~ubuntu-branches/ubuntu/oneiric/bogofilter/oneiric

« back to all changes in this revision

Viewing changes to trio/trio.c

Committer: Bazaar Package Importer
Author(s): Clint Adams
Date: 2004-06-27 09:22:31 UTC
Revision ID: james.westby@ubuntu.com-20040627092231-u26smic0nhp7rl4z

Tags: upstream-0.92.0

Import upstream version 0.92.0

files added:

AUTHORS

CHANGES-0.10

CHANGES-0.11

CHANGES-0.12

CHANGES-0.13

CHANGES-0.14

CHANGES-0.15

CHANGES-0.16

CHANGES-0.17

CHANGES-0.9x

COPYING

Doxyfile

INSTALL

METHODS

Makefile.am

Makefile.in

NEWS

README

README.cvs

RELEASE.NOTES-0.11

RELEASE.NOTES-0.12

RELEASE.NOTES-0.13

RELEASE.NOTES-0.14

RELEASE.NOTES-0.15

RELEASE.NOTES-0.16

RELEASE.NOTES-0.17

TODO

acinclude.m4

aclocal.m4

autogen.sh

bogofilter.cf.example

bogofilter.spec

bogofilter.spec.in

compile

config.guess

config.in

config.rpath

config.sub

configure

configure.ac

contrib

contrib/Makefile.am

contrib/Makefile.in

contrib/README.contrib

contrib/README.randomtrain

contrib/bogo.R

contrib/bogofilter-milter.pl

contrib/bogofilter-qfe

contrib/bogogrep.c

contrib/bogominitrain.pl

contrib/dot-qmail-bogofilter-default

contrib/mailfilter.example

contrib/mime.get.rfc822

contrib/parmtest.sh

contrib/printmaildir.pl

contrib/procmailrc.example

contrib/randomtrain

contrib/scramble

contrib/trainbogo.sh

depcomp

doc/Makefile.am

doc/Makefile.in

doc/README.db

doc/README.tdb

doc/README.validation

doc/bogofilter-SA-2002-01

doc/bogofilter-faq-fr.html

doc/bogofilter-faq.html

doc/bogofilter-tuning.HOWTO

doc/bogofilter.1in

doc/bogofilter.htmlin

doc/bogofilter.xml

doc/bogolexer.1in

doc/bogolexer.htmlin

doc/bogolexer.xml

doc/bogotune-faq.html

doc/bogotune.1in

doc/bogotune.htmlin

doc/bogotune.xml

doc/bogoupgrade.1in

doc/bogoupgrade.htmlin

doc/bogoupgrade.xml

doc/bogoutil.1in

doc/bogoutil.htmlin

doc/bogoutil.xml

doc/integrating-with-postfix

doc/integrating-with-qmail

doc/programmer

doc/programmer/README.RISC-OS

doc/programmer/README.freebsd

doc/programmer/README.hp-ux

doc/programmer/RISC-OS

doc/programmer/RISC-OS/gsl

doc/programmer/RISC-OS/gsl/Makefile

doc/programmer/RISC-OS/src

doc/programmer/RISC-OS/src/Makefile

gnugetopt

gnugetopt/getopt.c

gnugetopt/getopt.h

gnugetopt/getopt1.c

gsl/AUTHORS

gsl/README.bogofilter

gsl/cdf

gsl/cdf/chisq.c

gsl/cdf/gamma.c

gsl/err

gsl/err/error.c

gsl/err/stream.c

gsl/grep

gsl/gsl_cdf.h

gsl/gsl_errno.h

gsl/gsl_machine.h

gsl/gsl_math.h

gsl/gsl_message.h

gsl/gsl_nan.h

gsl/gsl_pow_int.h

gsl/gsl_precision.h

gsl/gsl_sf_elementary.h

gsl/gsl_sf_erf.h

gsl/gsl_sf_exp.h

gsl/gsl_sf_expint.h

gsl/gsl_sf_gamma.h

gsl/gsl_sf_log.h

gsl/gsl_sf_pow_int.h

gsl/gsl_sf_psi.h

gsl/gsl_sf_result.h

gsl/gsl_sf_trig.h

gsl/gsl_sf_zeta.h

gsl/gsl_sys.h

gsl/gsl_types.h

gsl/specfunc

gsl/specfunc/cheb_eval.c

gsl/specfunc/chebyshev.h

gsl/specfunc/check.h

gsl/specfunc/elementary.c

gsl/specfunc/erfc.c

gsl/specfunc/error.h

gsl/specfunc/eval.h

gsl/specfunc/exp.c

gsl/specfunc/expint.c

gsl/specfunc/gamma.c

gsl/specfunc/gamma_inc.c

gsl/specfunc/log.c

gsl/specfunc/psi.c

gsl/specfunc/trig.c

gsl/specfunc/zeta.c

gsl/sys

gsl/sys/coerce.c

gsl/sys/fdiv.c

gsl/sys/infnan.c

gsl/sys/minmax.c

gsl/sys/pow_int.c

install-sh

missing

mkinstalldirs

src/Makefile.am

src/Makefile.in

src/base64.c

src/base64.h

src/bf_exit.c

src/bftypes.h

src/bogoconfig.c

src/bogoconfig.h

src/bogofilter.c

src/bogofilter.h

src/bogohist.c

src/bogohist.h

src/bogohome.c

src/bogohome.h

src/bogolexer.c

src/bogoreader.c

src/bogoreader.h

src/bogotune.c

src/bogotune.h

src/bogoupgrade.in

src/bogoutil.c

src/bogowordfreq.c

src/bool.c

src/bool.h

src/buff.c

src/buff.h

src/charset.c

src/charset.h

src/collect.c

src/collect.h

src/common.h

src/configfile.c

src/configfile.h

src/configtest.c

src/datastore.c

src/datastore.h

src/datastore_db.c

src/datastore_db.h

src/datastore_qdbm.c

src/datastore_tdb.c

src/db_handle_props.h

src/debug.c

src/debug.h

src/debug.main.c

src/error.c

src/error.h

src/fgetsl.c

src/fgetsl.h

src/find_home.c

src/find_home.h

src/find_home.test.c

src/find_home_tildeexpand.c

src/find_home_user.c

src/format.c

src/format.h

src/globals.c

src/globals.h

src/lexer.c

src/lexer.h

src/lexer_v3.c

src/lexer_v3.l

src/main.c

src/maint.c

src/maint.h

src/memcmp.c

src/memdebug.c

src/memdebug.h

src/mime.c

src/mime.h

src/msgcounts.c

src/msgcounts.h

src/mysetvbuf.c

src/mysetvbuf.h

src/passthrough.c

src/passthrough.h

src/paths.c

src/paths.h

src/prob.c

src/prob.h

src/qp.c

src/qp.h

src/rand_sleep.c

src/rand_sleep.h

src/register.c

src/register.h

src/robx.c

src/robx.h

src/rstats.c

src/rstats.h

src/score.c

src/score.h

src/strerror.c

src/strlcat.3

src/strlcat.c

src/strlcpy.3

src/strlcpy.c

src/strtoul.c

src/swap.h

src/swap_32bit.c

src/system.c

src/system.h

src/tests

src/tests/Makefile.am

src/tests/Makefile.in

src/tests/README

src/tests/abortme.c

src/tests/deb64.c

src/tests/dehex.c

src/tests/deqp.c

src/tests/dumbhead.c

src/tests/escnp.c

src/tests/inputs

src/tests/inputs/dump.load.inp

src/tests/inputs/dump.load.upd

src/tests/inputs/good.mbx

src/tests/inputs/good.mbx.~1.1.~

src/tests/inputs/headerbody.txt

src/tests/inputs/lexer.inp

src/tests/inputs/lexer.mbx

src/tests/inputs/lexer.out

src/tests/inputs/msg.1.txt

src/tests/inputs/msg.2.txt

src/tests/inputs/msg.3.txt

src/tests/inputs/msg.4.txt

src/tests/inputs/msg.5.txt

src/tests/inputs/msg.6.txt

src/tests/inputs/msg.7.txt

src/tests/inputs/msg.8.txt

src/tests/inputs/msg.flex

src/tests/inputs/msg.obscured.URL

src/tests/inputs/msg.parsing.txt

src/tests/inputs/msg.regtest.n

src/tests/inputs/msg.regtest.s

src/tests/inputs/msg.rfc822.txt.gz

src/tests/inputs/msg.split.bg.0117.text

src/tests/inputs/msg.split.dr.0118.base64

src/tests/inputs/msg.split.gs.0119.text

src/tests/inputs/rmail.1.mbx

src/tests/inputs/rmail.2.mbx

src/tests/inputs/spam.mbx

src/tests/outputs

src/tests/outputs/0529

src/tests/outputs/0529/dump.load-1.out

src/tests/outputs/0529/dump.load-2.out

src/tests/outputs/0529/dump.load-3.out

src/tests/outputs/0529/dump.load-4.out

src/tests/outputs/0529/dump.load-5.out

src/tests/outputs/0529/dump.load-6.out

src/tests/outputs/MH.out

src/tests/outputs/bogolex.out

src/tests/outputs/bogoutil-hist.out

src/tests/outputs/bogoutil-hist.out.0528

src/tests/outputs/bogoutil-hist.out.orig

src/tests/outputs/bulkmode.out

src/tests/outputs/combined.out

src/tests/outputs/degen.out

src/tests/outputs/dump.load-1.out

src/tests/outputs/dump.load-2.out

src/tests/outputs/dump.load-3.out

src/tests/outputs/dump.load-4.out

src/tests/outputs/dump.load-5.out

src/tests/outputs/dump.load-6.out

src/tests/outputs/grftest.out

src/tests/outputs/ipaddr.ref

src/tests/outputs/ipaddr.ref~

src/tests/outputs/lexer.out

src/tests/outputs/maildir.out

src/tests/outputs/msg.1.f.v

src/tests/outputs/msg.1.g.v

src/tests/outputs/msg.1.r.v

src/tests/outputs/msg.2a.f.vv

src/tests/outputs/msg.2a.f.vvv

src/tests/outputs/msg.2a.g.vv

src/tests/outputs/msg.2a.g.vvv

src/tests/outputs/msg.2a.r.vv

src/tests/outputs/msg.2a.r.vvv

src/tests/outputs/msg.2b.f.vv

src/tests/outputs/msg.2b.f.vvv

src/tests/outputs/msg.2b.g.vv

src/tests/outputs/msg.2b.g.vvv

src/tests/outputs/msg.2b.r.vv

src/tests/outputs/msg.2b.r.vvv

src/tests/outputs/msg.3.f.vvv

src/tests/outputs/msg.3.g.vvv

src/tests/outputs/msg.3.r.vvv

src/tests/outputs/multiple.wordlists.ref

src/tests/outputs/multiple.wordlists.ref.new

src/tests/outputs/parsing.out

src/tests/outputs/separate.out

src/tests/outputs/split.out

src/tests/printcore

src/tests/run.sh

src/tests/spam_header_name.c

src/tests/t.MH

src/tests/t._abort

src/tests/t.abort

src/tests/t.bogodir

src/tests/t.bulkmode

src/tests/t.dump.load

src/tests/t.env

src/tests/t.escaped.html

src/tests/t.escaped.url

src/tests/t.folded_rfc2047

src/tests/t.frame

src/tests/t.grftest

src/tests/t.ignore_spam_header

src/tests/t.integrity

src/tests/t.integrity2

src/tests/t.integrity3

src/tests/t.lexer

src/tests/t.lexer.mbx

src/tests/t.lock1

src/tests/t.lock3

src/tests/t.maildir

src/tests/t.maint

src/tests/t.multiple.wordlists

src/tests/t.nonascii.replace

src/tests/t.nullstatsprefix

src/tests/t.parsing

src/tests/t.passthrough-hb

src/tests/t.regtest

src/tests/t.robx

src/tests/t.save

src/tests/t.score1

src/tests/t.score2

src/tests/t.skel

src/tests/t.split

src/tests/t.systest

src/tests/t.u_fpe

src/tests/t.upgrade.subnet.prefix

src/tests/t.valgrind

src/tests/t.wordhist

src/tests/u_fpe.c

src/tests/unsort.pl

src/tests/wantcore.c

src/textblock.c

src/textblock.h

src/token.c

src/token.h

src/transaction.c

src/transaction.h

src/tunelist.c

src/tunelist.h

src/uudecode.c

src/uudecode.h

src/version.c

src/version.sh

src/word.c

src/word.h

src/wordhash.c

src/wordhash.h

src/wordhash.main.c

src/wordlists.c

src/wordlists.h

src/wordlists_base.c

src/wordlists_base.h

src/xatof.c

src/xatoi.c

src/xatox.h

src/xcalloc.c

src/xmalloc.c

src/xmalloc.h

src/xmem_error.c

src/xmemrchr.c

src/xmemrchr.h

src/xrealloc.c

src/xstrdup.c

src/xstrdup.h

src/xstrlcat.c

src/xstrlcat.h

src/xstrlcpy.c

src/xstrlcpy.h

trio

trio/AUTHORS

trio/CHANGES

trio/Makefile.am

trio/Makefile.in

trio/README

trio/regression.c

trio/trio.c

trio/trio.h

trio/triodef.h

trio/trionan.c

trio/trionan.h

trio/triop.h

trio/triostr.c

trio/triostr.h

Show diffs side-by-side

added added

removed removed

trio/trio.c

/*************************************************************************

* $Id: trio.c,v 1.2 2003/10/29 14:31:52 m-a Exp $

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

* copyright notice and this permission notice appear in all copies.

* THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED

* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

* MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND

* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.

*************************************************************************

* A note to trio contributors:

* Avoid heap allocation at all costs to ensure that the trio functions

* are async-safe. The exceptions are the printf/fprintf functions, which

* uses fputc, and the asprintf functions and the <alloc> modifier, which

* by design are required to allocate form the heap.

************************************************************************/

* TODO:

* - Scan is probably too permissive about its modifiers.

* - C escapes in %#[] ?

* - Multibyte characters (done for format parsing, except scan groups)

* - Complex numbers? (C99 _Complex)

* - Boolean values? (C99 _Bool)

* - C99 NaN(n-char-sequence) missing. The n-char-sequence can be used

* to print the mantissa, e.g. NaN(0xc000000000000000)

* - Should we support the GNU %a alloc modifier? GNU has an ugly hack

* for %a, because C99 used %a for other purposes. If specified as

* %as or %a[ it is interpreted as the alloc modifier, otherwise as

* the C99 hex-float. This means that you cannot scan %as as a hex-float

* immediately followed by an 's'.

* - Scanning of collating symbols.

/*************************************************************************

* Trio include files

#include "triodef.h"

#include "trio.h"

#include "triop.h"

#include "trionan.h"

#if !defined(TRIO_MINIMAL)

# include "triostr.h"

#endif

/**************************************************************************

* Definitions

*************************************************************************/

#include <math.h>

#include <limits.h>

#include <float.h>

#if defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) || defined(USE_MULTIBYTE) || TRIO_WIDECHAR

# define TRIO_COMPILER_SUPPORTS_MULTIBYTE

# if !defined(MB_LEN_MAX)

# define MB_LEN_MAX 6

# endif

#endif

#if (defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1100)) || defined(TRIO_COMPILER_BCB)

# define TRIO_COMPILER_SUPPORTS_MSVC_INT

#endif

/*************************************************************************

* Generic definitions

#if !(defined(DEBUG) || defined(NDEBUG))

# define NDEBUG

#endif

#include <assert.h>

#include <ctype.h>

#if !defined(TRIO_COMPILER_SUPPORTS_C99)

# define isblank(x) (((x)==32) || ((x)==9))

#endif

#if defined(TRIO_COMPILER_ANCIENT)

# include <varargs.h>

#else

# include <stdarg.h>

#endif

#include <stddef.h>

#include <errno.h>

#ifndef NULL

# define NULL 0

#endif

100

#define NIL ((char)0)

101

#ifndef FALSE

102

# define FALSE (1 == 0)

103

# define TRUE (! FALSE)

104

#endif

105

#define BOOLEAN_T int

106

107

/* mincore() can be used for debugging purposes */

108

#define VALID(x) (NULL != (x))

109

110

#if TRIO_ERRORS

111

112

* Encode the error code and the position. This is decoded

113

* with TRIO_ERROR_CODE and TRIO_ERROR_POSITION.

114

115

# define TRIO_ERROR_RETURN(x,y) (- ((x) + ((y) << 8)))

116

#else

117

# define TRIO_ERROR_RETURN(x,y) (-1)

118

#endif

119

120

typedef unsigned long trio_flags_t;

121

122

123

/*************************************************************************

124

* Platform specific definitions

125

126

#if defined(TRIO_PLATFORM_UNIX)

127

# include <unistd.h>

128

# include <signal.h>

129

# include <locale.h>

130

# define USE_LOCALE

131

#endif /* TRIO_PLATFORM_UNIX */

132

#if defined(TRIO_PLATFORM_VMS)

133

# include <unistd.h>

134

#endif

135

#if defined(TRIO_PLATFORM_WIN32)

136

# include <io.h>

137

# define read _read

138

# define write _write

139

#endif /* TRIO_PLATFORM_WIN32 */

140

141

#if TRIO_WIDECHAR

142

# if defined(TRIO_COMPILER_SUPPORTS_ISO94)

143

# include <wchar.h>

144

# include <wctype.h>

145

typedef wchar_t trio_wchar_t;

146

typedef wint_t trio_wint_t;

147

# else

148

typedef char trio_wchar_t;

149

typedef int trio_wint_t;

150

# define WCONST(x) L ## x

151

# define WEOF EOF

152

# define iswalnum(x) isalnum(x)

153

# define iswalpha(x) isalpha(x)

154

# define iswblank(x) isblank(x)

155

# define iswcntrl(x) iscntrl(x)

156

# define iswdigit(x) isdigit(x)

157

# define iswgraph(x) isgraph(x)

158

# define iswlower(x) islower(x)

159

# define iswprint(x) isprint(x)

160

# define iswpunct(x) ispunct(x)

161

# define iswspace(x) isspace(x)

162

# define iswupper(x) isupper(x)

163

# define iswxdigit(x) isxdigit(x)

164

# endif

165

#endif

166

167

168

/*************************************************************************

169

* Compiler dependent definitions

170

171

172

/* Support for long long */

173

#ifndef __cplusplus

174

# if !defined(USE_LONGLONG)

175

# if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__)

176

# define USE_LONGLONG

177

# elif defined(TRIO_COMPILER_SUNPRO)

178

# define USE_LONGLONG

179

# elif defined(_LONG_LONG) || defined(_LONGLONG)

180

# define USE_LONGLONG

181

# endif

182

# endif

183

#endif

184

185

/* The extra long numbers */

186

#if defined(USE_LONGLONG)

187

typedef signed long long int trio_longlong_t;

188

typedef unsigned long long int trio_ulonglong_t;

189

#elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)

190

typedef signed __int64 trio_longlong_t;

191

typedef unsigned __int64 trio_ulonglong_t;

192

#else

193

typedef TRIO_SIGNED long int trio_longlong_t;

194

typedef unsigned long int trio_ulonglong_t;

195

#endif

196

197

/* Maximal and fixed integer types */

198

#if defined(TRIO_COMPILER_SUPPORTS_C99)

199

# include <stdint.h>

200

typedef intmax_t trio_intmax_t;

201

typedef uintmax_t trio_uintmax_t;

202

typedef int8_t trio_int8_t;

203

typedef int16_t trio_int16_t;

204

typedef int32_t trio_int32_t;

205

typedef int64_t trio_int64_t;

206

#elif defined(TRIO_COMPILER_SUPPORTS_UNIX98)

207

# include <inttypes.h>

208

typedef intmax_t trio_intmax_t;

209

typedef uintmax_t trio_uintmax_t;

210

typedef int8_t trio_int8_t;

211

typedef int16_t trio_int16_t;

212

typedef int32_t trio_int32_t;

213

typedef int64_t trio_int64_t;

214

#elif defined(TRIO_COMPILER_SUPPORTS_MSVC_INT)

215

typedef trio_longlong_t trio_intmax_t;

216

typedef trio_ulonglong_t trio_uintmax_t;

217

typedef __int8 trio_int8_t;

218

typedef __int16 trio_int16_t;

219

typedef __int32 trio_int32_t;

220

typedef __int64 trio_int64_t;

221

#else

222

typedef trio_longlong_t trio_intmax_t;

223

typedef trio_ulonglong_t trio_uintmax_t;

224

# if defined(TRIO_INT8_T)

225

typedef TRIO_INT8_T trio_int8_t;

226

# else

227

typedef TRIO_SIGNED char trio_int8_t;

228

# endif

229

# if defined(TRIO_INT16_T)

230

typedef TRIO_INT16_T trio_int16_t;

231

# else

232

typedef TRIO_SIGNED short trio_int16_t;

233

# endif

234

# if defined(TRIO_INT32_T)

235

typedef TRIO_INT32_T trio_int32_t;

236

# else

237

typedef TRIO_SIGNED int trio_int32_t;

238

# endif

239

# if defined(TRIO_INT64_T)

240

typedef TRIO_INT64_T trio_int64_t;

241

# else

242

typedef trio_longlong_t trio_int64_t;

243

# endif

244

#endif

245

246

#if !(defined(TRIO_COMPILER_SUPPORTS_C99) \

247

|| defined(TRIO_COMPILER_SUPPORTS_UNIX01))

248

# define floorl(x) floor((double)(x))

249

# define fmodl(x,y) fmod((double)(x),(double)(y))

250

# define powl(x,y) pow((double)(x),(double)(y))

251

#endif

252

253

#define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x))

254

255

/*************************************************************************

256

* Internal Definitions

257

258

259

#ifndef DECIMAL_DIG

260

# define DECIMAL_DIG DBL_DIG

261

#endif

262

263

/* Long double sizes */

264

#ifdef LDBL_DIG

265

# define MAX_MANTISSA_DIGITS LDBL_DIG

266

# define MAX_EXPONENT_DIGITS 4

267

# define MAX_DOUBLE_DIGITS LDBL_MAX_10_EXP

268

#else

269

# define MAX_MANTISSA_DIGITS DECIMAL_DIG

270

# define MAX_EXPONENT_DIGITS 3

271

# define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP

272

#endif

273

274

#if defined(TRIO_COMPILER_ANCIENT) || !defined(LDBL_DIG)

275

# undef LDBL_DIG

276

# undef LDBL_MANT_DIG

277

# undef LDBL_EPSILON

278

# define LDBL_DIG DBL_DIG

279

# define LDBL_MANT_DIG DBL_MANT_DIG

280

# define LDBL_EPSILON DBL_EPSILON

281

#endif

282

283

/* The maximal number of digits is for base 2 */

284

#define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT)

285

/* The width of a pointer. The number of bits in a hex digit is 4 */

286

#define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)

287

288

/* Infinite and Not-A-Number for floating-point */

289

#define INFINITE_LOWER "inf"

290

#define INFINITE_UPPER "INF"

291

#define LONG_INFINITE_LOWER "infinite"

292

#define LONG_INFINITE_UPPER "INFINITE"

293

#define NAN_LOWER "nan"

294

#define NAN_UPPER "NAN"

295

296

/* Various constants */

297

enum {

298

TYPE_PRINT = 1,

299

TYPE_SCAN = 2,

300

301

/* Flags. FLAGS_LAST must be less than ULONG_MAX */

302

FLAGS_NEW = 0,

303

FLAGS_STICKY = 1,

304

FLAGS_SPACE = 2 * FLAGS_STICKY,

305

FLAGS_SHOWSIGN = 2 * FLAGS_SPACE,

306

FLAGS_LEFTADJUST = 2 * FLAGS_SHOWSIGN,

307

FLAGS_ALTERNATIVE = 2 * FLAGS_LEFTADJUST,

308

FLAGS_SHORT = 2 * FLAGS_ALTERNATIVE,

309

FLAGS_SHORTSHORT = 2 * FLAGS_SHORT,

310

FLAGS_LONG = 2 * FLAGS_SHORTSHORT,

311

FLAGS_QUAD = 2 * FLAGS_LONG,

312

FLAGS_LONGDOUBLE = 2 * FLAGS_QUAD,

313

FLAGS_SIZE_T = 2 * FLAGS_LONGDOUBLE,

314

FLAGS_PTRDIFF_T = 2 * FLAGS_SIZE_T,

315

FLAGS_INTMAX_T = 2 * FLAGS_PTRDIFF_T,

316

FLAGS_NILPADDING = 2 * FLAGS_INTMAX_T,

317

FLAGS_UNSIGNED = 2 * FLAGS_NILPADDING,

318

FLAGS_UPPER = 2 * FLAGS_UNSIGNED,

319

FLAGS_WIDTH = 2 * FLAGS_UPPER,

320

FLAGS_WIDTH_PARAMETER = 2 * FLAGS_WIDTH,

321

FLAGS_PRECISION = 2 * FLAGS_WIDTH_PARAMETER,

322

FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION,

323

FLAGS_BASE = 2 * FLAGS_PRECISION_PARAMETER,

324

FLAGS_BASE_PARAMETER = 2 * FLAGS_BASE,

325

FLAGS_FLOAT_E = 2 * FLAGS_BASE_PARAMETER,

326

FLAGS_FLOAT_G = 2 * FLAGS_FLOAT_E,

327

FLAGS_QUOTE = 2 * FLAGS_FLOAT_G,

328

FLAGS_WIDECHAR = 2 * FLAGS_QUOTE,

329

FLAGS_ALLOC = 2 * FLAGS_WIDECHAR,

330

FLAGS_IGNORE = 2 * FLAGS_ALLOC,

331

FLAGS_IGNORE_PARAMETER = 2 * FLAGS_IGNORE,

332

FLAGS_VARSIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER,

333

FLAGS_FIXED_SIZE = 2 * FLAGS_VARSIZE_PARAMETER,

334

FLAGS_LAST = FLAGS_FIXED_SIZE,

335

/* Reused flags */

336

FLAGS_EXCLUDE = FLAGS_SHORT,

337

FLAGS_USER_DEFINED = FLAGS_IGNORE,

338

FLAGS_ROUNDING = FLAGS_INTMAX_T,

339

/* Compounded flags */

340

FLAGS_ALL_VARSIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T,

341

FLAGS_ALL_SIZES = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT,

342

343

NO_POSITION = -1,

344

NO_WIDTH = 0,

345

NO_PRECISION = -1,

346

NO_SIZE = -1,

347

348

/* Do not change these */

349

NO_BASE = -1,

350

MIN_BASE = 2,

351

MAX_BASE = 36,

352

BASE_BINARY = 2,

353

BASE_OCTAL = 8,

354

BASE_DECIMAL = 10,

355

BASE_HEX = 16,

356

357

/* Maximal number of allowed parameters */

358

MAX_PARAMETERS = 64,

359

/* Maximal number of characters in class */

360

MAX_CHARACTER_CLASS = UCHAR_MAX + 1,

361

362

/* Maximal string lengths for user-defined specifiers */

363

MAX_USER_NAME = 64,

364

MAX_USER_DATA = 256,

365

366

/* Maximal length of locale separator strings */

367

MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,

368

/* Maximal number of integers in grouping */

369

MAX_LOCALE_GROUPS = 64,

370

371

/* Initial size of asprintf buffer */

372

DYNAMIC_START_SIZE = 32

373

};

374

375

#define NO_GROUPING ((int)CHAR_MAX)

376

377

/* Fundamental formatting parameter types */

378

#define FORMAT_UNKNOWN 0

379

#define FORMAT_INT 1

380

#define FORMAT_DOUBLE 2

381

#define FORMAT_CHAR 3

382

#define FORMAT_STRING 4

383

#define FORMAT_POINTER 5

384

#define FORMAT_COUNT 6

385

#define FORMAT_PARAMETER 7

386

#define FORMAT_GROUP 8

387

#if TRIO_GNU

388

# define FORMAT_ERRNO 9

389

#endif

390

#if TRIO_EXTENSION

391

# define FORMAT_USER_DEFINED 10

392

#endif

393

394

/* Character constants */

395

#define CHAR_IDENTIFIER '%'

396

#define CHAR_BACKSLASH '\\'

397

#define CHAR_QUOTE '\"'

398

#define CHAR_ADJUST ' '

399

400

/* Character class expressions */

401

#define CLASS_ALNUM "[:alnum:]"

402

#define CLASS_ALPHA "[:alpha:]"

403

#define CLASS_BLANK "[:blank:]"

404

#define CLASS_CNTRL "[:cntrl:]"

405

#define CLASS_DIGIT "[:digit:]"

406

#define CLASS_GRAPH "[:graph:]"

407

#define CLASS_LOWER "[:lower:]"

408

#define CLASS_PRINT "[:print:]"

409

#define CLASS_PUNCT "[:punct:]"

410

#define CLASS_SPACE "[:space:]"

411

#define CLASS_UPPER "[:upper:]"

412

#define CLASS_XDIGIT "[:xdigit:]"

413

414

415

* SPECIFIERS:

416

417

418

* a Hex-float

419

* A Hex-float

420

* c Character

421

* C Widechar character (wint_t)

422

* d Decimal

423

* e Float

424

* E Float

425

* F Float

426

* F Float

427

* g Float

428

* G Float

429

* i Integer

430

* m Error message

431

* n Count

432

* o Octal

433

* p Pointer

434

* s String

435

* S Widechar string (wchar_t *)

436

* u Unsigned

437

* x Hex

438

* X Hex

439

* [] Group

440

* <> User-defined

441

442

* Reserved:

443

444

* D Binary Coded Decimal %D(length,precision) (OS/390)

445

446

#define SPECIFIER_CHAR 'c'

447

#define SPECIFIER_STRING 's'

448

#define SPECIFIER_DECIMAL 'd'

449

#define SPECIFIER_INTEGER 'i'

450

#define SPECIFIER_UNSIGNED 'u'

451

#define SPECIFIER_OCTAL 'o'

452

#define SPECIFIER_HEX 'x'

453

#define SPECIFIER_HEX_UPPER 'X'

454

#define SPECIFIER_FLOAT_E 'e'

455

#define SPECIFIER_FLOAT_E_UPPER 'E'

456

#define SPECIFIER_FLOAT_F 'f'

457

#define SPECIFIER_FLOAT_F_UPPER 'F'

458

#define SPECIFIER_FLOAT_G 'g'

459

#define SPECIFIER_FLOAT_G_UPPER 'G'

460

#define SPECIFIER_POINTER 'p'

461

#define SPECIFIER_GROUP '['

462

#define SPECIFIER_UNGROUP ']'

463

#define SPECIFIER_COUNT 'n'

464

#if TRIO_UNIX98

465

# define SPECIFIER_CHAR_UPPER 'C'

466

# define SPECIFIER_STRING_UPPER 'S'

467

#endif

468

#if TRIO_C99

469

# define SPECIFIER_HEXFLOAT 'a'

470

# define SPECIFIER_HEXFLOAT_UPPER 'A'

471

#endif

472

#if TRIO_GNU

473

# define SPECIFIER_ERRNO 'm'

474

#endif

475

#if TRIO_EXTENSION

476

# define SPECIFIER_BINARY 'b'

477

# define SPECIFIER_BINARY_UPPER 'B'

478

# define SPECIFIER_USER_DEFINED_BEGIN '<'

479

# define SPECIFIER_USER_DEFINED_END '>'

480

# define SPECIFIER_USER_DEFINED_SEPARATOR ':'

481

#endif

482

483

484

* QUALIFIERS:

485

486

487

* Numbers = d,i,o,u,x,X

488

* Float = a,A,e,E,f,F,g,G

489

* String = s

490

* Char = c

491

492

493

* 9$ Position

494

* Use the 9th parameter. 9 can be any number between 1 and

495

* the maximal argument

496

497

* 9 Width

498

* Set width to 9. 9 can be any number, but must not be postfixed

499

* by '$'

500

501

* h Short

502

* Numbers:

503

* (unsigned) short int

504

505

* hh Short short

506

* Numbers:

507

* (unsigned) char

508

509

* l Long

510

* Numbers:

511

* (unsigned) long int

512

* String:

513

* as the S specifier

514

* Char:

515

* as the C specifier

516

517

* ll Long Long

518

* Numbers:

519

* (unsigned) long long int

520

521

* L Long Double

522

* Float

523

* long double

524

525

* # Alternative

526

* Float:

527

* Decimal-point is always present

528

* String:

529

* non-printable characters are handled as \number

530

531

* Spacing

532

533

* + Sign

534

535

* - Alignment

536

537

* . Precision

538

539

* * Parameter

540

* print: use parameter

541

* scan: no parameter (ignore)

542

543

* q Quad

544

545

* Z size_t

546

547

* w Widechar

548

549

* ' Thousands/quote

550

* Numbers:

551

* Integer part grouped in thousands

552

* Binary numbers:

553

* Number grouped in nibbles (4 bits)

554

* String:

555

* Quoted string

556

557

* j intmax_t

558

* t prtdiff_t

559

* z size_t

560

561

* ! Sticky

562

* @ Parameter (for both print and scan)

563

564

* I n-bit Integer

565

* Numbers:

566

* The following options exists

567

* I8 = 8-bit integer

568

* I16 = 16-bit integer

569

* I32 = 32-bit integer

570

* I64 = 64-bit integer

571

572

#define QUALIFIER_POSITION '$'

573

#define QUALIFIER_SHORT 'h'

574

#define QUALIFIER_LONG 'l'

575

#define QUALIFIER_LONG_UPPER 'L'

576

#define QUALIFIER_ALTERNATIVE '#'

577

#define QUALIFIER_SPACE ' '

578

#define QUALIFIER_PLUS '+'

579

#define QUALIFIER_MINUS '-'

580

#define QUALIFIER_DOT '.'

581

#define QUALIFIER_STAR '*'

582

#define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */

583

#if TRIO_C99

584

# define QUALIFIER_SIZE_T 'z'

585

# define QUALIFIER_PTRDIFF_T 't'

586

# define QUALIFIER_INTMAX_T 'j'

587

#endif

588

#if TRIO_BSD || TRIO_GNU

589

# define QUALIFIER_QUAD 'q'

590

#endif

591

#if TRIO_GNU

592

# define QUALIFIER_SIZE_T_UPPER 'Z'

593

#endif

594

#if TRIO_MISC

595

# define QUALIFIER_WIDECHAR 'w'

596

#endif

597

#if TRIO_MICROSOFT

598

# define QUALIFIER_FIXED_SIZE 'I'

599

#endif

600

#if TRIO_EXTENSION

601

# define QUALIFIER_QUOTE '\''

602

# define QUALIFIER_STICKY '!'

603

# define QUALIFIER_VARSIZE '&' /* This should remain undocumented */

604

# define QUALIFIER_PARAM '@' /* Experimental */

605

# define QUALIFIER_COLON ':' /* For scanlists */

606

# define QUALIFIER_EQUAL '=' /* For scanlists */

607

# define QUALIFIER_ROUNDING_UPPER 'R'

608

#endif

609

610

611

/*************************************************************************

612

613

* Internal Structures

614

615

*************************************************************************/

616

617

/* Parameters */

618

typedef struct {

619

/* An indication of which entry in the data union is used */

620

int type;

621

/* The flags */

622

trio_flags_t flags;

623

/* The width qualifier */

624

int width;

625

/* The precision qualifier */

626

int precision;

627

/* The base qualifier */

628

int base;

629

/* The size for the variable size qualifier */

630

int varsize;

631

/* The marker of the end of the specifier */

632

int indexAfterSpecifier;

633

/* The data from the argument list */

634

union {

635

char *string;

636

#if TRIO_WIDECHAR

637

trio_wchar_t *wstring;

638

#endif

639

trio_pointer_t pointer;

640

union {

641

trio_intmax_t as_signed;

642

trio_uintmax_t as_unsigned;

643

} number;

644

double doubleNumber;

645

double *doublePointer;

646

trio_long_double_t longdoubleNumber;

647

trio_long_double_t *longdoublePointer;

648

int errorNumber;

649

} data;

650

/* For the user-defined specifier */

651

char user_name[MAX_USER_NAME];

652

char user_data[MAX_USER_DATA];

653

} trio_parameter_t;

654

655

/* Container for customized functions */

656

typedef struct {

657

union {

658

trio_outstream_t out;

659

trio_instream_t in;

660

} stream;

661

trio_pointer_t closure;

662

} trio_custom_t;

663

664

/* General trio "class" */

665

typedef struct _trio_class_t {

666

667

* The function to write characters to a stream.

668

669

void (*OutStream) TRIO_PROTO((struct _trio_class_t *, int));

670

671

* The function to read characters from a stream.

672

673

void (*InStream) TRIO_PROTO((struct _trio_class_t *, int *));

674

675

* The current location in the stream.

676

677

trio_pointer_t location;

678

679

* The character currently being processed.

680

681

int current;

682

683

* The number of characters that would have been written/read

684

* if there had been sufficient space.

685

686

int processed;

687

688

* The number of characters that are actually written/read.

689

* Processed and committed will only differ for the *nprintf

690

* and *nscanf functions.

691

692

int committed;

693

694

* The upper limit of characters that may be written/read.

695

696

int max;

697

698

* The last output error that was detected.

699

700

int error;

701

} trio_class_t;

702

703

/* References (for user-defined callbacks) */

704

typedef struct _trio_reference_t {

705

trio_class_t *data;

706

trio_parameter_t *parameter;

707

} trio_reference_t;

708

709

/* Registered entries (for user-defined callbacks) */

710

typedef struct _trio_userdef_t {

711

struct _trio_userdef_t *next;

712

trio_callback_t callback;

713

char *name;

714

} trio_userdef_t;

715

716

/*************************************************************************

717

718

* Internal Variables

719

720

*************************************************************************/

721

722

static TRIO_CONST char rcsid[] = "@(#)$Id: trio.c,v 1.2 2003/10/29 14:31:52 m-a Exp $";

723

724

725

* Need this to workaround a parser bug in HP C/iX compiler that fails

726

* to resolves macro definitions that includes type 'long double',

727

* e.g: va_arg(arg_ptr, long double)

728

729

#if defined(TRIO_PLATFORM_MPEIX)

730

static TRIO_CONST trio_long_double_t ___dummy_long_double = 0;

731

#endif

732

733

static TRIO_CONST char internalNullString[] = "(nil)";

734

735

#if defined(USE_LOCALE)

736

static struct lconv *internalLocaleValues = NULL;

737

#endif

738

739

740

* UNIX98 says "in a locale where the radix character is not defined,

741

* the radix character defaults to a period (.)"

742

743

static int internalDecimalPointLength = 1;

744

static int internalThousandSeparatorLength = 1;

745

static char internalDecimalPoint = '.';

746

static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ".";

747

static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ",";

748

static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING };

749

750

static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";

751

static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

752

static BOOLEAN_T internalDigitsUnconverted = TRUE;

753

static int internalDigitArray[128];

754

#if TRIO_EXTENSION

755

static BOOLEAN_T internalCollationUnconverted = TRUE;

756

static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS];

757

#endif

758

759

#if TRIO_EXTENSION

760

static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL;

761

static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL;

762

static trio_userdef_t *internalUserDef = NULL;

763

#endif

764

765

766

/*************************************************************************

767

768

* Internal Functions

769

770

************************************************************************/

771

772

#if defined(TRIO_MINIMAL)

773

# define TRIO_STRING_PUBLIC static

774

# include "triostr.c"

775

#endif /* defined(TRIO_MINIMAL) */

776

777

/*************************************************************************

778

* TrioIsQualifier

779

780

* Description:

781

* Remember to add all new qualifiers to this function.

782

* QUALIFIER_POSITION must not be added.

783

784

TRIO_PRIVATE BOOLEAN_T

785

TrioIsQualifier

786

TRIO_ARGS1((character),

787

TRIO_CONST char character)

788

{

789

/* QUALIFIER_POSITION is not included */

790

switch (character)

791

{

792

case '0': case '1': case '2': case '3': case '4':

793

case '5': case '6': case '7': case '8': case '9':

794

case QUALIFIER_PLUS:

795

case QUALIFIER_MINUS:

796

case QUALIFIER_SPACE:

797

case QUALIFIER_DOT:

798

case QUALIFIER_STAR:

799

case QUALIFIER_ALTERNATIVE:

800

case QUALIFIER_SHORT:

801

case QUALIFIER_LONG:

802

case QUALIFIER_LONG_UPPER:

803

case QUALIFIER_CIRCUMFLEX:

804

#if defined(QUALIFIER_SIZE_T)

805

case QUALIFIER_SIZE_T:

806

#endif

807

#if defined(QUALIFIER_PTRDIFF_T)

808

case QUALIFIER_PTRDIFF_T:

809

#endif

810

#if defined(QUALIFIER_INTMAX_T)

811

case QUALIFIER_INTMAX_T:

812

#endif

813

#if defined(QUALIFIER_QUAD)

814

case QUALIFIER_QUAD:

815

#endif

816

#if defined(QUALIFIER_SIZE_T_UPPER)

817

case QUALIFIER_SIZE_T_UPPER:

818

#endif

819

#if defined(QUALIFIER_WIDECHAR)

820

case QUALIFIER_WIDECHAR:

821

#endif

822

#if defined(QUALIFIER_QUOTE)

823

case QUALIFIER_QUOTE:

824

#endif

825

#if defined(QUALIFIER_STICKY)

826

case QUALIFIER_STICKY:

827

#endif

828

#if defined(QUALIFIER_VARSIZE)

829

case QUALIFIER_VARSIZE:

830

#endif

831

#if defined(QUALIFIER_PARAM)

832

case QUALIFIER_PARAM:

833

#endif

834

#if defined(QUALIFIER_FIXED_SIZE)

835

case QUALIFIER_FIXED_SIZE:

836

#endif

837

#if defined(QUALIFIER_ROUNDING_UPPER)

838

case QUALIFIER_ROUNDING_UPPER:

839

#endif

840

return TRUE;

841

default:

842

return FALSE;

843

}

844

}

845

846

/*************************************************************************

847

* TrioSetLocale

848

849

#if defined(USE_LOCALE)

850

TRIO_PRIVATE void

851

TrioSetLocale(TRIO_NOARGS)

852

{

853

internalLocaleValues = (struct lconv *)localeconv();

854

if (internalLocaleValues)

855

{

856

if ((internalLocaleValues->decimal_point) &&

857

(internalLocaleValues->decimal_point[0] != NIL))

858

{

859

internalDecimalPointLength = trio_length(internalLocaleValues->decimal_point);

860

if (internalDecimalPointLength == 1)

861

{

862

internalDecimalPoint = internalLocaleValues->decimal_point[0];

863

}

864

else

865

{

866

internalDecimalPoint = NIL;

867

trio_copy_max(internalDecimalPointString,

868

sizeof(internalDecimalPointString),

869

internalLocaleValues->decimal_point);

870

}

871

}

872

if ((internalLocaleValues->thousands_sep) &&

873

(internalLocaleValues->thousands_sep[0] != NIL))

874

{

875

trio_copy_max(internalThousandSeparator,

876

sizeof(internalThousandSeparator),

877

internalLocaleValues->thousands_sep);

878

internalThousandSeparatorLength = trio_length(internalThousandSeparator);

879

}

880

if ((internalLocaleValues->grouping) &&

881

(internalLocaleValues->grouping[0] != NIL))

882

{

883

trio_copy_max(internalGrouping,

884

sizeof(internalGrouping),

885

internalLocaleValues->grouping);

886

}

887

}

888

}

889

#endif /* defined(USE_LOCALE) */

890

891

TRIO_PRIVATE int

892

TrioCalcThousandSeparatorLength

893

TRIO_ARGS1((digits),

894

int digits)

895

{

896

#if TRIO_EXTENSION

897

int count = 0;

898

int step = NO_GROUPING;

899

char *groupingPointer = internalGrouping;

900

901

while (digits > 0)

902

{

903

if (*groupingPointer == CHAR_MAX)

904

{

905

/* Disable grouping */

906

break; /* while */

907

}

908

else if (*groupingPointer == 0)

909

{

910

/* Repeat last group */

911

if (step == NO_GROUPING)

912

{

913

/* Error in locale */

914

break; /* while */

915

}

916

}

917

else

918

{

919

step = *groupingPointer++;

920

}

921

if (digits > step)

922

count += internalThousandSeparatorLength;

923

digits -= step;

924

}

925

return count;

926

#else

927

return 0;

928

#endif

929

}

930

931

TRIO_PRIVATE BOOLEAN_T

932

TrioFollowedBySeparator

933

TRIO_ARGS1((position),

934

int position)

935

{

936

#if TRIO_EXTENSION

937

int step = 0;

938

char *groupingPointer = internalGrouping;

939

940

position--;

941

if (position == 0)

942

return FALSE;

943

while (position > 0)

944

{

945

if (*groupingPointer == CHAR_MAX)

946

{

947

/* Disable grouping */

948

break; /* while */

949

}

950

else if (*groupingPointer != 0)

951

{

952

step = *groupingPointer++;

953

}

954

if (step == 0)

955

break;

956

position -= step;

957

}

958

return (position == 0);

959

#else

960

return FALSE;

961

#endif

962

}

963

964

/*************************************************************************

965

* TrioGetPosition

966

967

* Get the %n$ position.

968

969

TRIO_PRIVATE int

970

TrioGetPosition

971

TRIO_ARGS2((format, indexPointer),

972

TRIO_CONST char *format,

973

int *indexPointer)

974

{

975

#if TRIO_UNIX98

976

char *tmpformat;

977

int number = 0;

978

int index = *indexPointer;

979

980

number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL);

981

index = (int)(tmpformat - format);

982

if ((number != 0) && (QUALIFIER_POSITION == format[index++]))

983

{

984

*indexPointer = index;

985

986

* number is decreased by 1, because n$ starts from 1, whereas

987

* the array it is indexing starts from 0.

988

989

return number - 1;

990

}

991

#endif

992

return NO_POSITION;

993

}

994

995

#if TRIO_EXTENSION

996

/*************************************************************************

997

* TrioFindNamespace

998

999

* Find registered user-defined specifier.

1000

* The prev argument is used for optimization only.

1001

1002

TRIO_PRIVATE trio_userdef_t *

1003

TrioFindNamespace

1004

TRIO_ARGS2((name, prev),

1005

TRIO_CONST char *name,

1006

trio_userdef_t **prev)

1007

{

1008

trio_userdef_t *def;

1009

1010

if (internalEnterCriticalRegion)

1011

(void)internalEnterCriticalRegion(NULL);

1012

1013

for (def = internalUserDef; def; def = def->next)

1014

{

1015

/* Case-sensitive string comparison */

1016

if (trio_equal_case(def->name, name))

1017

break;

1018

1019

if (prev)

1020

*prev = def;

1021

}

1022

1023

if (internalLeaveCriticalRegion)

1024

(void)internalLeaveCriticalRegion(NULL);

1025

1026

return def;

1027

}

1028

#endif

1029

1030

/*************************************************************************

1031

* TrioPower

1032

1033

* Description:

1034

* Calculate pow(base, exponent), where number and exponent are integers.

1035

1036

TRIO_PRIVATE trio_long_double_t

1037

TrioPower

1038

TRIO_ARGS2((number, exponent),

1039

int number,

1040

int exponent)

1041

{

1042

trio_long_double_t result;

1043

1044

if (number == 10)

1045

{

1046

switch (exponent)

1047

{

1048

/* Speed up calculation of common cases */

1049

case 0:

1050

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E-1);

1051

break;

1052

case 1:

1053

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+0);

1054

break;

1055

case 2:

1056

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+1);

1057

break;

1058

case 3:

1059

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+2);

1060

break;

1061

case 4:

1062

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+3);

1063

break;

1064

case 5:

1065

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+4);

1066

break;

1067

case 6:

1068

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+5);

1069

break;

1070

case 7:

1071

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+6);

1072

break;

1073

case 8:

1074

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+7);

1075

break;

1076

case 9:

1077

result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+8);

1078

break;

1079

default:

1080

result = powl((trio_long_double_t)number,

1081

(trio_long_double_t)exponent);

1082

break;

1083

}

1084

}

1085

else

1086

{

1087

return powl((trio_long_double_t)number, (trio_long_double_t)exponent);

1088

}

1089

return result;

1090

}

1091

1092

/*************************************************************************

1093

* TrioLogarithm

1094

1095

TRIO_PRIVATE double

1096

TrioLogarithm

1097

TRIO_ARGS2((number, base),

1098

double number,

1099

int base)

1100

{

1101

double result;

1102

1103

if (number <= 0.0)

1104

{

1105

/* xlC crashes on log(0) */

1106

result = (number == 0.0) ? trio_ninf() : trio_nan();

1107

}

1108

else

1109

{

1110

if (base == 10)

1111

{

1112

result = log10(number);

1113

}

1114

else

1115

{

1116

result = log10(number) / log10((double)base);

1117

}

1118

}

1119

return result;

1120

}

1121

1122

/*************************************************************************

1123

* TrioLogarithmBase

1124

1125

TRIO_PRIVATE double

1126

TrioLogarithmBase

1127

TRIO_ARGS1((base),

1128

int base)

1129

{

1130

switch (base)

1131

{

1132

case BASE_BINARY : return 1.0;

1133

case BASE_OCTAL : return 3.0;

1134

case BASE_DECIMAL: return 3.321928094887362345;

1135

case BASE_HEX : return 4.0;

1136

default : return TrioLogarithm((double)base, 2);

1137

}

1138

}

1139

1140

/*************************************************************************

1141

* TrioParse

1142

1143

* Description:

1144

* Parse the format string

1145

1146

TRIO_PRIVATE int

1147

TrioParse

1148

TRIO_ARGS5((type, format, parameters, arglist, argarray),

1149

int type,

1150

TRIO_CONST char *format,

1151

trio_parameter_t *parameters,

1152

va_list *arglist,

1153

trio_pointer_t *argarray)

1154

{

1155

/* Count the number of times a parameter is referenced */

1156

unsigned short usedEntries[MAX_PARAMETERS];

1157

/* Parameter counters */

1158

int parameterPosition;

1159

int currentParam;

1160

int maxParam = -1;

1161

/* Utility variables */

1162

trio_flags_t flags;

1163

int width;

1164

int precision;

1165

int varsize;

1166

int base;

1167

int index; /* Index into formatting string */

1168

int dots; /* Count number of dots in modifier part */

1169

BOOLEAN_T positional; /* Does the specifier have a positional? */

1170

BOOLEAN_T gotSticky = FALSE; /* Are there any sticky modifiers at all? */

1171

1172

* indices specifies the order in which the parameters must be

1173

* read from the va_args (this is necessary to handle positionals)

1174

1175

int indices[MAX_PARAMETERS];

1176

int pos = 0;

1177

/* Various variables */

1178

char ch;

1179

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

1180

int charlen;

1181

#endif

1182

int save_errno;

1183

int i = -1;

1184

int num;

1185

char *tmpformat;

1186

1187

/* One and only one of arglist and argarray must be used */

1188

assert((arglist != NULL) ^ (argarray != NULL));

1189

1190

1191

* The 'parameters' array is not initialized, but we need to

1192

* know which entries we have used.

1193

1194

memset(usedEntries, 0, sizeof(usedEntries));

1195

1196

save_errno = errno;

1197

index = 0;

1198

parameterPosition = 0;

1199

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

1200

(void)mblen(NULL, 0);

1201

#endif

1202

1203

while (format[index])

1204

{

1205

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

1206

if (! isascii(format[index]))

1207

{

1208

1209

* Multibyte characters cannot be legal specifiers or

1210

* modifiers, so we skip over them.

1211

1212

charlen = mblen(&format[index], MB_LEN_MAX);

1213

index += (charlen > 0) ? charlen : 1;

1214

continue; /* while */

1215

}

1216

#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */

1217

if (CHAR_IDENTIFIER == format[index++])

1218

{

1219

if (CHAR_IDENTIFIER == format[index])

1220

{

1221

index++;

1222

continue; /* while */

1223

}

1224

1225

flags = FLAGS_NEW;

1226

dots = 0;

1227

currentParam = TrioGetPosition(format, &index);

1228

positional = (NO_POSITION != currentParam);

1229

if (!positional)

1230

{

1231

/* We have no positional, get the next counter */

1232

currentParam = parameterPosition;

1233

}

1234

if(currentParam >= MAX_PARAMETERS)

1235

{

1236

/* Bail out completely to make the error more obvious */

1237

return TRIO_ERROR_RETURN(TRIO_ETOOMANY, index);

1238

}

1239

1240

if (currentParam > maxParam)

1241

maxParam = currentParam;

1242

1243

/* Default values */

1244

width = NO_WIDTH;

1245

precision = NO_PRECISION;

1246

base = NO_BASE;

1247

varsize = NO_SIZE;

1248

1249

while (TrioIsQualifier(format[index]))

1250

{

1251

ch = format[index++];

1252

1253

switch (ch)

1254

{

1255

case QUALIFIER_SPACE:

1256

flags |= FLAGS_SPACE;

1257

break;

1258

1259

case QUALIFIER_PLUS:

1260

flags |= FLAGS_SHOWSIGN;

1261

break;

1262

1263

case QUALIFIER_MINUS:

1264

flags |= FLAGS_LEFTADJUST;

1265

flags &= ~FLAGS_NILPADDING;

1266

break;

1267

1268

case QUALIFIER_ALTERNATIVE:

1269

flags |= FLAGS_ALTERNATIVE;

1270

break;

1271

1272

case QUALIFIER_DOT:

1273

if (dots == 0) /* Precision */

1274

{

1275

dots++;

1276

1277

/* Skip if no precision */

1278

if (QUALIFIER_DOT == format[index])

1279

break;

1280

1281

/* After the first dot we have the precision */

1282

flags |= FLAGS_PRECISION;

1283

if ((QUALIFIER_STAR == format[index])

1284

#if defined(QUALIFIER_PARAM)

1285

|| (QUALIFIER_PARAM == format[index])

1286

#endif

1287

)

1288

{

1289

index++;

1290

flags |= FLAGS_PRECISION_PARAMETER;

1291

1292

precision = TrioGetPosition(format, &index);

1293

if (precision == NO_POSITION)

1294

{

1295

parameterPosition++;

1296

if (positional)

1297

precision = parameterPosition;

1298

else

1299

{

1300

precision = currentParam;

1301

currentParam = precision + 1;

1302

}

1303

}

1304

else

1305

{

1306

if (! positional)

1307

currentParam = precision + 1;

1308

if (width > maxParam)

1309

maxParam = precision;

1310

}

1311

if (currentParam > maxParam)

1312

maxParam = currentParam;

1313

}

1314

else

1315

{

1316

precision = trio_to_long(&format[index],

1317

&tmpformat,

1318

BASE_DECIMAL);

1319

index = (int)(tmpformat - format);

1320

}

1321

}

1322

else if (dots == 1) /* Base */

1323

{

1324

dots++;

1325

1326

/* After the second dot we have the base */

1327

flags |= FLAGS_BASE;

1328

if ((QUALIFIER_STAR == format[index])

1329

#if defined(QUALIFIER_PARAM)

1330

|| (QUALIFIER_PARAM == format[index])

1331

#endif

1332

)

1333

{

1334

index++;

1335

flags |= FLAGS_BASE_PARAMETER;

1336

base = TrioGetPosition(format, &index);

1337

if (base == NO_POSITION)

1338

{

1339

parameterPosition++;

1340

if (positional)

1341

base = parameterPosition;

1342

else

1343

{

1344

base = currentParam;

1345

currentParam = base + 1;

1346

}

1347

}

1348

else

1349

{

1350

if (! positional)

1351

currentParam = base + 1;

1352

if (base > maxParam)

1353

maxParam = base;

1354

}

1355

if (currentParam > maxParam)

1356

maxParam = currentParam;

1357

}

1358

else

1359

{

1360

base = trio_to_long(&format[index],

1361

&tmpformat,

1362

BASE_DECIMAL);

1363

if (base > MAX_BASE)

1364

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1365

index = (int)(tmpformat - format);

1366

}

1367

}

1368

else

1369

{

1370

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1371

}

1372

break; /* QUALIFIER_DOT */

1373

1374

#if defined(QUALIFIER_PARAM)

1375

case QUALIFIER_PARAM:

1376

type = TYPE_PRINT;

1377

/* FALLTHROUGH */

1378

#endif

1379

case QUALIFIER_STAR:

1380

/* This has different meanings for print and scan */

1381

if (TYPE_PRINT == type)

1382

{

1383

/* Read with from parameter */

1384

flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER);

1385

width = TrioGetPosition(format, &index);

1386

if (width == NO_POSITION)

1387

{

1388

parameterPosition++;

1389

if (positional)

1390

width = parameterPosition;

1391

else

1392

{

1393

width = currentParam;

1394

currentParam = width + 1;

1395

}

1396

}

1397

else

1398

{

1399

if (! positional)

1400

currentParam = width + 1;

1401

if (width > maxParam)

1402

maxParam = width;

1403

}

1404

if (currentParam > maxParam)

1405

maxParam = currentParam;

1406

}

1407

else

1408

{

1409

/* Scan, but do not store result */

1410

flags |= FLAGS_IGNORE;

1411

}

1412

1413

break; /* QUALIFIER_STAR */

1414

1415

case '0':

1416

if (! (flags & FLAGS_LEFTADJUST))

1417

flags |= FLAGS_NILPADDING;

1418

/* FALLTHROUGH */

1419

case '1': case '2': case '3': case '4':

1420

case '5': case '6': case '7': case '8': case '9':

1421

flags |= FLAGS_WIDTH;

1422

/* &format[index - 1] is used to "rewind" the read

1423

* character from format

1424

1425

width = trio_to_long(&format[index - 1],

1426

&tmpformat,

1427

BASE_DECIMAL);

1428

index = (int)(tmpformat - format);

1429

break;

1430

1431

case QUALIFIER_SHORT:

1432

if (flags & FLAGS_SHORTSHORT)

1433

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1434

else if (flags & FLAGS_SHORT)

1435

flags |= FLAGS_SHORTSHORT;

1436

else

1437

flags |= FLAGS_SHORT;

1438

break;

1439

1440

case QUALIFIER_LONG:

1441

if (flags & FLAGS_QUAD)

1442

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1443

else if (flags & FLAGS_LONG)

1444

flags |= FLAGS_QUAD;

1445

else

1446

flags |= FLAGS_LONG;

1447

break;

1448

1449

case QUALIFIER_LONG_UPPER:

1450

flags |= FLAGS_LONGDOUBLE;

1451

break;

1452

1453

#if defined(QUALIFIER_SIZE_T)

1454

case QUALIFIER_SIZE_T:

1455

flags |= FLAGS_SIZE_T;

1456

/* Modify flags for later truncation of number */

1457

if (sizeof(size_t) == sizeof(trio_ulonglong_t))

1458

flags |= FLAGS_QUAD;

1459

else if (sizeof(size_t) == sizeof(long))

1460

flags |= FLAGS_LONG;

1461

break;

1462

#endif

1463

1464

#if defined(QUALIFIER_PTRDIFF_T)

1465

case QUALIFIER_PTRDIFF_T:

1466

flags |= FLAGS_PTRDIFF_T;

1467

if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t))

1468

flags |= FLAGS_QUAD;

1469

else if (sizeof(ptrdiff_t) == sizeof(long))

1470

flags |= FLAGS_LONG;

1471

break;

1472

#endif

1473

1474

#if defined(QUALIFIER_INTMAX_T)

1475

case QUALIFIER_INTMAX_T:

1476

flags |= FLAGS_INTMAX_T;

1477

if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t))

1478

flags |= FLAGS_QUAD;

1479

else if (sizeof(trio_intmax_t) == sizeof(long))

1480

flags |= FLAGS_LONG;

1481

break;

1482

#endif

1483

1484

#if defined(QUALIFIER_QUAD)

1485

case QUALIFIER_QUAD:

1486

flags |= FLAGS_QUAD;

1487

break;

1488

#endif

1489

1490

#if defined(QUALIFIER_FIXED_SIZE)

1491

case QUALIFIER_FIXED_SIZE:

1492

if (flags & FLAGS_FIXED_SIZE)

1493

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1494

1495

if (flags & (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE |

1496

FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER))

1497

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1498

1499

if ((format[index] == '6') &&

1500

(format[index + 1] == '4'))

1501

{

1502

varsize = sizeof(trio_int64_t);

1503

index += 2;

1504

}

1505

else if ((format[index] == '3') &&

1506

(format[index + 1] == '2'))

1507

{

1508

varsize = sizeof(trio_int32_t);

1509

index += 2;

1510

}

1511

else if ((format[index] == '1') &&

1512

(format[index + 1] == '6'))

1513

{

1514

varsize = sizeof(trio_int16_t);

1515

index += 2;

1516

}

1517

else if (format[index] == '8')

1518

{

1519

varsize = sizeof(trio_int8_t);

1520

index++;

1521

}

1522

else

1523

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1524

1525

flags |= FLAGS_FIXED_SIZE;

1526

break;

1527

#endif

1528

1529

#if defined(QUALIFIER_WIDECHAR)

1530

case QUALIFIER_WIDECHAR:

1531

flags |= FLAGS_WIDECHAR;

1532

break;

1533

#endif

1534

1535

#if defined(QUALIFIER_SIZE_T_UPPER)

1536

case QUALIFIER_SIZE_T_UPPER:

1537

break;

1538

#endif

1539

1540

#if defined(QUALIFIER_QUOTE)

1541

case QUALIFIER_QUOTE:

1542

flags |= FLAGS_QUOTE;

1543

break;

1544

#endif

1545

1546

#if defined(QUALIFIER_STICKY)

1547

case QUALIFIER_STICKY:

1548

flags |= FLAGS_STICKY;

1549

gotSticky = TRUE;

1550

break;

1551

#endif

1552

1553

#if defined(QUALIFIER_VARSIZE)

1554

case QUALIFIER_VARSIZE:

1555

flags |= FLAGS_VARSIZE_PARAMETER;

1556

parameterPosition++;

1557

if (positional)

1558

varsize = parameterPosition;

1559

else

1560

{

1561

varsize = currentParam;

1562

currentParam = varsize + 1;

1563

}

1564

if (currentParam > maxParam)

1565

maxParam = currentParam;

1566

break;

1567

#endif

1568

1569

#if defined(QUALIFIER_ROUNDING_UPPER)

1570

case QUALIFIER_ROUNDING_UPPER:

1571

flags |= FLAGS_ROUNDING;

1572

break;

1573

#endif

1574

1575

default:

1576

/* Bail out completely to make the error more obvious */

1577

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1578

}

1579

} /* while qualifier */

1580

1581

1582

* Parameters only need the type and value. The value is

1583

* read later.

1584

1585

if (flags & FLAGS_WIDTH_PARAMETER)

1586

{

1587

usedEntries[width] += 1;

1588

parameters[pos].type = FORMAT_PARAMETER;

1589

parameters[pos].flags = 0;

1590

indices[width] = pos;

1591

width = pos++;

1592

}

1593

if (flags & FLAGS_PRECISION_PARAMETER)

1594

{

1595

usedEntries[precision] += 1;

1596

parameters[pos].type = FORMAT_PARAMETER;

1597

parameters[pos].flags = 0;

1598

indices[precision] = pos;

1599

precision = pos++;

1600

}

1601

if (flags & FLAGS_BASE_PARAMETER)

1602

{

1603

usedEntries[base] += 1;

1604

parameters[pos].type = FORMAT_PARAMETER;

1605

parameters[pos].flags = 0;

1606

indices[base] = pos;

1607

base = pos++;

1608

}

1609

if (flags & FLAGS_VARSIZE_PARAMETER)

1610

{

1611

usedEntries[varsize] += 1;

1612

parameters[pos].type = FORMAT_PARAMETER;

1613

parameters[pos].flags = 0;

1614

indices[varsize] = pos;

1615

varsize = pos++;

1616

}

1617

1618

indices[currentParam] = pos;

1619

1620

switch (format[index++])

1621

{

1622

#if defined(SPECIFIER_CHAR_UPPER)

1623

case SPECIFIER_CHAR_UPPER:

1624

flags |= FLAGS_WIDECHAR;

1625

/* FALLTHROUGH */

1626

#endif

1627

case SPECIFIER_CHAR:

1628

if (flags & FLAGS_LONG)

1629

flags |= FLAGS_WIDECHAR;

1630

else if (flags & FLAGS_SHORT)

1631

flags &= ~FLAGS_WIDECHAR;

1632

parameters[pos].type = FORMAT_CHAR;

1633

break;

1634

1635

#if defined(SPECIFIER_STRING_UPPER)

1636

case SPECIFIER_STRING_UPPER:

1637

flags |= FLAGS_WIDECHAR;

1638

/* FALLTHROUGH */

1639

#endif

1640

case SPECIFIER_STRING:

1641

if (flags & FLAGS_LONG)

1642

flags |= FLAGS_WIDECHAR;

1643

else if (flags & FLAGS_SHORT)

1644

flags &= ~FLAGS_WIDECHAR;

1645

parameters[pos].type = FORMAT_STRING;

1646

break;

1647

1648

case SPECIFIER_GROUP:

1649

if (TYPE_SCAN == type)

1650

{

1651

int depth = 1;

1652

parameters[pos].type = FORMAT_GROUP;

1653

if (format[index] == QUALIFIER_CIRCUMFLEX)

1654

index++;

1655

if (format[index] == SPECIFIER_UNGROUP)

1656

index++;

1657

if (format[index] == QUALIFIER_MINUS)

1658

index++;

1659

/* Skip nested brackets */

1660

while (format[index] != NIL)

1661

{

1662

if (format[index] == SPECIFIER_GROUP)

1663

{

1664

depth++;

1665

}

1666

else if (format[index] == SPECIFIER_UNGROUP)

1667

{

1668

if (--depth <= 0)

1669

{

1670

index++;

1671

break;

1672

}

1673

}

1674

index++;

1675

}

1676

}

1677

break;

1678

1679

case SPECIFIER_INTEGER:

1680

parameters[pos].type = FORMAT_INT;

1681

break;

1682

1683

case SPECIFIER_UNSIGNED:

1684

flags |= FLAGS_UNSIGNED;

1685

parameters[pos].type = FORMAT_INT;

1686

break;

1687

1688

case SPECIFIER_DECIMAL:

1689

/* Disable base modifier */

1690

flags &= ~FLAGS_BASE_PARAMETER;

1691

base = BASE_DECIMAL;

1692

parameters[pos].type = FORMAT_INT;

1693

break;

1694

1695

case SPECIFIER_OCTAL:

1696

flags |= FLAGS_UNSIGNED;

1697

flags &= ~FLAGS_BASE_PARAMETER;

1698

base = BASE_OCTAL;

1699

parameters[pos].type = FORMAT_INT;

1700

break;

1701

1702

#if defined(SPECIFIER_BINARY)

1703

case SPECIFIER_BINARY_UPPER:

1704

flags |= FLAGS_UPPER;

1705

/* FALLTHROUGH */

1706

case SPECIFIER_BINARY:

1707

flags |= FLAGS_NILPADDING;

1708

flags &= ~FLAGS_BASE_PARAMETER;

1709

base = BASE_BINARY;

1710

parameters[pos].type = FORMAT_INT;

1711

break;

1712

#endif

1713

1714

case SPECIFIER_HEX_UPPER:

1715

flags |= FLAGS_UPPER;

1716

/* FALLTHROUGH */

1717

case SPECIFIER_HEX:

1718

flags |= FLAGS_UNSIGNED;

1719

flags &= ~FLAGS_BASE_PARAMETER;

1720

base = BASE_HEX;

1721

parameters[pos].type = FORMAT_INT;

1722

break;

1723

1724

case SPECIFIER_FLOAT_E_UPPER:

1725

flags |= FLAGS_UPPER;

1726

/* FALLTHROUGH */

1727

case SPECIFIER_FLOAT_E:

1728

flags |= FLAGS_FLOAT_E;

1729

parameters[pos].type = FORMAT_DOUBLE;

1730

break;

1731

1732

case SPECIFIER_FLOAT_G_UPPER:

1733

flags |= FLAGS_UPPER;

1734

/* FALLTHROUGH */

1735

case SPECIFIER_FLOAT_G:

1736

flags |= FLAGS_FLOAT_G;

1737

parameters[pos].type = FORMAT_DOUBLE;

1738

break;

1739

1740

case SPECIFIER_FLOAT_F_UPPER:

1741

flags |= FLAGS_UPPER;

1742

/* FALLTHROUGH */

1743

case SPECIFIER_FLOAT_F:

1744

parameters[pos].type = FORMAT_DOUBLE;

1745

break;

1746

1747

case SPECIFIER_POINTER:

1748

if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t))

1749

flags |= FLAGS_QUAD;

1750

else if (sizeof(trio_pointer_t) == sizeof(long))

1751

flags |= FLAGS_LONG;

1752

parameters[pos].type = FORMAT_POINTER;

1753

break;

1754

1755

case SPECIFIER_COUNT:

1756

parameters[pos].type = FORMAT_COUNT;

1757

break;

1758

1759

#if defined(SPECIFIER_HEXFLOAT)

1760

# if defined(SPECIFIER_HEXFLOAT_UPPER)

1761

case SPECIFIER_HEXFLOAT_UPPER:

1762

flags |= FLAGS_UPPER;

1763

/* FALLTHROUGH */

1764

# endif

1765

case SPECIFIER_HEXFLOAT:

1766

base = BASE_HEX;

1767

parameters[pos].type = FORMAT_DOUBLE;

1768

break;

1769

#endif

1770

1771

#if defined(FORMAT_ERRNO)

1772

case SPECIFIER_ERRNO:

1773

parameters[pos].type = FORMAT_ERRNO;

1774

break;

1775

#endif

1776

1777

#if defined(SPECIFIER_USER_DEFINED_BEGIN)

1778

case SPECIFIER_USER_DEFINED_BEGIN:

1779

{

1780

unsigned int max;

1781

int without_namespace = TRUE;

1782

1783

parameters[pos].type = FORMAT_USER_DEFINED;

1784

parameters[pos].user_name[0] = NIL;

1785

tmpformat = (char *)&format[index];

1786

1787

while ((ch = format[index]))

1788

{

1789

index++;

1790

if (ch == SPECIFIER_USER_DEFINED_END)

1791

{

1792

if (without_namespace)

1793

{

1794

/* We must get the handle first */

1795

parameters[pos].type = FORMAT_PARAMETER;

1796

parameters[pos].indexAfterSpecifier = index;

1797

parameters[pos].flags = FLAGS_USER_DEFINED;

1798

/* Adjust parameters for insertion of new one */

1799

pos++;

1800

usedEntries[currentParam] += 1;

1801

parameters[pos].type = FORMAT_USER_DEFINED;

1802

currentParam++;

1803

indices[currentParam] = pos;

1804

if (currentParam > maxParam)

1805

maxParam = currentParam;

1806

}

1807

/* Copy the user data */

1808

max = (unsigned int)(&format[index] - tmpformat);

1809

if (max > MAX_USER_DATA)

1810

max = MAX_USER_DATA;

1811

trio_copy_max(parameters[pos].user_data,

1812

max,

1813

tmpformat);

1814

break; /* while */

1815

}

1816

if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)

1817

{

1818

without_namespace = FALSE;

1819

/* Copy the namespace for later looking-up */

1820

max = (int)(&format[index] - tmpformat);

1821

if (max > MAX_USER_NAME)

1822

max = MAX_USER_NAME;

1823

trio_copy_max(parameters[pos].user_name,

1824

max,

1825

tmpformat);

1826

tmpformat = (char *)&format[index];

1827

}

1828

}

1829

if (ch != SPECIFIER_USER_DEFINED_END)

1830

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1831

}

1832

break;

1833

#endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */

1834

1835

default:

1836

/* Bail out completely to make the error more obvious */

1837

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

1838

}

1839

1840

/* Count the number of times this entry has been used */

1841

usedEntries[currentParam] += 1;

1842

1843

/* Find last sticky parameters */

1844

if (gotSticky && !(flags & FLAGS_STICKY))

1845

{

1846

for (i = pos - 1; i >= 0; i--)

1847

{

1848

if (parameters[i].type == FORMAT_PARAMETER)

1849

continue;

1850

if ((parameters[i].flags & FLAGS_STICKY) &&

1851

(parameters[i].type == parameters[pos].type))

1852

{

1853

/* Do not overwrite current qualifiers */

1854

flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);

1855

if (width == NO_WIDTH)

1856

width = parameters[i].width;

1857

if (precision == NO_PRECISION)

1858

precision = parameters[i].precision;

1859

if (base == NO_BASE)

1860

base = parameters[i].base;

1861

break;

1862

}

1863

}

1864

}

1865

1866

parameters[pos].indexAfterSpecifier = index;

1867

parameters[pos].flags = flags;

1868

parameters[pos].width = width;

1869

parameters[pos].precision = precision;

1870

parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base;

1871

parameters[pos].varsize = varsize;

1872

pos++;

1873

1874

if (! positional)

1875

parameterPosition++;

1876

1877

} /* if identifier */

1878

1879

} /* while format characters left */

1880

1881

for (num = 0; num <= maxParam; num++)

1882

{

1883

if (usedEntries[num] != 1)

1884

{

1885

if (usedEntries[num] == 0) /* gap detected */

1886

return TRIO_ERROR_RETURN(TRIO_EGAP, num);

1887

else /* double references detected */

1888

return TRIO_ERROR_RETURN(TRIO_EDBLREF, num);

1889

}

1890

1891

i = indices[num];

1892

1893

1894

* FORMAT_PARAMETERS are only present if they must be read,

1895

* so it makes no sense to check the ignore flag (besides,

1896

* the flags variable is not set for that particular type)

1897

1898

if ((parameters[i].type != FORMAT_PARAMETER) &&

1899

(parameters[i].flags & FLAGS_IGNORE))

1900

continue; /* for all arguments */

1901

1902

1903

* The stack arguments are read according to ANSI C89

1904

* default argument promotions:

1905

1906

* char = int

1907

* short = int

1908

* unsigned char = unsigned int

1909

* unsigned short = unsigned int

1910

* float = double

1911

1912

* In addition to the ANSI C89 these types are read (the

1913

* default argument promotions of C99 has not been

1914

* considered yet)

1915

1916

* long long

1917

* long double

1918

* size_t

1919

* ptrdiff_t

1920

* intmax_t

1921

1922

switch (parameters[i].type)

1923

{

1924

case FORMAT_GROUP:

1925

case FORMAT_STRING:

1926

#if TRIO_WIDECHAR

1927

if (flags & FLAGS_WIDECHAR)

1928

{

1929

parameters[i].data.wstring = (argarray == NULL)

1930

? va_arg(*arglist, trio_wchar_t *)

1931

: (trio_wchar_t *)(argarray[num]);

1932

}

1933

else

1934

#endif

1935

{

1936

parameters[i].data.string = (argarray == NULL)

1937

? va_arg(*arglist, char *)

1938

: (char *)(argarray[num]);

1939

}

1940

break;

1941

1942

#if defined(FORMAT_USER_DEFINED)

1943

case FORMAT_USER_DEFINED:

1944

#endif

1945

case FORMAT_POINTER:

1946

case FORMAT_COUNT:

1947

case FORMAT_UNKNOWN:

1948

parameters[i].data.pointer = (argarray == NULL)

1949

? va_arg(*arglist, trio_pointer_t )

1950

: argarray[num];

1951

break;

1952

1953

case FORMAT_CHAR:

1954

case FORMAT_INT:

1955

if (TYPE_SCAN == type)

1956

{

1957

if (argarray == NULL)

1958

parameters[i].data.pointer =

1959

(trio_pointer_t)va_arg(*arglist, trio_pointer_t);

1960

else

1961

{

1962

if (parameters[i].type == FORMAT_CHAR)

1963

parameters[i].data.pointer =

1964

(trio_pointer_t)((char *)argarray[num]);

1965

else if (parameters[i].flags & FLAGS_SHORT)

1966

parameters[i].data.pointer =

1967

(trio_pointer_t)((short *)argarray[num]);

1968

else

1969

parameters[i].data.pointer =

1970

(trio_pointer_t)((int *)argarray[num]);

1971

}

1972

}

1973

else

1974

{

1975

#if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE)

1976

if (parameters[i].flags

1977

& (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))

1978

{

1979

if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER)

1980

{

1981

1982

* Variable sizes are mapped onto the fixed sizes, in

1983

* accordance with integer promotion.

1984

1985

* Please note that this may not be portable, as we

1986

* only guess the size, not the layout of the numbers.

1987

* For example, if int is little-endian, and long is

1988

* big-endian, then this will fail.

1989

1990

varsize = (int)parameters[parameters[i].varsize].data.number.as_unsigned;

1991

}

1992

else

1993

{

1994

/* Used for the I<bits> modifiers */

1995

varsize = parameters[i].varsize;

1996

}

1997

parameters[i].flags &= ~FLAGS_ALL_VARSIZES;

1998

1999

if (varsize <= (int)sizeof(int))

2000

;

2001

else if (varsize <= (int)sizeof(long))

2002

parameters[i].flags |= FLAGS_LONG;

2003

#if defined(QUALIFIER_INTMAX_T)

2004

else if (varsize <= (int)sizeof(trio_longlong_t))

2005

parameters[i].flags |= FLAGS_QUAD;

2006

else

2007

parameters[i].flags |= FLAGS_INTMAX_T;

2008

#else

2009

else

2010

parameters[i].flags |= FLAGS_QUAD;

2011

#endif

2012

}

2013

#endif /* defined(QUALIFIER_VARSIZE) */

2014

#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)

2015

if (parameters[i].flags & FLAGS_SIZE_T)

2016

parameters[i].data.number.as_unsigned = (argarray == NULL)

2017

? (trio_uintmax_t)va_arg(*arglist, size_t)

2018

: (trio_uintmax_t)(*((size_t *)argarray[num]));

2019

else

2020

#endif

2021

#if defined(QUALIFIER_PTRDIFF_T)

2022

if (parameters[i].flags & FLAGS_PTRDIFF_T)

2023

parameters[i].data.number.as_unsigned = (argarray == NULL)

2024

? (trio_uintmax_t)va_arg(*arglist, ptrdiff_t)

2025

: (trio_uintmax_t)(*((ptrdiff_t *)argarray[num]));

2026

else

2027

#endif

2028

#if defined(QUALIFIER_INTMAX_T)

2029

if (parameters[i].flags & FLAGS_INTMAX_T)

2030

parameters[i].data.number.as_unsigned = (argarray == NULL)

2031

? (trio_uintmax_t)va_arg(*arglist, trio_intmax_t)

2032

: (trio_uintmax_t)(*((trio_intmax_t *)argarray[num]));

2033

else

2034

#endif

2035

if (parameters[i].flags & FLAGS_QUAD)

2036

parameters[i].data.number.as_unsigned = (argarray == NULL)

2037

? (trio_uintmax_t)va_arg(*arglist, trio_ulonglong_t)

2038

: (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num]));

2039

else if (parameters[i].flags & FLAGS_LONG)

2040

parameters[i].data.number.as_unsigned = (argarray == NULL)

2041

? (trio_uintmax_t)va_arg(*arglist, long)

2042

: (trio_uintmax_t)(*((long *)argarray[num]));

2043

else

2044

{

2045

if (argarray == NULL)

2046

parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(*arglist, int);

2047

else

2048

{

2049

if (parameters[i].type == FORMAT_CHAR)

2050

parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num]));

2051

else if (parameters[i].flags & FLAGS_SHORT)

2052

parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num]));

2053

else

2054

parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num]));

2055

}

2056

}

2057

}

2058

break;

2059

2060

case FORMAT_PARAMETER:

2061

2062

* The parameter for the user-defined specifier is a pointer,

2063

* whereas the rest (width, precision, base) uses an integer.

2064

2065

if (parameters[i].flags & FLAGS_USER_DEFINED)

2066

parameters[i].data.pointer = (argarray == NULL)

2067

? va_arg(*arglist, trio_pointer_t )

2068

: argarray[num];

2069

else

2070

parameters[i].data.number.as_unsigned = (argarray == NULL)

2071

? (trio_uintmax_t)va_arg(*arglist, int)

2072

: (trio_uintmax_t)(*((int *)argarray[num]));

2073

break;

2074

2075

case FORMAT_DOUBLE:

2076

if (TYPE_SCAN == type)

2077

{

2078

if (parameters[i].flags & FLAGS_LONGDOUBLE)

2079

parameters[i].data.longdoublePointer = (argarray == NULL)

2080

? va_arg(*arglist, trio_long_double_t *)

2081

: (trio_long_double_t *)argarray[num];

2082

else

2083

{

2084

if (parameters[i].flags & FLAGS_LONG)

2085

parameters[i].data.doublePointer = (argarray == NULL)

2086

? va_arg(*arglist, double *)

2087

: (double *)argarray[num];

2088

else

2089

parameters[i].data.doublePointer = (argarray == NULL)

2090

? (double *)va_arg(*arglist, float *)

2091

: (double *)((float *)argarray[num]);

2092

}

2093

}

2094

else

2095

{

2096

if (parameters[i].flags & FLAGS_LONGDOUBLE)

2097

parameters[i].data.longdoubleNumber = (argarray == NULL)

2098

? va_arg(*arglist, trio_long_double_t)

2099

: (trio_long_double_t)(*((trio_long_double_t *)argarray[num]));

2100

else

2101

{

2102

if (argarray == NULL)

2103

parameters[i].data.longdoubleNumber =

2104

(trio_long_double_t)va_arg(*arglist, double);

2105

else

2106

{

2107

if (parameters[i].flags & FLAGS_SHORT)

2108

parameters[i].data.longdoubleNumber =

2109

(trio_long_double_t)(*((float *)argarray[num]));

2110

else

2111

parameters[i].data.longdoubleNumber =

2112

(trio_long_double_t)(*((double *)argarray[num]));

2113

}

2114

}

2115

}

2116

break;

2117

2118

#if defined(FORMAT_ERRNO)

2119

case FORMAT_ERRNO:

2120

parameters[i].data.errorNumber = save_errno;

2121

break;

2122

#endif

2123

2124

default:

2125

break;

2126

}

2127

} /* for all specifiers */

2128

return num;

2129

}

2130

2131

2132

/*************************************************************************

2133

2134

* FORMATTING

2135

2136

************************************************************************/

2137

2138

2139

/*************************************************************************

2140

* TrioWriteNumber

2141

2142

* Description:

2143

* Output a number.

2144

* The complexity of this function is a result of the complexity

2145

* of the dependencies of the flags.

2146

2147

TRIO_PRIVATE void

2148

TrioWriteNumber

2149

TRIO_ARGS6((self, number, flags, width, precision, base),

2150

trio_class_t *self,

2151

trio_uintmax_t number,

2152

trio_flags_t flags,

2153

int width,

2154

int precision,

2155

int base)

2156

{

2157

BOOLEAN_T isNegative;

2158

BOOLEAN_T isNumberZero;

2159

BOOLEAN_T isPrecisionZero;

2160

BOOLEAN_T ignoreNumber;

2161

char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];

2162

char *bufferend;

2163

char *pointer;

2164

TRIO_CONST char *digits;

2165

int i;

2166

int length;

2167

char *p;

2168

int count;

2169

2170

assert(VALID(self));

2171

assert(VALID(self->OutStream));

2172

assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));

2173

2174

digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;

2175

if (base == NO_BASE)

2176

base = BASE_DECIMAL;

2177

2178

isNumberZero = (number == 0);

2179

isPrecisionZero = (precision == 0);

2180

ignoreNumber = (isNumberZero

2181

&& isPrecisionZero

2182

&& !((flags & FLAGS_ALTERNATIVE) && (base == BASE_OCTAL)));

2183

2184

if (flags & FLAGS_UNSIGNED)

2185

{

2186

isNegative = FALSE;

2187

flags &= ~FLAGS_SHOWSIGN;

2188

}

2189

else

2190

{

2191

isNegative = ((trio_intmax_t)number < 0);

2192

if (isNegative)

2193

number = -((trio_intmax_t)number);

2194

}

2195

2196

if (flags & FLAGS_QUAD)

2197

number &= (trio_ulonglong_t)-1;

2198

else if (flags & FLAGS_LONG)

2199

number &= (unsigned long)-1;

2200

else

2201

number &= (unsigned int)-1;

2202

2203

/* Build number */

2204

pointer = bufferend = &buffer[sizeof(buffer) - 1];

2205

*pointer-- = NIL;

2206

for (i = 1; i < (int)sizeof(buffer); i++)

2207

{

2208

*pointer-- = digits[number % base];

2209

number /= base;

2210

if (number == 0)

2211

break;

2212

2213

if ((flags & FLAGS_QUOTE) && TrioFollowedBySeparator(i + 1))

2214

{

2215

2216

* We are building the number from the least significant

2217

* to the most significant digit, so we have to copy the

2218

* thousand separator backwards

2219

2220

length = internalThousandSeparatorLength;

2221

if (((int)(pointer - buffer) - length) > 0)

2222

{

2223

p = &internalThousandSeparator[length - 1];

2224

while (length-- > 0)

2225

*pointer-- = *p--;

2226

}

2227

}

2228

}

2229

2230

if (! ignoreNumber)

2231

{

2232

/* Adjust width */

2233

width -= (bufferend - pointer) - 1;

2234

}

2235

2236

/* Adjust precision */

2237

if (NO_PRECISION != precision)

2238

{

2239

precision -= (bufferend - pointer) - 1;

2240

if (precision < 0)

2241

precision = 0;

2242

flags |= FLAGS_NILPADDING;

2243

}

2244

2245

/* Calculate padding */

2246

count = (! ((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION)))

2247

? precision

2248

: 0;

2249

2250

/* Adjust width further */

2251

if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))

2252

width--;

2253

if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)

2254

{

2255

switch (base)

2256

{

2257

case BASE_BINARY:

2258

case BASE_HEX:

2259

width -= 2;

2260

break;

2261

case BASE_OCTAL:

2262

if (!(flags & FLAGS_NILPADDING) || (count == 0))

2263

width--;

2264

break;

2265

default:

2266

break;

2267

}

2268

}

2269

2270

/* Output prefixes spaces if needed */

2271

if (! ((flags & FLAGS_LEFTADJUST) ||

2272

((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION))))

2273

{

2274

while (width-- > count)

2275

self->OutStream(self, CHAR_ADJUST);

2276

}

2277

2278

/* width has been adjusted for signs and alternatives */

2279

if (isNegative)

2280

self->OutStream(self, '-');

2281

else if (flags & FLAGS_SHOWSIGN)

2282

self->OutStream(self, '+');

2283

else if (flags & FLAGS_SPACE)

2284

self->OutStream(self, ' ');

2285

2286

/* Prefix is not written when the value is zero */

2287

if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)

2288

{

2289

switch (base)

2290

{

2291

case BASE_BINARY:

2292

self->OutStream(self, '0');

2293

self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b');

2294

break;

2295

2296

case BASE_OCTAL:

2297

if (!(flags & FLAGS_NILPADDING) || (count == 0))

2298

self->OutStream(self, '0');

2299

break;

2300

2301

case BASE_HEX:

2302

self->OutStream(self, '0');

2303

self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');

2304

break;

2305

2306

default:

2307

break;

2308

} /* switch base */

2309

}

2310

2311

/* Output prefixed zero padding if needed */

2312

if (flags & FLAGS_NILPADDING)

2313

{

2314

if (precision == NO_PRECISION)

2315

precision = width;

2316

while (precision-- > 0)

2317

{

2318

self->OutStream(self, '0');

2319

width--;

2320

}

2321

}

2322

2323

if (! ignoreNumber)

2324

{

2325

/* Output the number itself */

2326

while (*(++pointer))

2327

{

2328

self->OutStream(self, *pointer);

2329

}

2330

}

2331

2332

/* Output trailing spaces if needed */

2333

if (flags & FLAGS_LEFTADJUST)

2334

{

2335

while (width-- > 0)

2336

self->OutStream(self, CHAR_ADJUST);

2337

}

2338

}

2339

2340

/*************************************************************************

2341

* TrioWriteStringCharacter

2342

2343

* Description:

2344

* Output a single character of a string

2345

2346

TRIO_PRIVATE void

2347

TrioWriteStringCharacter

2348

TRIO_ARGS3((self, ch, flags),

2349

trio_class_t *self,

2350

int ch,

2351

trio_flags_t flags)

2352

{

2353

if (flags & FLAGS_ALTERNATIVE)

2354

{

2355

if (! isprint(ch))

2356

{

2357

2358

* Non-printable characters are converted to C escapes or

2359

* \number, if no C escape exists.

2360

2361

self->OutStream(self, CHAR_BACKSLASH);

2362

switch (ch)

2363

{

2364

case '\007': self->OutStream(self, 'a'); break;

2365

case '\b': self->OutStream(self, 'b'); break;

2366

case '\f': self->OutStream(self, 'f'); break;

2367

case '\n': self->OutStream(self, 'n'); break;

2368

case '\r': self->OutStream(self, 'r'); break;

2369

case '\t': self->OutStream(self, 't'); break;

2370

case '\v': self->OutStream(self, 'v'); break;

2371

case '\\': self->OutStream(self, '\\'); break;

2372

default:

2373

self->OutStream(self, 'x');

2374

TrioWriteNumber(self, (trio_uintmax_t)ch,

2375

FLAGS_UNSIGNED | FLAGS_NILPADDING,

2376

2, 2, BASE_HEX);

2377

break;

2378

}

2379

}

2380

else if (ch == CHAR_BACKSLASH)

2381

{

2382

self->OutStream(self, CHAR_BACKSLASH);

2383

self->OutStream(self, CHAR_BACKSLASH);

2384

}

2385

else

2386

{

2387

self->OutStream(self, ch);

2388

}

2389

}

2390

else

2391

{

2392

self->OutStream(self, ch);

2393

}

2394

}

2395

2396

/*************************************************************************

2397

* TrioWriteString

2398

2399

* Description:

2400

* Output a string

2401

2402

TRIO_PRIVATE void

2403

TrioWriteString

2404

TRIO_ARGS5((self, string, flags, width, precision),

2405

trio_class_t *self,

2406

TRIO_CONST char *string,

2407

trio_flags_t flags,

2408

int width,

2409

int precision)

2410

{

2411

int length;

2412

int ch;

2413

2414

assert(VALID(self));

2415

assert(VALID(self->OutStream));

2416

2417

if (string == NULL)

2418

{

2419

string = internalNullString;

2420

length = sizeof(internalNullString) - 1;

2421

/* Disable quoting for the null pointer */

2422

flags &= (~FLAGS_QUOTE);

2423

width = 0;

2424

}

2425

else

2426

{

2427

length = trio_length(string);

2428

}

2429

if ((NO_PRECISION != precision) &&

2430

(precision < length))

2431

{

2432

length = precision;

2433

}

2434

width -= length;

2435

2436

if (flags & FLAGS_QUOTE)

2437

self->OutStream(self, CHAR_QUOTE);

2438

2439

if (! (flags & FLAGS_LEFTADJUST))

2440

{

2441

while (width-- > 0)

2442

self->OutStream(self, CHAR_ADJUST);

2443

}

2444

2445

while (length-- > 0)

2446

{

2447

/* The ctype parameters must be an unsigned char (or EOF) */

2448

ch = (int)((unsigned char)(*string++));

2449

TrioWriteStringCharacter(self, ch, flags);

2450

}

2451

2452

if (flags & FLAGS_LEFTADJUST)

2453

{

2454

while (width-- > 0)

2455

self->OutStream(self, CHAR_ADJUST);

2456

}

2457

if (flags & FLAGS_QUOTE)

2458

self->OutStream(self, CHAR_QUOTE);

2459

}

2460

2461

/*************************************************************************

2462

* TrioWriteWideStringCharacter

2463

2464

* Description:

2465

* Output a wide string as a multi-byte sequence

2466

2467

#if TRIO_WIDECHAR

2468

TRIO_PRIVATE int

2469

TrioWriteWideStringCharacter

2470

TRIO_ARGS4((self, wch, flags, width),

2471

trio_class_t *self,

2472

trio_wchar_t wch,

2473

trio_flags_t flags,

2474

int width)

2475

{

2476

int size;

2477

int i;

2478

int ch;

2479

char *string;

2480

char buffer[MB_LEN_MAX + 1];

2481

2482

if (width == NO_WIDTH)

2483

width = sizeof(buffer);

2484

2485

size = wctomb(buffer, wch);

2486

if ((size <= 0) || (size > width) || (buffer[0] == NIL))

2487

return 0;

2488

2489

string = buffer;

2490

i = size;

2491

while ((width >= i) && (width-- > 0) && (i-- > 0))

2492

{

2493

/* The ctype parameters must be an unsigned char (or EOF) */

2494

ch = (int)((unsigned char)(*string++));

2495

TrioWriteStringCharacter(self, ch, flags);

2496

}

2497

return size;

2498

}

2499

#endif /* TRIO_WIDECHAR */

2500

2501

/*************************************************************************

2502

* TrioWriteWideString

2503

2504

* Description:

2505

* Output a wide character string as a multi-byte string

2506

2507

#if TRIO_WIDECHAR

2508

TRIO_PRIVATE void

2509

TrioWriteWideString

2510

TRIO_ARGS5((self, wstring, flags, width, precision),

2511

trio_class_t *self,

2512

TRIO_CONST trio_wchar_t *wstring,

2513

trio_flags_t flags,

2514

int width,

2515

int precision)

2516

{

2517

int length;

2518

int size;

2519

2520

assert(VALID(self));

2521

assert(VALID(self->OutStream));

2522

2523

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

2524

(void)mblen(NULL, 0);

2525

#endif

2526

2527

if (wstring == NULL)

2528

{

2529

TrioWriteString(self, NULL, flags, width, precision);

2530

return;

2531

}

2532

2533

if (NO_PRECISION == precision)

2534

{

2535

length = INT_MAX;

2536

}

2537

else

2538

{

2539

length = precision;

2540

width -= length;

2541

}

2542

2543

if (flags & FLAGS_QUOTE)

2544

self->OutStream(self, CHAR_QUOTE);

2545

2546

if (! (flags & FLAGS_LEFTADJUST))

2547

{

2548

while (width-- > 0)

2549

self->OutStream(self, CHAR_ADJUST);

2550

}

2551

2552

while (length > 0)

2553

{

2554

size = TrioWriteWideStringCharacter(self, *wstring++, flags, length);

2555

if (size == 0)

2556

break; /* while */

2557

length -= size;

2558

}

2559

2560

if (flags & FLAGS_LEFTADJUST)

2561

{

2562

while (width-- > 0)

2563

self->OutStream(self, CHAR_ADJUST);

2564

}

2565

if (flags & FLAGS_QUOTE)

2566

self->OutStream(self, CHAR_QUOTE);

2567

}

2568

#endif /* TRIO_WIDECHAR */

2569

2570

/*************************************************************************

2571

* TrioWriteDouble

2572

2573

* http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/dr_211.htm

2574

2575

* "5.2.4.2.2 paragraph #4

2576

2577

* The accuracy [...] is implementation defined, as is the accuracy

2578

* of the conversion between floating-point internal representations

2579

* and string representations performed by the libray routine in

2580

* <stdio.h>"

2581

2582

/* FIXME: handle all instances of constant long-double number (L)

2583

* and *l() math functions.

2584

2585

TRIO_PRIVATE void

2586

TrioWriteDouble

2587

TRIO_ARGS6((self, number, flags, width, precision, base),

2588

trio_class_t *self,

2589

trio_long_double_t number,

2590

trio_flags_t flags,

2591

int width,

2592

int precision,

2593

int base)

2594

{

2595

trio_long_double_t integerNumber;

2596

trio_long_double_t fractionNumber;

2597

trio_long_double_t workNumber;

2598

int integerDigits;

2599

int fractionDigits;

2600

int exponentDigits;

2601

int baseDigits;

2602

int integerThreshold;

2603

int fractionThreshold;

2604

int expectedWidth;

2605

int exponent = 0;

2606

unsigned int uExponent = 0;

2607

int exponentBase;

2608

trio_long_double_t dblBase;

2609

trio_long_double_t dblIntegerBase;

2610

trio_long_double_t dblFractionBase;

2611

trio_long_double_t integerAdjust;

2612

trio_long_double_t fractionAdjust;

2613

BOOLEAN_T isNegative;

2614

BOOLEAN_T isExponentNegative = FALSE;

2615

BOOLEAN_T requireTwoDigitExponent;

2616

BOOLEAN_T isHex;

2617

TRIO_CONST char *digits;

2618

char *groupingPointer;

2619

int i;

2620

int index;

2621

BOOLEAN_T hasOnlyZeroes;

2622

int zeroes = 0;

2623

2624

BOOLEAN_T keepTrailingZeroes;

2625

BOOLEAN_T keepDecimalPoint;

2626

trio_long_double_t epsilon;

2627

2628

assert(VALID(self));

2629

assert(VALID(self->OutStream));

2630

assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));

2631

2632

/* Determine sign and look for special quantities */

2633

switch (trio_fpclassify_and_signbit(number, &isNegative))

2634

{

2635

case TRIO_FP_NAN:

2636

TrioWriteString(self,

2637

(flags & FLAGS_UPPER)

2638

? NAN_UPPER

2639

: NAN_LOWER,

2640

flags, width, precision);

2641

return;

2642

2643

case TRIO_FP_INFINITE:

2644

if (isNegative)

2645

{

2646

/* Negative infinity */

2647

TrioWriteString(self,

2648

(flags & FLAGS_UPPER)

2649

? "-" INFINITE_UPPER

2650

: "-" INFINITE_LOWER,

2651

flags, width, precision);

2652

return;

2653

}

2654

else

2655

{

2656

/* Positive infinity */

2657

TrioWriteString(self,

2658

(flags & FLAGS_UPPER)

2659

? INFINITE_UPPER

2660

: INFINITE_LOWER,

2661

flags, width, precision);

2662

return;

2663

}

2664

2665

default:

2666

/* Finitude */

2667

break;

2668

}

2669

2670

/* Normal numbers */

2671

if (flags & FLAGS_LONGDOUBLE)

2672

{

2673

baseDigits = (base == 10)

2674

? LDBL_DIG

2675

: (int)floor(LDBL_MANT_DIG / TrioLogarithmBase(base));

2676

epsilon = LDBL_EPSILON;

2677

}

2678

else if (flags & FLAGS_SHORT)

2679

{

2680

baseDigits = (base == BASE_DECIMAL)

2681

? FLT_DIG

2682

: (int)floor(FLT_MANT_DIG / TrioLogarithmBase(base));

2683

epsilon = FLT_EPSILON;

2684

}

2685

else

2686

{

2687

baseDigits = (base == BASE_DECIMAL)

2688

? DBL_DIG

2689

: (int)floor(DBL_MANT_DIG / TrioLogarithmBase(base));

2690

epsilon = DBL_EPSILON;

2691

}

2692

2693

digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;

2694

isHex = (base == BASE_HEX);

2695

if (base == NO_BASE)

2696

base = BASE_DECIMAL;

2697

dblBase = (trio_long_double_t)base;

2698

keepTrailingZeroes = !( (flags & FLAGS_ROUNDING) ||

2699

( (flags & FLAGS_FLOAT_G) &&

2700

!(flags & FLAGS_ALTERNATIVE) ) );

2701

2702

if (flags & FLAGS_ROUNDING)

2703

precision = baseDigits;

2704

2705

if (precision == NO_PRECISION)

2706

{

2707

if (isHex)

2708

{

2709

keepTrailingZeroes = FALSE;

2710

precision = FLT_MANT_DIG;

2711

}

2712

else

2713

{

2714

precision = FLT_DIG;

2715

}

2716

}

2717

2718

if (isNegative)

2719

number = -number;

2720

2721

if (isHex)

2722

flags |= FLAGS_FLOAT_E;

2723

2724

if (flags & FLAGS_FLOAT_G)

2725

{

2726

if (precision == 0)

2727

precision = 1;

2728

2729

if ((number < 1.0E-4) || (number > powl(base,

2730

(trio_long_double_t)precision)))

2731

{

2732

/* Use scientific notation */

2733

flags |= FLAGS_FLOAT_E;

2734

}

2735

else if (number < 1.0)

2736

{

2737

2738

* Use normal notation. If the integer part of the number is

2739

* zero, then adjust the precision to include leading fractional

2740

* zeros.

2741

2742

workNumber = TrioLogarithm(number, base);

2743

workNumber = TRIO_FABS(workNumber);

2744

if (workNumber - floorl(workNumber) < 0.001)

2745

workNumber--;

2746

zeroes = (int)floorl(workNumber);

2747

}

2748

}

2749

2750

if (flags & FLAGS_FLOAT_E)

2751

{

2752

/* Scale the number */

2753

workNumber = TrioLogarithm(number, base);

2754

if (trio_isinf(workNumber) == -1)

2755

{

2756

exponent = 0;

2757

/* Undo setting */

2758

if (flags & FLAGS_FLOAT_G)

2759

flags &= ~FLAGS_FLOAT_E;

2760

}

2761

else

2762

{

2763

exponent = (int)floorl(workNumber);

2764

number /= powl(dblBase, (trio_long_double_t)exponent);

2765

isExponentNegative = (exponent < 0);

2766

uExponent = (isExponentNegative) ? -exponent : exponent;

2767

if (isHex)

2768

uExponent *= 4; /* log16(2) */

2769

/* No thousand separators */

2770

flags &= ~FLAGS_QUOTE;

2771

}

2772

}

2773

2774

integerNumber = floorl(number);

2775

fractionNumber = number - integerNumber;

2776

2777

2778

* Truncated number.

2779

2780

* Precision is number of significant digits for FLOAT_G

2781

* and number of fractional digits for others.

2782

2783

integerDigits = (integerNumber > epsilon)

2784

? 1 + (int)TrioLogarithm(integerNumber, base)

2785

: 1;

2786

fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0))

2787

? precision - integerDigits

2788

: zeroes + precision;

2789

2790

dblFractionBase = TrioPower(base, fractionDigits);

2791

2792

workNumber = number + 0.5 / dblFractionBase;

2793

if (floorl(number) != floorl(workNumber))

2794

{

2795

if (flags & FLAGS_FLOAT_E)

2796

{

2797

/* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */

2798

exponent++;

2799

isExponentNegative = (exponent < 0);

2800

uExponent = (isExponentNegative) ? -exponent : exponent;

2801

if (isHex)

2802

uExponent *= 4; /* log16(2) */

2803

workNumber = (number + 0.5 / dblFractionBase) / dblBase;

2804

integerNumber = floorl(workNumber);

2805

fractionNumber = workNumber - integerNumber;

2806

}

2807

else

2808

{

2809

/* Adjust if number was rounded up one digit (ie. 99 to 100) */

2810

integerNumber = floorl(number + 0.5);

2811

fractionNumber = 0.0;

2812

integerDigits = (integerNumber > epsilon)

2813

? 1 + (int)TrioLogarithm(integerNumber, base)

2814

: 1;

2815

}

2816

}

2817

2818

/* Estimate accuracy */

2819

integerAdjust = fractionAdjust = 0.5;

2820

if (flags & FLAGS_ROUNDING)

2821

{

2822

if (integerDigits > baseDigits)

2823

{

2824

integerThreshold = baseDigits;

2825

fractionDigits = 0;

2826

dblFractionBase = 1.0;

2827

fractionThreshold = 0;

2828

precision = 0; /* Disable decimal-point */

2829

integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1);

2830

fractionAdjust = 0.0;

2831

}

2832

else

2833

{

2834

integerThreshold = integerDigits;

2835

fractionThreshold = fractionDigits - integerThreshold;

2836

fractionAdjust = 1.0;

2837

}

2838

}

2839

else

2840

{

2841

integerThreshold = INT_MAX;

2842

fractionThreshold = INT_MAX;

2843

}

2844

2845

2846

* Calculate expected width.

2847

* sign + integer part + thousands separators + decimal point

2848

* + fraction + exponent

2849

2850

fractionAdjust /= dblFractionBase;

2851

hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);

2852

keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) ||

2853

!((precision == 0) ||

2854

(!keepTrailingZeroes && hasOnlyZeroes)) );

2855

if (flags & FLAGS_FLOAT_E)

2856

{

2857

exponentDigits = (uExponent == 0)

2858

? 1

2859

: (int)ceil(TrioLogarithm((double)(uExponent + 1),

2860

(isHex) ? 10.0 : base));

2861

}

2862

else

2863

exponentDigits = 0;

2864

requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1));

2865

2866

expectedWidth = integerDigits + fractionDigits

2867

+ (keepDecimalPoint

2868

? internalDecimalPointLength

2869

: 0)

2870

+ ((flags & FLAGS_QUOTE)

2871

? TrioCalcThousandSeparatorLength(integerDigits)

2872

: 0);

2873

if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))

2874

expectedWidth += sizeof("-") - 1;

2875

if (exponentDigits > 0)

2876

expectedWidth += exponentDigits +

2877

((requireTwoDigitExponent ? sizeof("E+0") : sizeof("E+")) - 1);

2878

if (isHex)

2879

expectedWidth += sizeof("0X") - 1;

2880

2881

/* Output prefixing */

2882

if (flags & FLAGS_NILPADDING)

2883

{

2884

/* Leading zeros must be after sign */

2885

if (isNegative)

2886

self->OutStream(self, '-');

2887

else if (flags & FLAGS_SHOWSIGN)

2888

self->OutStream(self, '+');

2889

else if (flags & FLAGS_SPACE)

2890

self->OutStream(self, ' ');

2891

if (isHex)

2892

{

2893

self->OutStream(self, '0');

2894

self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');

2895

}

2896

if (!(flags & FLAGS_LEFTADJUST))

2897

{

2898

for (i = expectedWidth; i < width; i++)

2899

{

2900

self->OutStream(self, '0');

2901

}

2902

}

2903

}

2904

else

2905

{

2906

/* Leading spaces must be before sign */

2907

if (!(flags & FLAGS_LEFTADJUST))

2908

{

2909

for (i = expectedWidth; i < width; i++)

2910

{

2911

self->OutStream(self, CHAR_ADJUST);

2912

}

2913

}

2914

if (isNegative)

2915

self->OutStream(self, '-');

2916

else if (flags & FLAGS_SHOWSIGN)

2917

self->OutStream(self, '+');

2918

else if (flags & FLAGS_SPACE)

2919

self->OutStream(self, ' ');

2920

if (isHex)

2921

{

2922

self->OutStream(self, '0');

2923

self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');

2924

}

2925

}

2926

2927

/* Output the integer part and thousand separators */

2928

dblIntegerBase = 1.0 / TrioPower(base, integerDigits - 1);

2929

for (i = 0; i < integerDigits; i++)

2930

{

2931

workNumber = floorl(((integerNumber + integerAdjust) * dblIntegerBase));

2932

if (i > integerThreshold)

2933

{

2934

/* Beyond accuracy */

2935

self->OutStream(self, digits[0]);

2936

}

2937

else

2938

{

2939

self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]);

2940

}

2941

dblIntegerBase *= dblBase;

2942

2943

if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE)

2944

&& TrioFollowedBySeparator(integerDigits - i))

2945

{

2946

for (groupingPointer = internalThousandSeparator;

2947

*groupingPointer != NIL;

2948

groupingPointer++)

2949

{

2950

self->OutStream(self, *groupingPointer);

2951

}

2952

}

2953

}

2954

2955

/* Insert decimal point and build the fraction part */

2956

trailingZeroes = 0;

2957

2958

if (keepDecimalPoint)

2959

{

2960

if (internalDecimalPoint)

2961

{

2962

self->OutStream(self, internalDecimalPoint);

2963

}

2964

else

2965

{

2966

for (i = 0; i < internalDecimalPointLength; i++)

2967

{

2968

self->OutStream(self, internalDecimalPointString[i]);

2969

}

2970

}

2971

}

2972

2973

for (i = 0; i < fractionDigits; i++)

2974

{

2975

if ((integerDigits > integerThreshold) || (i > fractionThreshold))

2976

{

2977

/* Beyond accuracy */

2978

trailingZeroes++;

2979

}

2980

else

2981

{

2982

fractionNumber *= dblBase;

2983

fractionAdjust *= dblBase;

2984

workNumber = floorl(fractionNumber + fractionAdjust);

2985

fractionNumber -= workNumber;

2986

index = (int)fmodl(workNumber, dblBase);

2987

if (index == 0)

2988

{

2989

trailingZeroes++;

2990

}

2991

else

2992

{

2993

while (trailingZeroes > 0)

2994

{

2995

/* Not trailing zeroes after all */

2996

self->OutStream(self, digits[0]);

2997

trailingZeroes--;

2998

}

2999

self->OutStream(self, digits[index]);

3000

}

3001

}

3002

}

3003

3004

if (keepTrailingZeroes)

3005

{

3006

while (trailingZeroes > 0)

3007

{

3008

self->OutStream(self, digits[0]);

3009

trailingZeroes--;

3010

}

3011

}

3012

3013

/* Output exponent */

3014

if (exponentDigits > 0)

3015

{

3016

self->OutStream(self,

3017

isHex

3018

? ((flags & FLAGS_UPPER) ? 'P' : 'p')

3019

: ((flags & FLAGS_UPPER) ? 'E' : 'e'));

3020

self->OutStream(self, (isExponentNegative) ? '-' : '+');

3021

3022

/* The exponent must contain at least two digits */

3023

if (requireTwoDigitExponent)

3024

self->OutStream(self, '0');

3025

3026

if (isHex)

3027

base = 10.0;

3028

exponentBase = (int)TrioPower(base, exponentDigits - 1);

3029

for (i = 0; i < exponentDigits; i++)

3030

{

3031

self->OutStream(self, digits[(uExponent / exponentBase) % base]);

3032

exponentBase /= base;

3033

}

3034

}

3035

/* Output trailing spaces */

3036

if (flags & FLAGS_LEFTADJUST)

3037

{

3038

for (i = expectedWidth; i < width; i++)

3039

{

3040

self->OutStream(self, CHAR_ADJUST);

3041

}

3042

}

3043

}

3044

3045

/*************************************************************************

3046

* TrioFormatProcess

3047

3048

* Description:

3049

* This is the main engine for formatting output

3050

3051

TRIO_PRIVATE int

3052

TrioFormatProcess

3053

TRIO_ARGS3((data, format, parameters),

3054

trio_class_t *data,

3055

TRIO_CONST char *format,

3056

trio_parameter_t *parameters)

3057

{

3058

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

3059

int charlen;

3060

#endif

3061

int i;

3062

TRIO_CONST char *string;

3063

trio_pointer_t pointer;

3064

trio_flags_t flags;

3065

int width;

3066

int precision;

3067

int base;

3068

int index;

3069

3070

index = 0;

3071

i = 0;

3072

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

3073

(void)mblen(NULL, 0);

3074

#endif

3075

3076

while (format[index])

3077

{

3078

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

3079

if (! isascii(format[index]))

3080

{

3081

charlen = mblen(&format[index], MB_LEN_MAX);

3082

3083

* Only valid multibyte characters are handled here. Invalid

3084

* multibyte characters (charlen == -1) are handled as normal

3085

* characters.

3086

3087

if (charlen != -1)

3088

{

3089

while (charlen-- > 0)

3090

{

3091

data->OutStream(data, format[index++]);

3092

}

3093

continue; /* while characters left in formatting string */

3094

}

3095

}

3096

#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */

3097

if (CHAR_IDENTIFIER == format[index])

3098

{

3099

if (CHAR_IDENTIFIER == format[index + 1])

3100

{

3101

data->OutStream(data, CHAR_IDENTIFIER);

3102

index += 2;

3103

}

3104

else

3105

{

3106

/* Skip the parameter entries */

3107

while (parameters[i].type == FORMAT_PARAMETER)

3108

i++;

3109

3110

flags = parameters[i].flags;

3111

3112

/* Find width */

3113

width = parameters[i].width;

3114

if (flags & FLAGS_WIDTH_PARAMETER)

3115

{

3116

/* Get width from parameter list */

3117

width = (int)parameters[width].data.number.as_signed;

3118

if (width < 0)

3119

{

3120

3121

* A negative width is the same as the - flag and

3122

* a positive width.

3123

3124

flags |= FLAGS_LEFTADJUST;

3125

flags &= ~FLAGS_NILPADDING;

3126

width = -width;

3127

}

3128

}

3129

3130

/* Find precision */

3131

if (flags & FLAGS_PRECISION)

3132

{

3133

precision = parameters[i].precision;

3134

if (flags & FLAGS_PRECISION_PARAMETER)

3135

{

3136

/* Get precision from parameter list */

3137

precision = (int)parameters[precision].data.number.as_signed;

3138

if (precision < 0)

3139

{

3140

3141

* A negative precision is the same as no

3142

* precision

3143

3144

precision = NO_PRECISION;

3145

}

3146

}

3147

}

3148

else

3149

{

3150

precision = NO_PRECISION;

3151

}

3152

3153

/* Find base */

3154

base = parameters[i].base;

3155

if (flags & FLAGS_BASE_PARAMETER)

3156

{

3157

/* Get base from parameter list */

3158

base = (int)parameters[base].data.number.as_signed;

3159

}

3160

3161

switch (parameters[i].type)

3162

{

3163

case FORMAT_CHAR:

3164

if (flags & FLAGS_QUOTE)

3165

data->OutStream(data, CHAR_QUOTE);

3166

if (! (flags & FLAGS_LEFTADJUST))

3167

{

3168

while (--width > 0)

3169

data->OutStream(data, CHAR_ADJUST);

3170

}

3171

#if TRIO_WIDECHAR

3172

if (flags & FLAGS_WIDECHAR)

3173

{

3174

TrioWriteWideStringCharacter(data,

3175

(trio_wchar_t)parameters[i].data.number.as_signed,

3176

flags,

3177

NO_WIDTH);

3178

}

3179

else

3180

#endif

3181

{

3182

TrioWriteStringCharacter(data,

3183

(int)parameters[i].data.number.as_signed,

3184

flags);

3185

}

3186

3187

if (flags & FLAGS_LEFTADJUST)

3188

{

3189

while(--width > 0)

3190

data->OutStream(data, CHAR_ADJUST);

3191

}

3192

if (flags & FLAGS_QUOTE)

3193

data->OutStream(data, CHAR_QUOTE);

3194

3195

break; /* FORMAT_CHAR */

3196

3197

case FORMAT_INT:

3198

TrioWriteNumber(data,

3199

parameters[i].data.number.as_unsigned,

3200

flags,

3201

width,

3202

precision,

3203

base);

3204

3205

break; /* FORMAT_INT */

3206

3207

case FORMAT_DOUBLE:

3208

TrioWriteDouble(data,

3209

parameters[i].data.longdoubleNumber,

3210

flags,

3211

width,

3212

precision,

3213

base);

3214

break; /* FORMAT_DOUBLE */

3215

3216

case FORMAT_STRING:

3217

#if TRIO_WIDECHAR

3218

if (flags & FLAGS_WIDECHAR)

3219

{

3220

TrioWriteWideString(data,

3221

parameters[i].data.wstring,

3222

flags,

3223

width,

3224

precision);

3225

}

3226

else

3227

#endif

3228

{

3229

TrioWriteString(data,

3230

parameters[i].data.string,

3231

flags,

3232

width,

3233

precision);

3234

}

3235

break; /* FORMAT_STRING */

3236

3237

case FORMAT_POINTER:

3238

{

3239

trio_reference_t reference;

3240

3241

reference.data = data;

3242

reference.parameter = &parameters[i];

3243

trio_print_pointer(&reference, parameters[i].data.pointer);

3244

}

3245

break; /* FORMAT_POINTER */

3246

3247

case FORMAT_COUNT:

3248

pointer = parameters[i].data.pointer;

3249

if (NULL != pointer)

3250

{

3251

3252

* C99 paragraph 7.19.6.1.8 says "the number of

3253

* characters written to the output stream so far by

3254

* this call", which is data->committed

3255

3256

#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)

3257

if (flags & FLAGS_SIZE_T)

3258

*(size_t *)pointer = (size_t)data->committed;

3259

else

3260

#endif

3261

#if defined(QUALIFIER_PTRDIFF_T)

3262

if (flags & FLAGS_PTRDIFF_T)

3263

*(ptrdiff_t *)pointer = (ptrdiff_t)data->committed;

3264

else

3265

#endif

3266

#if defined(QUALIFIER_INTMAX_T)

3267

if (flags & FLAGS_INTMAX_T)

3268

*(trio_intmax_t *)pointer = (trio_intmax_t)data->committed;

3269

else

3270

#endif

3271

if (flags & FLAGS_QUAD)

3272

{

3273

*(trio_ulonglong_t *)pointer = (trio_ulonglong_t)data->committed;

3274

}

3275

else if (flags & FLAGS_LONG)

3276

{

3277

*(long int *)pointer = (long int)data->committed;

3278

}

3279

else if (flags & FLAGS_SHORT)

3280

{

3281

*(short int *)pointer = (short int)data->committed;

3282

}

3283

else

3284

{

3285

*(int *)pointer = (int)data->committed;

3286

}

3287

}

3288

break; /* FORMAT_COUNT */

3289

3290

case FORMAT_PARAMETER:

3291

break; /* FORMAT_PARAMETER */

3292

3293

#if defined(FORMAT_ERRNO)

3294

case FORMAT_ERRNO:

3295

string = trio_error(parameters[i].data.errorNumber);

3296

if (string)

3297

{

3298

TrioWriteString(data,

3299

string,

3300

flags,

3301

width,

3302

precision);

3303

}

3304

else

3305

{

3306

data->OutStream(data, '#');

3307

TrioWriteNumber(data,

3308

(trio_uintmax_t)parameters[i].data.errorNumber,

3309

flags,

3310

width,

3311

precision,

3312

BASE_DECIMAL);

3313

}

3314

break; /* FORMAT_ERRNO */

3315

#endif /* defined(FORMAT_ERRNO) */

3316

3317

#if defined(FORMAT_USER_DEFINED)

3318

case FORMAT_USER_DEFINED:

3319

{

3320

trio_reference_t reference;

3321

trio_userdef_t *def = NULL;

3322

3323

if (parameters[i].user_name[0] == NIL)

3324

{

3325

/* Use handle */

3326

if ((i > 0) ||

3327

(parameters[i - 1].type == FORMAT_PARAMETER))

3328

def = (trio_userdef_t *)parameters[i - 1].data.pointer;

3329

}

3330

else

3331

{

3332

/* Look up namespace */

3333

def = TrioFindNamespace(parameters[i].user_name, NULL);

3334

}

3335

if (def) {

3336

reference.data = data;

3337

reference.parameter = &parameters[i];

3338

def->callback(&reference);

3339

}

3340

}

3341

break;

3342

#endif /* defined(FORMAT_USER_DEFINED) */

3343

3344

default:

3345

break;

3346

} /* switch parameter type */

3347

3348

/* Prepare for next */

3349

index = parameters[i].indexAfterSpecifier;

3350

i++;

3351

}

3352

}

3353

else /* not identifier */

3354

{

3355

data->OutStream(data, format[index++]);

3356

}

3357

}

3358

return data->processed;

3359

}

3360

3361

/*************************************************************************

3362

* TrioFormatRef

3363

3364

TRIO_PRIVATE int

3365

TrioFormatRef

3366

TRIO_ARGS4((reference, format, arglist, argarray),

3367

trio_reference_t *reference,

3368

TRIO_CONST char *format,

3369

va_list *arglist,

3370

trio_pointer_t *argarray)

3371

{

3372

int status;

3373

trio_parameter_t parameters[MAX_PARAMETERS];

3374

3375

status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);

3376

if (status < 0)

3377

return status;

3378

3379

status = TrioFormatProcess(reference->data, format, parameters);

3380

if (reference->data->error != 0)

3381

{

3382

status = reference->data->error;

3383

}

3384

return status;

3385

}

3386

3387

/*************************************************************************

3388

* TrioFormat

3389

3390

TRIO_PRIVATE int

3391

TrioFormat

3392

TRIO_ARGS6((destination, destinationSize, OutStream, format, arglist, argarray),

3393

trio_pointer_t destination,

3394

size_t destinationSize,

3395

void (*OutStream) TRIO_PROTO((trio_class_t *, int)),

3396

TRIO_CONST char *format,

3397

va_list *arglist,

3398

trio_pointer_t *argarray)

3399

{

3400

int status;

3401

trio_class_t data;

3402

trio_parameter_t parameters[MAX_PARAMETERS];

3403

3404

assert(VALID(OutStream));

3405

assert(VALID(format));

3406

3407

memset(&data, 0, sizeof(data));

3408

data.OutStream = OutStream;

3409

data.location = destination;

3410

data.max = destinationSize;

3411

data.error = 0;

3412

3413

#if defined(USE_LOCALE)

3414

if (NULL == internalLocaleValues)

3415

{

3416

TrioSetLocale();

3417

}

3418

#endif

3419

3420

status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);

3421

if (status < 0)

3422

return status;

3423

3424

status = TrioFormatProcess(&data, format, parameters);

3425

if (data.error != 0)

3426

{

3427

status = data.error;

3428

}

3429

return status;

3430

}

3431

3432

/*************************************************************************

3433

* TrioOutStreamFile

3434

3435

TRIO_PRIVATE void

3436

TrioOutStreamFile

3437

TRIO_ARGS2((self, output),

3438

trio_class_t *self,

3439

int output)

3440

{

3441

FILE *file;

3442

3443

assert(VALID(self));

3444

assert(VALID(self->location));

3445

3446

file = (FILE *)self->location;

3447

self->processed++;

3448

if (fputc(output, file) == EOF)

3449

{

3450

self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);

3451

}

3452

else

3453

{

3454

self->committed++;

3455

}

3456

}

3457

3458

/*************************************************************************

3459

* TrioOutStreamFileDescriptor

3460

3461

TRIO_PRIVATE void

3462

TrioOutStreamFileDescriptor

3463

TRIO_ARGS2((self, output),

3464

trio_class_t *self,

3465

int output)

3466

{

3467

int fd;

3468

char ch;

3469

3470

assert(VALID(self));

3471

3472

fd = *((int *)self->location);

3473

ch = (char)output;

3474

self->processed++;

3475

if (write(fd, &ch, sizeof(char)) == -1)

3476

{

3477

self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);

3478

}

3479

else

3480

{

3481

self->committed++;

3482

}

3483

}

3484

3485

/*************************************************************************

3486

* TrioOutStreamCustom

3487

3488

TRIO_PRIVATE void

3489

TrioOutStreamCustom

3490

TRIO_ARGS2((self, output),

3491

trio_class_t *self,

3492

int output)

3493

{

3494

int status;

3495

trio_custom_t *data;

3496

3497

assert(VALID(self));

3498

assert(VALID(self->location));

3499

3500

data = (trio_custom_t *)self->location;

3501

if (data->stream.out)

3502

{

3503

status = (data->stream.out)(data->closure, output);

3504

if (status >= 0)

3505

{

3506

self->committed++;

3507

}

3508

else

3509

{

3510

if (self->error == 0)

3511

{

3512

self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status);

3513

}

3514

}

3515

}

3516

self->processed++;

3517

}

3518

3519

/*************************************************************************

3520

* TrioOutStreamString

3521

3522

TRIO_PRIVATE void

3523

TrioOutStreamString

3524

TRIO_ARGS2((self, output),

3525

trio_class_t *self,

3526

int output)

3527

{

3528

char **buffer;

3529

3530

assert(VALID(self));

3531

assert(VALID(self->location));

3532

3533

buffer = (char **)self->location;

3534

**buffer = (char)output;

3535

(*buffer)++;

3536

self->processed++;

3537

self->committed++;

3538

}

3539

3540

/*************************************************************************

3541

* TrioOutStreamStringMax

3542

3543

TRIO_PRIVATE void

3544

TrioOutStreamStringMax

3545

TRIO_ARGS2((self, output),

3546

trio_class_t *self,

3547

int output)

3548

{

3549

char **buffer;

3550

3551

assert(VALID(self));

3552

assert(VALID(self->location));

3553

3554

buffer = (char **)self->location;

3555

3556

if (self->processed < self->max)

3557

{

3558

**buffer = (char)output;

3559

(*buffer)++;

3560

self->committed++;

3561

}

3562

self->processed++;

3563

}

3564

3565

/*************************************************************************

3566

* TrioOutStreamStringDynamic

3567

3568

TRIO_PRIVATE void

3569

TrioOutStreamStringDynamic

3570

TRIO_ARGS2((self, output),

3571

trio_class_t *self,

3572

int output)

3573

{

3574

assert(VALID(self));

3575

assert(VALID(self->location));

3576

3577

if (self->error == 0)

3578

{

3579

trio_xstring_append_char((trio_string_t *)self->location,

3580

(char)output);

3581

self->committed++;

3582

}

3583

/* The processed variable must always be increased */

3584

self->processed++;

3585

}

3586

3587

/*************************************************************************

3588

3589

* Formatted printing functions

3590

3591

************************************************************************/

3592

3593

#if defined(TRIO_DOCUMENTATION)

3594

# include "doc/doc_printf.h"

3595

#endif

3596

/** @addtogroup Printf

3597

3598

3599

3600

/*************************************************************************

3601

* printf

3602

3603

3604

/**

3605

Print to standard output stream.

3606

3607

@param format Formatting string.

3608

@param ... Arguments.

3609

@return Number of printed characters.

3610

3611

TRIO_PUBLIC int

3612

trio_printf

3613

TRIO_VARGS2((format, va_alist),

3614

TRIO_CONST char *format,

3615

TRIO_VA_DECL)

3616

{

3617

int status;

3618

va_list args;

3619

3620

assert(VALID(format));

3621

3622

TRIO_VA_START(args, format);

3623

status = TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);

3624

TRIO_VA_END(args);

3625

return status;

3626

}

3627

3628

/**

3629

Print to standard output stream.

3630

3631

@param format Formatting string.

3632

@param args Arguments.

3633

@return Number of printed characters.

3634

3635

TRIO_PUBLIC int

3636

trio_vprintf

3637

TRIO_ARGS2((format, args),

3638

TRIO_CONST char *format,

3639

va_list args)

3640

{

3641

assert(VALID(format));

3642

3643

return TrioFormat(stdout, 0, TrioOutStreamFile, format, &args, NULL);

3644

}

3645

3646

/**

3647

Print to standard output stream.

3648

3649

@param format Formatting string.

3650

@param args Arguments.

3651

@return Number of printed characters.

3652

3653

TRIO_PUBLIC int

3654

trio_printfv

3655

TRIO_ARGS2((format, args),

3656

TRIO_CONST char *format,

3657

trio_pointer_t * args)

3658

{

3659

assert(VALID(format));

3660

3661

return TrioFormat(stdout, 0, TrioOutStreamFile, format, NULL, args);

3662

}

3663

3664

/*************************************************************************

3665

* fprintf

3666

3667

3668

/**

3669

Print to file.

3670

3671

@param file File pointer.

3672

@param format Formatting string.

3673

@param ... Arguments.

3674

@return Number of printed characters.

3675

3676

TRIO_PUBLIC int

3677

trio_fprintf

3678

TRIO_VARGS3((file, format, va_alist),

3679

FILE *file,

3680

TRIO_CONST char *format,

3681

TRIO_VA_DECL)

3682

{

3683

int status;

3684

va_list args;

3685

3686

assert(VALID(file));

3687

assert(VALID(format));

3688

3689

TRIO_VA_START(args, format);

3690

status = TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);

3691

TRIO_VA_END(args);

3692

return status;

3693

}

3694

3695

/**

3696

Print to file.

3697

3698

@param file File pointer.

3699

@param format Formatting string.

3700

@param args Arguments.

3701

@return Number of printed characters.

3702

3703

TRIO_PUBLIC int

3704

trio_vfprintf

3705

TRIO_ARGS3((file, format, args),

3706

FILE *file,

3707

TRIO_CONST char *format,

3708

va_list args)

3709

{

3710

assert(VALID(file));

3711

assert(VALID(format));

3712

3713

return TrioFormat(file, 0, TrioOutStreamFile, format, &args, NULL);

3714

}

3715

3716

/**

3717

Print to file.

3718

3719

@param file File pointer.

3720

@param format Formatting string.

3721

@param args Arguments.

3722

@return Number of printed characters.

3723

3724

TRIO_PUBLIC int

3725

trio_fprintfv

3726

TRIO_ARGS3((file, format, args),

3727

FILE *file,

3728

TRIO_CONST char *format,

3729

trio_pointer_t * args)

3730

{

3731

assert(VALID(file));

3732

assert(VALID(format));

3733

3734

return TrioFormat(file, 0, TrioOutStreamFile, format, NULL, args);

3735

}

3736

3737

/*************************************************************************

3738

* dprintf

3739

3740

3741

/**

3742

Print to file descriptor.

3743

3744

@param fd File descriptor.

3745

@param format Formatting string.

3746

@param ... Arguments.

3747

@return Number of printed characters.

3748

3749

TRIO_PUBLIC int

3750

trio_dprintf

3751

TRIO_VARGS3((fd, format, va_alist),

3752

int fd,

3753

TRIO_CONST char *format,

3754

TRIO_VA_DECL)

3755

{

3756

int status;

3757

va_list args;

3758

3759

assert(VALID(format));

3760

3761

TRIO_VA_START(args, format);

3762

status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);

3763

TRIO_VA_END(args);

3764

return status;

3765

}

3766

3767

/**

3768

Print to file descriptor.

3769

3770

@param fd File descriptor.

3771

@param format Formatting string.

3772

@param args Arguments.

3773

@return Number of printed characters.

3774

3775

TRIO_PUBLIC int

3776

trio_vdprintf

3777

TRIO_ARGS3((fd, format, args),

3778

int fd,

3779

TRIO_CONST char *format,

3780

va_list args)

3781

{

3782

assert(VALID(format));

3783

3784

return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, &args, NULL);

3785

}

3786

3787

/**

3788

Print to file descriptor.

3789

3790

@param fd File descriptor.

3791

@param format Formatting string.

3792

@param args Arguments.

3793

@return Number of printed characters.

3794

3795

TRIO_PUBLIC int

3796

trio_dprintfv

3797

TRIO_ARGS3((fd, format, args),

3798

int fd,

3799

TRIO_CONST char *format,

3800

trio_pointer_t *args)

3801

{

3802

assert(VALID(format));

3803

3804

return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, NULL, args);

3805

}

3806

3807

/*************************************************************************

3808

* cprintf

3809

3810

TRIO_PUBLIC int

3811

trio_cprintf

3812

TRIO_VARGS4((stream, closure, format, va_alist),

3813

trio_outstream_t stream,

3814

trio_pointer_t closure,

3815

TRIO_CONST char *format,

3816

TRIO_VA_DECL)

3817

{

3818

int status;

3819

va_list args;

3820

trio_custom_t data;

3821

3822

assert(VALID(stream));

3823

assert(VALID(format));

3824

3825

TRIO_VA_START(args, format);

3826

data.stream.out = stream;

3827

data.closure = closure;

3828

status = TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);

3829

TRIO_VA_END(args);

3830

return status;

3831

}

3832

3833

TRIO_PUBLIC int

3834

trio_vcprintf

3835

TRIO_ARGS4((stream, closure, format, args),

3836

trio_outstream_t stream,

3837

trio_pointer_t closure,

3838

TRIO_CONST char *format,

3839

va_list args)

3840

{

3841

trio_custom_t data;

3842

3843

assert(VALID(stream));

3844

assert(VALID(format));

3845

3846

data.stream.out = stream;

3847

data.closure = closure;

3848

return TrioFormat(&data, 0, TrioOutStreamCustom, format, &args, NULL);

3849

}

3850

3851

TRIO_PUBLIC int

3852

trio_cprintfv

3853

TRIO_ARGS4((stream, closure, format, args),

3854

trio_outstream_t stream,

3855

trio_pointer_t closure,

3856

TRIO_CONST char *format,

3857

void **args)

3858

{

3859

trio_custom_t data;

3860

3861

assert(VALID(stream));

3862

assert(VALID(format));

3863

3864

data.stream.out = stream;

3865

data.closure = closure;

3866

return TrioFormat(&data, 0, TrioOutStreamCustom, format, NULL, args);

3867

}

3868

3869

/*************************************************************************

3870

* sprintf

3871

3872

3873

/**

3874

Print to string.

3875

3876

@param buffer Output string.

3877

@param format Formatting string.

3878

@param ... Arguments.

3879

@return Number of printed characters.

3880

3881

TRIO_PUBLIC int

3882

trio_sprintf

3883

TRIO_VARGS3((buffer, format, va_alist),

3884

char *buffer,

3885

TRIO_CONST char *format,

3886

TRIO_VA_DECL)

3887

{

3888

int status;

3889

va_list args;

3890

3891

assert(VALID(buffer));

3892

assert(VALID(format));

3893

3894

TRIO_VA_START(args, format);

3895

status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);

3896

*buffer = NIL; /* Terminate with NIL character */

3897

TRIO_VA_END(args);

3898

return status;

3899

}

3900

3901

/**

3902

Print to string.

3903

3904

@param buffer Output string.

3905

@param format Formatting string.

3906

@param args Arguments.

3907

@return Number of printed characters.

3908

3909

TRIO_PUBLIC int

3910

trio_vsprintf

3911

TRIO_ARGS3((buffer, format, args),

3912

char *buffer,

3913

TRIO_CONST char *format,

3914

va_list args)

3915

{

3916

int status;

3917

3918

assert(VALID(buffer));

3919

assert(VALID(format));

3920

3921

status = TrioFormat(&buffer, 0, TrioOutStreamString, format, &args, NULL);

3922

*buffer = NIL;

3923

return status;

3924

}

3925

3926

/**

3927

Print to string.

3928

3929

@param buffer Output string.

3930

@param format Formatting string.

3931

@param args Arguments.

3932

@return Number of printed characters.

3933

3934

TRIO_PUBLIC int

3935

trio_sprintfv

3936

TRIO_ARGS3((buffer, format, args),

3937

char *buffer,

3938

TRIO_CONST char *format,

3939

trio_pointer_t *args)

3940

{

3941

int status;

3942

3943

assert(VALID(buffer));

3944

assert(VALID(format));

3945

3946

status = TrioFormat(&buffer, 0, TrioOutStreamString, format, NULL, args);

3947

*buffer = NIL;

3948

return status;

3949

}

3950

3951

/*************************************************************************

3952

* snprintf

3953

3954

3955

/**

3956

Print at most @p max characters to string.

3957

3958

@param buffer Output string.

3959

@param max Maximum number of characters to print.

3960

@param format Formatting string.

3961

@param ... Arguments.

3962

@return Number of printed characters.

3963

3964

TRIO_PUBLIC int

3965

trio_snprintf

3966

TRIO_VARGS4((buffer, max, format, va_alist),

3967

char *buffer,

3968

size_t max,

3969

TRIO_CONST char *format,

3970

TRIO_VA_DECL)

3971

{

3972

int status;

3973

va_list args;

3974

3975

assert(VALID(buffer));

3976

assert(VALID(format));

3977

3978

TRIO_VA_START(args, format);

3979

status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,

3980

TrioOutStreamStringMax, format, &args, NULL);

3981

if (max > 0)

3982

*buffer = NIL;

3983

TRIO_VA_END(args);

3984

return status;

3985

}

3986

3987

/**

3988

Print at most @p max characters to string.

3989

3990

@param buffer Output string.

3991

@param max Maximum number of characters to print.

3992

@param format Formatting string.

3993

@param args Arguments.

3994

@return Number of printed characters.

3995

3996

TRIO_PUBLIC int

3997

trio_vsnprintf

3998

TRIO_ARGS4((buffer, max, format, args),

3999

char *buffer,

4000

size_t max,

4001

TRIO_CONST char *format,

4002

va_list args)

4003

{

4004

int status;

4005

4006

assert(VALID(buffer));

4007

assert(VALID(format));

4008

4009

status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,

4010

TrioOutStreamStringMax, format, &args, NULL);

4011

if (max > 0)

4012

*buffer = NIL;

4013

return status;

4014

}

4015

4016

/**

4017

Print at most @p max characters to string.

4018

4019

@param buffer Output string.

4020

@param max Maximum number of characters to print.

4021

@param format Formatting string.

4022

@param args Arguments.

4023

@return Number of printed characters.

4024

4025

TRIO_PUBLIC int

4026

trio_snprintfv

4027

TRIO_ARGS4((buffer, max, format, args),

4028

char *buffer,

4029

size_t max,

4030

TRIO_CONST char *format,

4031

trio_pointer_t *args)

4032

{

4033

int status;

4034

4035

assert(VALID(buffer));

4036

assert(VALID(format));

4037

4038

status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,

4039

TrioOutStreamStringMax, format, NULL, args);

4040

if (max > 0)

4041

*buffer = NIL;

4042

return status;

4043

}

4044

4045

/*************************************************************************

4046

* snprintfcat

4047

* Appends the new string to the buffer string overwriting the '\0'

4048

* character at the end of buffer.

4049

4050

TRIO_PUBLIC int

4051

trio_snprintfcat

4052

TRIO_VARGS4((buffer, max, format, va_alist),

4053

char *buffer,

4054

size_t max,

4055

TRIO_CONST char *format,

4056

TRIO_VA_DECL)

4057

{

4058

int status;

4059

va_list args;

4060

size_t buf_len;

4061

4062

TRIO_VA_START(args, format);

4063

4064

assert(VALID(buffer));

4065

assert(VALID(format));

4066

4067

buf_len = trio_length(buffer);

4068

buffer = &buffer[buf_len];

4069

4070

status = TrioFormat(&buffer, max - 1 - buf_len,

4071

TrioOutStreamStringMax, format, &args, NULL);

4072

TRIO_VA_END(args);

4073

*buffer = NIL;

4074

return status;

4075

}

4076

4077

TRIO_PUBLIC int

4078

trio_vsnprintfcat

4079

TRIO_ARGS4((buffer, max, format, args),

4080

char *buffer,

4081

size_t max,

4082

TRIO_CONST char *format,

4083

va_list args)

4084

{

4085

int status;

4086

size_t buf_len;

4087

4088

assert(VALID(buffer));

4089

assert(VALID(format));

4090

4091

buf_len = trio_length(buffer);

4092

buffer = &buffer[buf_len];

4093

status = TrioFormat(&buffer, max - 1 - buf_len,

4094

TrioOutStreamStringMax, format, &args, NULL);

4095

*buffer = NIL;

4096

return status;

4097

}

4098

4099

/*************************************************************************

4100

* trio_aprintf

4101

4102

4103

/* Deprecated */

4104

TRIO_PUBLIC char *

4105

trio_aprintf

4106

TRIO_VARGS2((format, va_alist),

4107

TRIO_CONST char *format,

4108

TRIO_VA_DECL)

4109

{

4110

va_list args;

4111

trio_string_t *info;

4112

char *result = NULL;

4113

4114

assert(VALID(format));

4115

4116

info = trio_xstring_duplicate("");

4117

if (info)

4118

{

4119

TRIO_VA_START(args, format);

4120

(void)TrioFormat(info, 0, TrioOutStreamStringDynamic,

4121

format, &args, NULL);

4122

TRIO_VA_END(args);

4123

4124

trio_string_terminate(info);

4125

result = trio_string_extract(info);

4126

trio_string_destroy(info);

4127

}

4128

return result;

4129

}

4130

4131

/* Deprecated */

4132

TRIO_PUBLIC char *

4133

trio_vaprintf

4134

TRIO_ARGS2((format, args),

4135

TRIO_CONST char *format,

4136

va_list args)

4137

{

4138

trio_string_t *info;

4139

char *result = NULL;

4140

4141

assert(VALID(format));

4142

4143

info = trio_xstring_duplicate("");

4144

if (info)

4145

{

4146

(void)TrioFormat(info, 0, TrioOutStreamStringDynamic,

4147

format, &args, NULL);

4148

trio_string_terminate(info);

4149

result = trio_string_extract(info);

4150

trio_string_destroy(info);

4151

}

4152

return result;

4153

}

4154

4155

TRIO_PUBLIC int

4156

trio_asprintf

4157

TRIO_VARGS3((result, format, va_alist),

4158

char **result,

4159

TRIO_CONST char *format,

4160

TRIO_VA_DECL)

4161

{

4162

va_list args;

4163

int status;

4164

trio_string_t *info;

4165

4166

assert(VALID(format));

4167

4168

*result = NULL;

4169

4170

info = trio_xstring_duplicate("");

4171

if (info == NULL)

4172

{

4173

status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);

4174

}

4175

else

4176

{

4177

TRIO_VA_START(args, format);

4178

status = TrioFormat(info, 0, TrioOutStreamStringDynamic,

4179

format, &args, NULL);

4180

TRIO_VA_END(args);

4181

if (status >= 0)

4182

{

4183

trio_string_terminate(info);

4184

*result = trio_string_extract(info);

4185

}

4186

trio_string_destroy(info);

4187

}

4188

return status;

4189

}

4190

4191

TRIO_PUBLIC int

4192

trio_vasprintf

4193

TRIO_ARGS3((result, format, args),

4194

char **result,

4195

TRIO_CONST char *format,

4196

va_list args)

4197

{

4198

int status;

4199

trio_string_t *info;

4200

4201

assert(VALID(format));

4202

4203

*result = NULL;

4204

4205

info = trio_xstring_duplicate("");

4206

if (info == NULL)

4207

{

4208

status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);

4209

}

4210

else

4211

{

4212

status = TrioFormat(info, 0, TrioOutStreamStringDynamic,

4213

format, &args, NULL);

4214

if (status >= 0)

4215

{

4216

trio_string_terminate(info);

4217

*result = trio_string_extract(info);

4218

}

4219

trio_string_destroy(info);

4220

}

4221

return status;

4222

}

4223

4224

/** @} End of Printf documentation module */

4225

4226

/*************************************************************************

4227

4228

* CALLBACK

4229

4230

************************************************************************/

4231

4232

#if defined(TRIO_DOCUMENTATION)

4233

# include "doc/doc_register.h"

4234

#endif

4235

/**

4236

@addtogroup UserDefined

4237

4238

4239

4240

#if TRIO_EXTENSION

4241

4242

/*************************************************************************

4243

* trio_register

4244

4245

4246

/**

4247

4248

4249

@param callback

4250

@param name

4251

@return Handle.

4252

4253

TRIO_PUBLIC trio_pointer_t

4254

trio_register

4255

TRIO_ARGS2((callback, name),

4256

trio_callback_t callback,

4257

TRIO_CONST char *name)

4258

{

4259

trio_userdef_t *def;

4260

trio_userdef_t *prev = NULL;

4261

4262

if (callback == NULL)

4263

return NULL;

4264

4265

if (name)

4266

{

4267

/* Handle built-in namespaces */

4268

if (name[0] == ':')

4269

{

4270

if (trio_equal(name, ":enter"))

4271

{

4272

internalEnterCriticalRegion = callback;

4273

}

4274

else if (trio_equal(name, ":leave"))

4275

{

4276

internalLeaveCriticalRegion = callback;

4277

}

4278

return NULL;

4279

}

4280

4281

/* Bail out if namespace is too long */

4282

if (trio_length(name) >= MAX_USER_NAME)

4283

return NULL;

4284

4285

/* Bail out if namespace already is registered */

4286

def = TrioFindNamespace(name, &prev);

4287

if (def)

4288

return NULL;

4289

}

4290

4291

def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t));

4292

if (def)

4293

{

4294

if (internalEnterCriticalRegion)

4295

(void)internalEnterCriticalRegion(NULL);

4296

4297

if (name)

4298

{

4299

/* Link into internal list */

4300

if (prev == NULL)

4301

internalUserDef = def;

4302

else

4303

prev->next = def;

4304

}

4305

/* Initialize */

4306

def->callback = callback;

4307

def->name = (name == NULL)

4308

? NULL

4309

: trio_duplicate(name);

4310

def->next = NULL;

4311

4312

if (internalLeaveCriticalRegion)

4313

(void)internalLeaveCriticalRegion(NULL);

4314

}

4315

return (trio_pointer_t)def;

4316

}

4317

4318

/**

4319

Unregister an existing user-defined specifier.

4320

4321

@param handle

4322

4323

void

4324

trio_unregister

4325

TRIO_ARGS1((handle),

4326

trio_pointer_t handle)

4327

{

4328

trio_userdef_t *self = (trio_userdef_t *)handle;

4329

trio_userdef_t *def;

4330

trio_userdef_t *prev = NULL;

4331

4332

assert(VALID(self));

4333

4334

if (self->name)

4335

{

4336

def = TrioFindNamespace(self->name, &prev);

4337

if (def)

4338

{

4339

if (internalEnterCriticalRegion)

4340

(void)internalEnterCriticalRegion(NULL);

4341

4342

if (prev == NULL)

4343

internalUserDef = NULL;

4344

else

4345

prev->next = def->next;

4346

4347

if (internalLeaveCriticalRegion)

4348

(void)internalLeaveCriticalRegion(NULL);

4349

}

4350

trio_destroy(self->name);

4351

}

4352

TRIO_FREE(self);

4353

}

4354

4355

/*************************************************************************

4356

* trio_get_format [public]

4357

4358

TRIO_CONST char *

4359

trio_get_format

4360

TRIO_ARGS1((ref),

4361

trio_pointer_t ref)

4362

{

4363

#if defined(FORMAT_USER_DEFINED)

4364

assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);

4365

#endif

4366

4367

return (((trio_reference_t *)ref)->parameter->user_data);

4368

}

4369

4370

/*************************************************************************

4371

* trio_get_argument [public]

4372

4373

trio_pointer_t

4374

trio_get_argument

4375

TRIO_ARGS1((ref),

4376

trio_pointer_t ref)

4377

{

4378

#if defined(FORMAT_USER_DEFINED)

4379

assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);

4380

#endif

4381

4382

return ((trio_reference_t *)ref)->parameter->data.pointer;

4383

}

4384

4385

/*************************************************************************

4386

* trio_get_width / trio_set_width [public]

4387

4388

int

4389

trio_get_width

4390

TRIO_ARGS1((ref),

4391

trio_pointer_t ref)

4392

{

4393

return ((trio_reference_t *)ref)->parameter->width;

4394

}

4395

4396

void

4397

trio_set_width

4398

TRIO_ARGS2((ref, width),

4399

trio_pointer_t ref,

4400

int width)

4401

{

4402

((trio_reference_t *)ref)->parameter->width = width;

4403

}

4404

4405

/*************************************************************************

4406

* trio_get_precision / trio_set_precision [public]

4407

4408

int

4409

trio_get_precision

4410

TRIO_ARGS1((ref),

4411

trio_pointer_t ref)

4412

{

4413

return (((trio_reference_t *)ref)->parameter->precision);

4414

}

4415

4416

void

4417

trio_set_precision

4418

TRIO_ARGS2((ref, precision),

4419

trio_pointer_t ref,

4420

int precision)

4421

{

4422

((trio_reference_t *)ref)->parameter->precision = precision;

4423

}

4424

4425

/*************************************************************************

4426

* trio_get_base / trio_set_base [public]

4427

4428

int

4429

trio_get_base

4430

TRIO_ARGS1((ref),

4431

trio_pointer_t ref)

4432

{

4433

return (((trio_reference_t *)ref)->parameter->base);

4434

}

4435

4436

void

4437

trio_set_base

4438

TRIO_ARGS2((ref, base),

4439

trio_pointer_t ref,

4440

int base)

4441

{

4442

((trio_reference_t *)ref)->parameter->base = base;

4443

}

4444

4445

/*************************************************************************

4446

* trio_get_long / trio_set_long [public]

4447

4448

int

4449

trio_get_long

4450

TRIO_ARGS1((ref),

4451

trio_pointer_t ref)

4452

{

4453

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONG)

4454

? TRUE

4455

: FALSE;

4456

}

4457

4458

void

4459

trio_set_long

4460

TRIO_ARGS2((ref, is_long),

4461

trio_pointer_t ref,

4462

int is_long)

4463

{

4464

if (is_long)

4465

((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONG;

4466

else

4467

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONG;

4468

}

4469

4470

/*************************************************************************

4471

* trio_get_longlong / trio_set_longlong [public]

4472

4473

int

4474

trio_get_longlong

4475

TRIO_ARGS1((ref),

4476

trio_pointer_t ref)

4477

{

4478

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUAD)

4479

? TRUE

4480

: FALSE;

4481

}

4482

4483

void

4484

trio_set_longlong

4485

TRIO_ARGS2((ref, is_longlong),

4486

trio_pointer_t ref,

4487

int is_longlong)

4488

{

4489

if (is_longlong)

4490

((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUAD;

4491

else

4492

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUAD;

4493

}

4494

4495

/*************************************************************************

4496

* trio_get_longdouble / trio_set_longdouble [public]

4497

4498

int

4499

trio_get_longdouble

4500

TRIO_ARGS1((ref),

4501

trio_pointer_t ref)

4502

{

4503

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONGDOUBLE)

4504

? TRUE

4505

: FALSE;

4506

}

4507

4508

void

4509

trio_set_longdouble

4510

TRIO_ARGS2((ref, is_longdouble),

4511

trio_pointer_t ref,

4512

int is_longdouble)

4513

{

4514

if (is_longdouble)

4515

((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONGDOUBLE;

4516

else

4517

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;

4518

}

4519

4520

/*************************************************************************

4521

* trio_get_short / trio_set_short [public]

4522

4523

int

4524

trio_get_short

4525

TRIO_ARGS1((ref),

4526

trio_pointer_t ref)

4527

{

4528

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORT)

4529

? TRUE

4530

: FALSE;

4531

}

4532

4533

void

4534

trio_set_short

4535

TRIO_ARGS2((ref, is_short),

4536

trio_pointer_t ref,

4537

int is_short)

4538

{

4539

if (is_short)

4540

((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORT;

4541

else

4542

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORT;

4543

}

4544

4545

/*************************************************************************

4546

* trio_get_shortshort / trio_set_shortshort [public]

4547

4548

int

4549

trio_get_shortshort

4550

TRIO_ARGS1((ref),

4551

trio_pointer_t ref)

4552

{

4553

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORTSHORT)

4554

? TRUE

4555

: FALSE;

4556

}

4557

4558

void

4559

trio_set_shortshort

4560

TRIO_ARGS2((ref, is_shortshort),

4561

trio_pointer_t ref,

4562

int is_shortshort)

4563

{

4564

if (is_shortshort)

4565

((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORTSHORT;

4566

else

4567

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;

4568

}

4569

4570

/*************************************************************************

4571

* trio_get_alternative / trio_set_alternative [public]

4572

4573

int

4574

trio_get_alternative

4575

TRIO_ARGS1((ref),

4576

trio_pointer_t ref)

4577

{

4578

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_ALTERNATIVE)

4579

? TRUE

4580

: FALSE;

4581

}

4582

4583

void

4584

trio_set_alternative

4585

TRIO_ARGS2((ref, is_alternative),

4586

trio_pointer_t ref,

4587

int is_alternative)

4588

{

4589

if (is_alternative)

4590

((trio_reference_t *)ref)->parameter->flags |= FLAGS_ALTERNATIVE;

4591

else

4592

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;

4593

}

4594

4595

/*************************************************************************

4596

* trio_get_alignment / trio_set_alignment [public]

4597

4598

int

4599

trio_get_alignment

4600

TRIO_ARGS1((ref),

4601

trio_pointer_t ref)

4602

{

4603

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LEFTADJUST)

4604

? TRUE

4605

: FALSE;

4606

}

4607

4608

void

4609

trio_set_alignment

4610

TRIO_ARGS2((ref, is_leftaligned),

4611

trio_pointer_t ref,

4612

int is_leftaligned)

4613

{

4614

if (is_leftaligned)

4615

((trio_reference_t *)ref)->parameter->flags |= FLAGS_LEFTADJUST;

4616

else

4617

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;

4618

}

4619

4620

/*************************************************************************

4621

* trio_get_spacing /trio_set_spacing [public]

4622

4623

int

4624

trio_get_spacing

4625

TRIO_ARGS1((ref),

4626

trio_pointer_t ref)

4627

{

4628

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SPACE)

4629

? TRUE

4630

: FALSE;

4631

}

4632

4633

void

4634

trio_set_spacing

4635

TRIO_ARGS2((ref, is_space),

4636

trio_pointer_t ref,

4637

int is_space)

4638

{

4639

if (is_space)

4640

((trio_reference_t *)ref)->parameter->flags |= FLAGS_SPACE;

4641

else

4642

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SPACE;

4643

}

4644

4645

/*************************************************************************

4646

* trio_get_sign / trio_set_sign [public]

4647

4648

int

4649

trio_get_sign

4650

TRIO_ARGS1((ref),

4651

trio_pointer_t ref)

4652

{

4653

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHOWSIGN)

4654

? TRUE

4655

: FALSE;

4656

}

4657

4658

void

4659

trio_set_sign

4660

TRIO_ARGS2((ref, is_sign),

4661

trio_pointer_t ref,

4662

int is_sign)

4663

{

4664

if (is_sign)

4665

((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHOWSIGN;

4666

else

4667

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;

4668

}

4669

4670

/*************************************************************************

4671

* trio_get_padding / trio_set_padding [public]

4672

4673

int

4674

trio_get_padding

4675

TRIO_ARGS1((ref),

4676

trio_pointer_t ref)

4677

{

4678

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_NILPADDING)

4679

? TRUE

4680

: FALSE;

4681

}

4682

4683

void

4684

trio_set_padding

4685

TRIO_ARGS2((ref, is_padding),

4686

trio_pointer_t ref,

4687

int is_padding)

4688

{

4689

if (is_padding)

4690

((trio_reference_t *)ref)->parameter->flags |= FLAGS_NILPADDING;

4691

else

4692

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_NILPADDING;

4693

}

4694

4695

/*************************************************************************

4696

* trio_get_quote / trio_set_quote [public]

4697

4698

int

4699

trio_get_quote

4700

TRIO_ARGS1((ref),

4701

trio_pointer_t ref)

4702

{

4703

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUOTE)

4704

? TRUE

4705

: FALSE;

4706

}

4707

4708

void

4709

trio_set_quote

4710

TRIO_ARGS2((ref, is_quote),

4711

trio_pointer_t ref,

4712

int is_quote)

4713

{

4714

if (is_quote)

4715

((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUOTE;

4716

else

4717

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUOTE;

4718

}

4719

4720

/*************************************************************************

4721

* trio_get_upper / trio_set_upper [public]

4722

4723

int

4724

trio_get_upper

4725

TRIO_ARGS1((ref),

4726

trio_pointer_t ref)

4727

{

4728

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_UPPER)

4729

? TRUE

4730

: FALSE;

4731

}

4732

4733

void

4734

trio_set_upper

4735

TRIO_ARGS2((ref, is_upper),

4736

trio_pointer_t ref,

4737

int is_upper)

4738

{

4739

if (is_upper)

4740

((trio_reference_t *)ref)->parameter->flags |= FLAGS_UPPER;

4741

else

4742

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_UPPER;

4743

}

4744

4745

/*************************************************************************

4746

* trio_get_largest / trio_set_largest [public]

4747

4748

#if TRIO_C99

4749

int

4750

trio_get_largest

4751

TRIO_ARGS1((ref),

4752

trio_pointer_t ref)

4753

{

4754

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_INTMAX_T)

4755

? TRUE

4756

: FALSE;

4757

}

4758

4759

void

4760

trio_set_largest

4761

TRIO_ARGS2((ref, is_largest),

4762

trio_pointer_t ref,

4763

int is_largest)

4764

{

4765

if (is_largest)

4766

((trio_reference_t *)ref)->parameter->flags |= FLAGS_INTMAX_T;

4767

else

4768

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_INTMAX_T;

4769

}

4770

#endif

4771

4772

/*************************************************************************

4773

* trio_get_ptrdiff / trio_set_ptrdiff [public]

4774

4775

int

4776

trio_get_ptrdiff

4777

TRIO_ARGS1((ref),

4778

trio_pointer_t ref)

4779

{

4780

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_PTRDIFF_T)

4781

? TRUE

4782

: FALSE;

4783

}

4784

4785

void

4786

trio_set_ptrdiff

4787

TRIO_ARGS2((ref, is_ptrdiff),

4788

trio_pointer_t ref,

4789

int is_ptrdiff)

4790

{

4791

if (is_ptrdiff)

4792

((trio_reference_t *)ref)->parameter->flags |= FLAGS_PTRDIFF_T;

4793

else

4794

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;

4795

}

4796

4797

/*************************************************************************

4798

* trio_get_size / trio_set_size [public]

4799

4800

#if TRIO_C99

4801

int

4802

trio_get_size

4803

TRIO_ARGS1((ref),

4804

trio_pointer_t ref)

4805

{

4806

return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SIZE_T)

4807

? TRUE

4808

: FALSE;

4809

}

4810

4811

void

4812

trio_set_size

4813

TRIO_ARGS2((ref, is_size),

4814

trio_pointer_t ref,

4815

int is_size)

4816

{

4817

if (is_size)

4818

((trio_reference_t *)ref)->parameter->flags |= FLAGS_SIZE_T;

4819

else

4820

((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SIZE_T;

4821

}

4822

#endif

4823

4824

/*************************************************************************

4825

* trio_print_int [public]

4826

4827

void

4828

trio_print_int

4829

TRIO_ARGS2((ref, number),

4830

trio_pointer_t ref,

4831

int number)

4832

{

4833

trio_reference_t *self = (trio_reference_t *)ref;

4834

4835

TrioWriteNumber(self->data,

4836

(trio_uintmax_t)number,

4837

self->parameter->flags,

4838

self->parameter->width,

4839

self->parameter->precision,

4840

self->parameter->base);

4841

}

4842

4843

/*************************************************************************

4844

* trio_print_uint [public]

4845

4846

void

4847

trio_print_uint

4848

TRIO_ARGS2((ref, number),

4849

trio_pointer_t ref,

4850

unsigned int number)

4851

{

4852

trio_reference_t *self = (trio_reference_t *)ref;

4853

4854

TrioWriteNumber(self->data,

4855

(trio_uintmax_t)number,

4856

self->parameter->flags | FLAGS_UNSIGNED,

4857

self->parameter->width,

4858

self->parameter->precision,

4859

self->parameter->base);

4860

}

4861

4862

/*************************************************************************

4863

* trio_print_double [public]

4864

4865

void

4866

trio_print_double

4867

TRIO_ARGS2((ref, number),

4868

trio_pointer_t ref,

4869

double number)

4870

{

4871

trio_reference_t *self = (trio_reference_t *)ref;

4872

4873

TrioWriteDouble(self->data,

4874

number,

4875

self->parameter->flags,

4876

self->parameter->width,

4877

self->parameter->precision,

4878

self->parameter->base);

4879

}

4880

4881

/*************************************************************************

4882

* trio_print_string [public]

4883

4884

void

4885

trio_print_string

4886

TRIO_ARGS2((ref, string),

4887

trio_pointer_t ref,

4888

char *string)

4889

{

4890

trio_reference_t *self = (trio_reference_t *)ref;

4891

4892

TrioWriteString(self->data,

4893

string,

4894

self->parameter->flags,

4895

self->parameter->width,

4896

self->parameter->precision);

4897

}

4898

4899

/*************************************************************************

4900

* trio_print_ref [public]

4901

4902

int

4903

trio_print_ref

4904

TRIO_VARGS3((ref, format, va_alist),

4905

trio_pointer_t ref,

4906

TRIO_CONST char *format,

4907

TRIO_VA_DECL)

4908

{

4909

int status;

4910

va_list arglist;

4911

4912

assert(VALID(format));

4913

4914

TRIO_VA_START(arglist, format);

4915

status = TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);

4916

TRIO_VA_END(arglist);

4917

return status;

4918

}

4919

4920

/*************************************************************************

4921

* trio_vprint_ref [public]

4922

4923

int

4924

trio_vprint_ref

4925

TRIO_ARGS3((ref, format, arglist),

4926

trio_pointer_t ref,

4927

TRIO_CONST char *format,

4928

va_list arglist)

4929

{

4930

assert(VALID(format));

4931

4932

return TrioFormatRef((trio_reference_t *)ref, format, &arglist, NULL);

4933

}

4934

4935

/*************************************************************************

4936

* trio_printv_ref [public]

4937

4938

int

4939

trio_printv_ref

4940

TRIO_ARGS3((ref, format, argarray),

4941

trio_pointer_t ref,

4942

TRIO_CONST char *format,

4943

trio_pointer_t *argarray)

4944

{

4945

assert(VALID(format));

4946

4947

return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray);

4948

}

4949

4950

#endif /* TRIO_EXTENSION */

4951

4952

/*************************************************************************

4953

* trio_print_pointer [public]

4954

4955

void

4956

trio_print_pointer

4957

TRIO_ARGS2((ref, pointer),

4958

trio_pointer_t ref,

4959

trio_pointer_t pointer)

4960

{

4961

trio_reference_t *self = (trio_reference_t *)ref;

4962

trio_flags_t flags;

4963

trio_uintmax_t number;

4964

4965

if (NULL == pointer)

4966

{

4967

TRIO_CONST char *string = internalNullString;

4968

while (*string)

4969

self->data->OutStream(self->data, *string++);

4970

}

4971

else

4972

{

4973

4974

* The subtraction of the null pointer is a workaround

4975

* to avoid a compiler warning. The performance overhead

4976

* is negligible (and likely to be removed by an

4977

* optimizing compiler). The (char *) casting is done

4978

* to please ANSI C++.

4979

4980

number = (trio_uintmax_t)((char *)pointer - (char *)0);

4981

/* Shrink to size of pointer */

4982

number &= (trio_uintmax_t)-1;

4983

flags = self->parameter->flags;

4984

flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE |

4985

FLAGS_NILPADDING);

4986

TrioWriteNumber(self->data,

4987

number,

4988

flags,

4989

POINTER_WIDTH,

4990

NO_PRECISION,

4991

BASE_HEX);

4992

}

4993

}

4994

4995

/** @} End of UserDefined documentation module */

4996

4997

/*************************************************************************

4998

4999

* LOCALES

5000

5001

************************************************************************/

5002

5003

/*************************************************************************

5004

* trio_locale_set_decimal_point

5005

5006

* Decimal point can only be one character. The input argument is a

5007

* string to enable multibyte characters. At most MB_LEN_MAX characters

5008

* will be used.

5009

5010

TRIO_PUBLIC void

5011

trio_locale_set_decimal_point

5012

TRIO_ARGS1((decimalPoint),

5013

char *decimalPoint)

5014

{

5015

#if defined(USE_LOCALE)

5016

if (NULL == internalLocaleValues)

5017

{

5018

TrioSetLocale();

5019

}

5020

#endif

5021

internalDecimalPointLength = trio_length(decimalPoint);

5022

if (internalDecimalPointLength == 1)

5023

{

5024

internalDecimalPoint = *decimalPoint;

5025

}

5026

else

5027

{

5028

internalDecimalPoint = NIL;

5029

trio_copy_max(internalDecimalPointString,

5030

sizeof(internalDecimalPointString),

5031

decimalPoint);

5032

}

5033

}

5034

5035

/*************************************************************************

5036

* trio_locale_set_thousand_separator

5037

5038

* See trio_locale_set_decimal_point

5039

5040

TRIO_PUBLIC void

5041

trio_locale_set_thousand_separator

5042

TRIO_ARGS1((thousandSeparator),

5043

char *thousandSeparator)

5044

{

5045

#if defined(USE_LOCALE)

5046

if (NULL == internalLocaleValues)

5047

{

5048

TrioSetLocale();

5049

}

5050

#endif

5051

trio_copy_max(internalThousandSeparator,

5052

sizeof(internalThousandSeparator),

5053

thousandSeparator);

5054

internalThousandSeparatorLength = trio_length(internalThousandSeparator);

5055

}

5056

5057

/*************************************************************************

5058

* trio_locale_set_grouping

5059

5060

* Array of bytes. Reversed order.

5061

5062

* CHAR_MAX : No further grouping

5063

* 0 : Repeat last group for the remaining digits (not necessary

5064

* as C strings are zero-terminated)

5065

* n : Set current group to n

5066

5067

* Same order as the grouping attribute in LC_NUMERIC.

5068

5069

TRIO_PUBLIC void

5070

trio_locale_set_grouping

5071

TRIO_ARGS1((grouping),

5072

char *grouping)

5073

{

5074

#if defined(USE_LOCALE)

5075

if (NULL == internalLocaleValues)

5076

{

5077

TrioSetLocale();

5078

}

5079

#endif

5080

trio_copy_max(internalGrouping,

5081

sizeof(internalGrouping),

5082

grouping);

5083

}

5084

5085

5086

/*************************************************************************

5087

5088

* SCANNING

5089

5090

************************************************************************/

5091

5092

/*************************************************************************

5093

* TrioSkipWhitespaces

5094

5095

TRIO_PRIVATE int

5096

TrioSkipWhitespaces

5097

TRIO_ARGS1((self),

5098

trio_class_t *self)

5099

{

5100

int ch;

5101

5102

ch = self->current;

5103

while (isspace(ch))

5104

{

5105

self->InStream(self, &ch);

5106

}

5107

return ch;

5108

}

5109

5110

/*************************************************************************

5111

* TrioGetCollation

5112

5113

#if TRIO_EXTENSION

5114

TRIO_PRIVATE void

5115

TrioGetCollation(TRIO_NOARGS)

5116

{

5117

int i;

5118

int j;

5119

int k;

5120

char first[2];

5121

char second[2];

5122

5123

/* This is computationally expensive */

5124

first[1] = NIL;

5125

second[1] = NIL;

5126

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5127

{

5128

k = 0;

5129

first[0] = (char)i;

5130

for (j = 0; j < MAX_CHARACTER_CLASS; j++)

5131

{

5132

second[0] = (char)j;

5133

if (trio_equal_locale(first, second))

5134

internalCollationArray[i][k++] = (char)j;

5135

}

5136

internalCollationArray[i][k] = NIL;

5137

}

5138

}

5139

#endif

5140

5141

/*************************************************************************

5142

* TrioGetCharacterClass

5143

5144

* FIXME:

5145

* multibyte

5146

5147

TRIO_PRIVATE int

5148

TrioGetCharacterClass

5149

TRIO_ARGS4((format, indexPointer, flagsPointer, characterclass),

5150

TRIO_CONST char *format,

5151

int *indexPointer,

5152

trio_flags_t *flagsPointer,

5153

int *characterclass)

5154

{

5155

int index = *indexPointer;

5156

int i;

5157

char ch;

5158

char range_begin;

5159

char range_end;

5160

5161

*flagsPointer &= ~FLAGS_EXCLUDE;

5162

5163

if (format[index] == QUALIFIER_CIRCUMFLEX)

5164

{

5165

*flagsPointer |= FLAGS_EXCLUDE;

5166

index++;

5167

}

5168

5169

* If the ungroup character is at the beginning of the scanlist,

5170

* it will be part of the class, and a second ungroup character

5171

* must follow to end the group.

5172

5173

if (format[index] == SPECIFIER_UNGROUP)

5174

{

5175

characterclass[(int)SPECIFIER_UNGROUP]++;

5176

index++;

5177

}

5178

5179

* Minus is used to specify ranges. To include minus in the class,

5180

* it must be at the beginning of the list

5181

5182

if (format[index] == QUALIFIER_MINUS)

5183

{

5184

characterclass[(int)QUALIFIER_MINUS]++;

5185

index++;

5186

}

5187

/* Collect characters */

5188

for (ch = format[index];

5189

(ch != SPECIFIER_UNGROUP) && (ch != NIL);

5190

ch = format[++index])

5191

{

5192

switch (ch)

5193

{

5194

case QUALIFIER_MINUS: /* Scanlist ranges */

5195

5196

5197

* Both C99 and UNIX98 describes ranges as implementation-

5198

* defined.

5199

5200

* We support the following behaviour (although this may

5201

* change as we become wiser)

5202

* - only increasing ranges, ie. [a-b] but not [b-a]

5203

* - transitive ranges, ie. [a-b-c] == [a-c]

5204

* - trailing minus, ie. [a-] is interpreted as an 'a'

5205

* and a '-'

5206

* - duplicates (although we can easily convert these

5207

* into errors)

5208

5209

range_begin = format[index - 1];

5210

range_end = format[++index];

5211

if (range_end == SPECIFIER_UNGROUP)

5212

{

5213

/* Trailing minus is included */

5214

characterclass[(int)ch]++;

5215

ch = range_end;

5216

break; /* for */

5217

}

5218

if (range_end == NIL)

5219

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

5220

if (range_begin > range_end)

5221

return TRIO_ERROR_RETURN(TRIO_ERANGE, index);

5222

5223

for (i = (int)range_begin; i <= (int)range_end; i++)

5224

characterclass[i]++;

5225

5226

ch = range_end;

5227

break;

5228

5229

#if TRIO_EXTENSION

5230

5231

case SPECIFIER_GROUP:

5232

5233

switch (format[index + 1])

5234

{

5235

case QUALIFIER_DOT: /* Collating symbol */

5236

5237

* FIXME: This will be easier to implement when multibyte

5238

* characters have been implemented. Until now, we ignore

5239

* this feature.

5240

5241

for (i = index + 2; ; i++)

5242

{

5243

if (format[i] == NIL)

5244

/* Error in syntax */

5245

return -1;

5246

else if (format[i] == QUALIFIER_DOT)

5247

break; /* for */

5248

}

5249

if (format[++i] != SPECIFIER_UNGROUP)

5250

return -1;

5251

5252

index = i;

5253

break;

5254

5255

case QUALIFIER_EQUAL: /* Equivalence class expressions */

5256

{

5257

unsigned int j;

5258

unsigned int k;

5259

5260

if (internalCollationUnconverted)

5261

{

5262

/* Lazy evaluation of collation array */

5263

TrioGetCollation();

5264

internalCollationUnconverted = FALSE;

5265

}

5266

for (i = index + 2; ; i++)

5267

{

5268

if (format[i] == NIL)

5269

/* Error in syntax */

5270

return -1;

5271

else if (format[i] == QUALIFIER_EQUAL)

5272

break; /* for */

5273

else

5274

{

5275

/* Mark any equivalent character */

5276

k = (unsigned int)format[i];

5277

for (j = 0; internalCollationArray[k][j] != NIL; j++)

5278

characterclass[(int)internalCollationArray[k][j]]++;

5279

}

5280

}

5281

if (format[++i] != SPECIFIER_UNGROUP)

5282

return -1;

5283

5284

index = i;

5285

}

5286

break;

5287

5288

case QUALIFIER_COLON: /* Character class expressions */

5289

5290

if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,

5291

&format[index]))

5292

{

5293

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5294

if (isalnum(i))

5295

characterclass[i]++;

5296

index += sizeof(CLASS_ALNUM) - 1;

5297

}

5298

else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,

5299

&format[index]))

5300

{

5301

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5302

if (isalpha(i))

5303

characterclass[i]++;

5304

index += sizeof(CLASS_ALPHA) - 1;

5305

}

5306

else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,

5307

&format[index]))

5308

{

5309

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5310

if (iscntrl(i))

5311

characterclass[i]++;

5312

index += sizeof(CLASS_CNTRL) - 1;

5313

}

5314

else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,

5315

&format[index]))

5316

{

5317

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5318

if (isdigit(i))

5319

characterclass[i]++;

5320

index += sizeof(CLASS_DIGIT) - 1;

5321

}

5322

else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,

5323

&format[index]))

5324

{

5325

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5326

if (isgraph(i))

5327

characterclass[i]++;

5328

index += sizeof(CLASS_GRAPH) - 1;

5329

}

5330

else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,

5331

&format[index]))

5332

{

5333

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5334

if (islower(i))

5335

characterclass[i]++;

5336

index += sizeof(CLASS_LOWER) - 1;

5337

}

5338

else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,

5339

&format[index]))

5340

{

5341

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5342

if (isprint(i))

5343

characterclass[i]++;

5344

index += sizeof(CLASS_PRINT) - 1;

5345

}

5346

else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,

5347

&format[index]))

5348

{

5349

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5350

if (ispunct(i))

5351

characterclass[i]++;

5352

index += sizeof(CLASS_PUNCT) - 1;

5353

}

5354

else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,

5355

&format[index]))

5356

{

5357

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5358

if (isspace(i))

5359

characterclass[i]++;

5360

index += sizeof(CLASS_SPACE) - 1;

5361

}

5362

else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,

5363

&format[index]))

5364

{

5365

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5366

if (isupper(i))

5367

characterclass[i]++;

5368

index += sizeof(CLASS_UPPER) - 1;

5369

}

5370

else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,

5371

&format[index]))

5372

{

5373

for (i = 0; i < MAX_CHARACTER_CLASS; i++)

5374

if (isxdigit(i))

5375

characterclass[i]++;

5376

index += sizeof(CLASS_XDIGIT) - 1;

5377

}

5378

else

5379

{

5380

characterclass[(int)ch]++;

5381

}

5382

break;

5383

5384

default:

5385

characterclass[(int)ch]++;

5386

break;

5387

}

5388

break;

5389

5390

#endif /* TRIO_EXTENSION */

5391

5392

default:

5393

characterclass[(int)ch]++;

5394

break;

5395

}

5396

}

5397

return 0;

5398

}

5399

5400

/*************************************************************************

5401

* TrioReadNumber

5402

5403

* We implement our own number conversion in preference of strtol and

5404

* strtoul, because we must handle 'long long' and thousand separators.

5405

5406

TRIO_PRIVATE BOOLEAN_T

5407

TrioReadNumber

5408

TRIO_ARGS5((self, target, flags, width, base),

5409

trio_class_t *self,

5410

trio_uintmax_t *target,

5411

trio_flags_t flags,

5412

int width,

5413

int base)

5414

{

5415

trio_uintmax_t number = 0;

5416

int digit;

5417

int count;

5418

BOOLEAN_T isNegative = FALSE;

5419

BOOLEAN_T gotNumber = FALSE;

5420

int j;

5421

5422

assert(VALID(self));

5423

assert(VALID(self->InStream));

5424

assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE));

5425

5426

if (internalDigitsUnconverted)

5427

{

5428

/* Lazy evaluation of digits array */

5429

memset(internalDigitArray, -1, sizeof(internalDigitArray));

5430

for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)

5431

{

5432

internalDigitArray[(int)internalDigitsLower[j]] = j;

5433

internalDigitArray[(int)internalDigitsUpper[j]] = j;

5434

}

5435

internalDigitsUnconverted = FALSE;

5436

}

5437

5438

TrioSkipWhitespaces(self);

5439

5440

if (!(flags & FLAGS_UNSIGNED))

5441

{

5442

/* Leading sign */

5443

if (self->current == '+')

5444

{

5445

self->InStream(self, NULL);

5446

}

5447

else if (self->current == '-')

5448

{

5449

self->InStream(self, NULL);

5450

isNegative = TRUE;

5451

}

5452

}

5453

5454

count = self->processed;

5455

5456

if (flags & FLAGS_ALTERNATIVE)

5457

{

5458

switch (base)

5459

{

5460

case NO_BASE:

5461

case BASE_OCTAL:

5462

case BASE_HEX:

5463

case BASE_BINARY:

5464

if (self->current == '0')

5465

{

5466

self->InStream(self, NULL);

5467

if (self->current)

5468

{

5469

if ((base == BASE_HEX) &&

5470

(trio_to_upper(self->current) == 'X'))

5471

{

5472

self->InStream(self, NULL);

5473

}

5474

else if ((base == BASE_BINARY) &&

5475

(trio_to_upper(self->current) == 'B'))

5476

{

5477

self->InStream(self, NULL);

5478

}

5479

}

5480

}

5481

else

5482

return FALSE;

5483

break;

5484

default:

5485

break;

5486

}

5487

}

5488

5489

while (((width == NO_WIDTH) || (self->processed - count < width)) &&

5490

(! ((self->current == EOF) || isspace(self->current))))

5491

{

5492

if (isascii(self->current))

5493

{

5494

digit = internalDigitArray[self->current];

5495

/* Abort if digit is not allowed in the specified base */

5496

if ((digit == -1) || (digit >= base))

5497

break;

5498

}

5499

else if (flags & FLAGS_QUOTE)

5500

{

5501

/* Compare with thousands separator */

5502

for (j = 0; internalThousandSeparator[j] && self->current; j++)

5503

{

5504

if (internalThousandSeparator[j] != self->current)

5505

break;

5506

5507

self->InStream(self, NULL);

5508

}

5509

if (internalThousandSeparator[j])

5510

break; /* Mismatch */

5511

else

5512

continue; /* Match */

5513

}

5514

else

5515

break;

5516

5517

number *= base;

5518

number += digit;

5519

gotNumber = TRUE; /* we need at least one digit */

5520

5521

self->InStream(self, NULL);

5522

}

5523

5524

/* Was anything read at all? */

5525

if (!gotNumber)

5526

return FALSE;

5527

5528

if (target)

5529

*target = (isNegative) ? -((trio_intmax_t)number) : number;

5530

return TRUE;

5531

}

5532

5533

/*************************************************************************

5534

* TrioReadChar

5535

5536

TRIO_PRIVATE int

5537

TrioReadChar

5538

TRIO_ARGS4((self, target, flags, width),

5539

trio_class_t *self,

5540

char *target,

5541

trio_flags_t flags,

5542

int width)

5543

{

5544

int i;

5545

char ch;

5546

trio_uintmax_t number;

5547

5548

assert(VALID(self));

5549

assert(VALID(self->InStream));

5550

5551

for (i = 0;

5552

(self->current != EOF) && (i < width);

5553

i++)

5554

{

5555

ch = (char)self->current;

5556

self->InStream(self, NULL);

5557

if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH))

5558

{

5559

switch (self->current)

5560

{

5561

case '\\': ch = '\\'; break;

5562

case 'a': ch = '\007'; break;

5563

case 'b': ch = '\b'; break;

5564

case 'f': ch = '\f'; break;

5565

case 'n': ch = '\n'; break;

5566

case 'r': ch = '\r'; break;

5567

case 't': ch = '\t'; break;

5568

case 'v': ch = '\v'; break;

5569

default:

5570

if (isdigit(self->current))

5571

{

5572

/* Read octal number */

5573

if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL))

5574

return 0;

5575

ch = (char)number;

5576

}

5577

else if (trio_to_upper(self->current) == 'X')

5578

{

5579

/* Read hexadecimal number */

5580

self->InStream(self, NULL);

5581

if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX))

5582

return 0;

5583

ch = (char)number;

5584

}

5585

else

5586

{

5587

ch = (char)self->current;

5588

}

5589

break;

5590

}

5591

}

5592

5593

if (target)

5594

target[i] = ch;

5595

}

5596

return i + 1;

5597

}

5598

5599

/*************************************************************************

5600

* TrioReadString

5601

5602

TRIO_PRIVATE BOOLEAN_T

5603

TrioReadString

5604

TRIO_ARGS4((self, target, flags, width),

5605

trio_class_t *self,

5606

char *target,

5607

trio_flags_t flags,

5608

int width)

5609

{

5610

int i;

5611

5612

assert(VALID(self));

5613

assert(VALID(self->InStream));

5614

5615

TrioSkipWhitespaces(self);

5616

5617

5618

* Continue until end of string is reached, a whitespace is encountered,

5619

* or width is exceeded

5620

5621

for (i = 0;

5622

((width == NO_WIDTH) || (i < width)) &&

5623

(! ((self->current == EOF) || isspace(self->current)));

5624

i++)

5625

{

5626

if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)

5627

break; /* for */

5628

}

5629

if (target)

5630

target[i] = NIL;

5631

return TRUE;

5632

}

5633

5634

/*************************************************************************

5635

* TrioReadWideChar

5636

5637

#if TRIO_WIDECHAR

5638

TRIO_PRIVATE int

5639

TrioReadWideChar

5640

TRIO_ARGS4((self, target, flags, width),

5641

trio_class_t *self,

5642

trio_wchar_t *target,

5643

trio_flags_t flags,

5644

int width)

5645

{

5646

int i;

5647

int j;

5648

int size;

5649

int amount = 0;

5650

trio_wchar_t wch;

5651

char buffer[MB_LEN_MAX + 1];

5652

5653

assert(VALID(self));

5654

assert(VALID(self->InStream));

5655

5656

for (i = 0;

5657

(self->current != EOF) && (i < width);

5658

i++)

5659

{

5660

if (isascii(self->current))

5661

{

5662

if (TrioReadChar(self, buffer, flags, 1) == 0)

5663

return 0;

5664

buffer[1] = NIL;

5665

}

5666

else

5667

{

5668

5669

* Collect a multibyte character, by enlarging buffer until

5670

* it contains a fully legal multibyte character, or the

5671

* buffer is full.

5672

5673

j = 0;

5674

5675

{

5676

buffer[j++] = (char)self->current;

5677

buffer[j] = NIL;

5678

self->InStream(self, NULL);

5679

}

5680

while ((j < (int)sizeof(buffer)) && (mblen(buffer, (size_t)j) != j));

5681

}

5682

if (target)

5683

{

5684

size = mbtowc(&wch, buffer, sizeof(buffer));

5685

if (size > 0)

5686

target[i] = wch;

5687

}

5688

amount += size;

5689

self->InStream(self, NULL);

5690

}

5691

return amount;

5692

}

5693

#endif /* TRIO_WIDECHAR */

5694

5695

/*************************************************************************

5696

* TrioReadWideString

5697

5698

#if TRIO_WIDECHAR

5699

TRIO_PRIVATE BOOLEAN_T

5700

TrioReadWideString

5701

TRIO_ARGS4((self, target, flags, width),

5702

trio_class_t *self,

5703

trio_wchar_t *target,

5704

trio_flags_t flags,

5705

int width)

5706

{

5707

int i;

5708

int size;

5709

5710

assert(VALID(self));

5711

assert(VALID(self->InStream));

5712

5713

TrioSkipWhitespaces(self);

5714

5715

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

5716

(void)mblen(NULL, 0);

5717

#endif

5718

5719

5720

* Continue until end of string is reached, a whitespace is encountered,

5721

* or width is exceeded

5722

5723

for (i = 0;

5724

((width == NO_WIDTH) || (i < width)) &&

5725

(! ((self->current == EOF) || isspace(self->current)));

5726

)

5727

{

5728

size = TrioReadWideChar(self, &target[i], flags, 1);

5729

if (size == 0)

5730

break; /* for */

5731

5732

i += size;

5733

}

5734

if (target)

5735

target[i] = WCONST('\0');

5736

return TRUE;

5737

}

5738

#endif /* TRIO_WIDECHAR */

5739

5740

/*************************************************************************

5741

* TrioReadGroup

5742

5743

* FIXME: characterclass does not work with multibyte characters

5744

5745

TRIO_PRIVATE BOOLEAN_T

5746

TrioReadGroup

5747

TRIO_ARGS5((self, target, characterclass, flags, width),

5748

trio_class_t *self,

5749

char *target,

5750

int *characterclass,

5751

trio_flags_t flags,

5752

int width)

5753

{

5754

int ch;

5755

int i;

5756

5757

assert(VALID(self));

5758

assert(VALID(self->InStream));

5759

5760

ch = self->current;

5761

for (i = 0;

5762

((width == NO_WIDTH) || (i < width)) &&

5763

(! ((ch == EOF) ||

5764

(((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0))));

5765

i++)

5766

{

5767

if (target)

5768

target[i] = (char)ch;

5769

self->InStream(self, &ch);

5770

}

5771

5772

if (target)

5773

target[i] = NIL;

5774

return TRUE;

5775

}

5776

5777

/*************************************************************************

5778

* TrioReadDouble

5779

5780

* FIXME:

5781

* add long double

5782

* handle base

5783

5784

TRIO_PRIVATE BOOLEAN_T

5785

TrioReadDouble

5786

TRIO_ARGS4((self, target, flags, width),

5787

trio_class_t *self,

5788

trio_pointer_t target,

5789

trio_flags_t flags,

5790

int width)

5791

{

5792

int ch;

5793

char doubleString[512];

5794

int index = 0;

5795

int start;

5796

int j;

5797

BOOLEAN_T isHex = FALSE;

5798

5799

doubleString[0] = 0;

5800

5801

if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1))

5802

width = sizeof(doubleString) - 1;

5803

5804

TrioSkipWhitespaces(self);

5805

5806

5807

* Read entire double number from stream. trio_to_double requires

5808

* a string as input, but InStream can be anything, so we have to

5809

* collect all characters.

5810

5811

ch = self->current;

5812

if ((ch == '+') || (ch == '-'))

5813

{

5814

doubleString[index++] = (char)ch;

5815

self->InStream(self, &ch);

5816

width--;

5817

}

5818

5819

start = index;

5820

switch (ch)

5821

{

5822

case 'n':

5823

case 'N':

5824

/* Not-a-number */

5825

if (index != 0)

5826

break;

5827

/* FALLTHROUGH */

5828

case 'i':

5829

case 'I':

5830

/* Infinity */

5831

while (isalpha(ch) && (index - start < width))

5832

{

5833

doubleString[index++] = (char)ch;

5834

self->InStream(self, &ch);

5835

}

5836

doubleString[index] = NIL;

5837

5838

/* Case insensitive string comparison */

5839

if (trio_equal(&doubleString[start], INFINITE_UPPER) ||

5840

trio_equal(&doubleString[start], LONG_INFINITE_UPPER))

5841

{

5842

if (flags & FLAGS_LONGDOUBLE)

5843

{

5844

if ((start == 1) && (doubleString[0] == '-'))

5845

{

5846

*((trio_long_double_t *)target) = trio_ninf();

5847

}

5848

else

5849

{

5850

*((trio_long_double_t *)target) = trio_pinf();

5851

}

5852

}

5853

else

5854

{

5855

if ((start == 1) && (doubleString[0] == '-'))

5856

{

5857

*((double *)target) = trio_ninf();

5858

}

5859

else

5860

{

5861

*((double *)target) = trio_pinf();

5862

}

5863

}

5864

return TRUE;

5865

}

5866

if (trio_equal(doubleString, NAN_UPPER))

5867

{

5868

/* NaN must not have a preceeding + nor - */

5869

if (flags & FLAGS_LONGDOUBLE)

5870

{

5871

*((trio_long_double_t *)target) = trio_nan();

5872

}

5873

else

5874

{

5875

*((double *)target) = trio_nan();

5876

}

5877

return TRUE;

5878

}

5879

return FALSE;

5880

5881

case '0':

5882

doubleString[index++] = (char)ch;

5883

self->InStream(self, &ch);

5884

if (trio_to_upper(ch) == 'X')

5885

{

5886

isHex = TRUE;

5887

doubleString[index++] = (char)ch;

5888

self->InStream(self, &ch);

5889

}

5890

break;

5891

5892

default:

5893

break;

5894

}

5895

5896

while ((ch != EOF) && (index - start < width))

5897

{

5898

/* Integer part */

5899

if (isHex ? isxdigit(ch) : isdigit(ch))

5900

{

5901

doubleString[index++] = (char)ch;

5902

self->InStream(self, &ch);

5903

}

5904

else if (flags & FLAGS_QUOTE)

5905

{

5906

/* Compare with thousands separator */

5907

for (j = 0; internalThousandSeparator[j] && self->current; j++)

5908

{

5909

if (internalThousandSeparator[j] != self->current)

5910

break;

5911

5912

self->InStream(self, &ch);

5913

}

5914

if (internalThousandSeparator[j])

5915

break; /* Mismatch */

5916

else

5917

continue; /* Match */

5918

}

5919

else

5920

break; /* while */

5921

}

5922

if (ch == '.')

5923

{

5924

/* Decimal part */

5925

doubleString[index++] = (char)ch;

5926

self->InStream(self, &ch);

5927

while ((isHex ? isxdigit(ch) : isdigit(ch)) &&

5928

(index - start < width))

5929

{

5930

doubleString[index++] = (char)ch;

5931

self->InStream(self, &ch);

5932

}

5933

if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E'))

5934

{

5935

/* Exponent */

5936

doubleString[index++] = (char)ch;

5937

self->InStream(self, &ch);

5938

if ((ch == '+') || (ch == '-'))

5939

{

5940

doubleString[index++] = (char)ch;

5941

self->InStream(self, &ch);

5942

}

5943

while (isdigit(ch) && (index - start < width))

5944

{

5945

doubleString[index++] = (char)ch;

5946

self->InStream(self, &ch);

5947

}

5948

}

5949

}

5950

5951

if ((index == start) || (*doubleString == NIL))

5952

return FALSE;

5953

5954

doubleString[index] = 0;

5955

5956

if (flags & FLAGS_LONGDOUBLE)

5957

{

5958

*((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL);

5959

}

5960

else

5961

{

5962

*((double *)target) = trio_to_double(doubleString, NULL);

5963

}

5964

return TRUE;

5965

}

5966

5967

/*************************************************************************

5968

* TrioReadPointer

5969

5970

TRIO_PRIVATE BOOLEAN_T

5971

TrioReadPointer

5972

TRIO_ARGS3((self, target, flags),

5973

trio_class_t *self,

5974

trio_pointer_t *target,

5975

trio_flags_t flags)

5976

{

5977

trio_uintmax_t number;

5978

char buffer[sizeof(internalNullString)];

5979

5980

flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);

5981

5982

if (TrioReadNumber(self,

5983

&number,

5984

flags,

5985

POINTER_WIDTH,

5986

BASE_HEX))

5987

{

5988

5989

* The strange assignment of number is a workaround for a compiler

5990

* warning

5991

5992

if (target)

5993

*target = (char *)0 + number;

5994

return TRUE;

5995

}

5996

else if (TrioReadString(self,

5997

(flags & FLAGS_IGNORE)

5998

? NULL

5999

: buffer,

6000

6001

sizeof(internalNullString) - 1))

6002

{

6003

if (trio_equal_case(buffer, internalNullString))

6004

{

6005

if (target)

6006

*target = NULL;

6007

return TRUE;

6008

}

6009

}

6010

return FALSE;

6011

}

6012

6013

/*************************************************************************

6014

* TrioScanProcess

6015

6016

TRIO_PRIVATE int

6017

TrioScanProcess

6018

TRIO_ARGS3((data, format, parameters),

6019

trio_class_t *data,

6020

TRIO_CONST char *format,

6021

trio_parameter_t *parameters)

6022

{

6023

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

6024

int charlen;

6025

int cnt;

6026

#endif

6027

int assignment;

6028

int ch;

6029

int index; /* Index of format string */

6030

int i; /* Index of current parameter */

6031

trio_flags_t flags;

6032

int width;

6033

int base;

6034

trio_pointer_t pointer;

6035

6036

assignment = 0;

6037

i = 0;

6038

index = 0;

6039

data->InStream(data, &ch);

6040

6041

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

6042

(void)mblen(NULL, 0);

6043

#endif

6044

6045

while (format[index])

6046

{

6047

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)

6048

if (! isascii(format[index]))

6049

{

6050

charlen = mblen(&format[index], MB_LEN_MAX);

6051

if (charlen != -1)

6052

{

6053

/* Compare multibyte characters in format string */

6054

for (cnt = 0; cnt < charlen - 1; cnt++)

6055

{

6056

if (ch != format[index + cnt])

6057

{

6058

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

6059

}

6060

data->InStream(data, &ch);

6061

}

6062

continue; /* while characters left in formatting string */

6063

}

6064

}

6065

#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */

6066

6067

if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT))

6068

{

6069

return (assignment > 0) ? assignment : EOF;

6070

}

6071

6072

if (CHAR_IDENTIFIER == format[index])

6073

{

6074

if (CHAR_IDENTIFIER == format[index + 1])

6075

{

6076

/* Two % in format matches one % in input stream */

6077

if (CHAR_IDENTIFIER == ch)

6078

{

6079

data->InStream(data, &ch);

6080

index += 2;

6081

continue; /* while format chars left */

6082

}

6083

else

6084

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

6085

}

6086

6087

/* Skip the parameter entries */

6088

while (parameters[i].type == FORMAT_PARAMETER)

6089

i++;

6090

6091

flags = parameters[i].flags;

6092

/* Find width */

6093

width = parameters[i].width;

6094

if (flags & FLAGS_WIDTH_PARAMETER)

6095

{

6096

/* Get width from parameter list */

6097

width = (int)parameters[width].data.number.as_signed;

6098

}

6099

/* Find base */

6100

base = parameters[i].base;

6101

if (flags & FLAGS_BASE_PARAMETER)

6102

{

6103

/* Get base from parameter list */

6104

base = (int)parameters[base].data.number.as_signed;

6105

}

6106

6107

switch (parameters[i].type)

6108

{

6109

case FORMAT_INT:

6110

{

6111

trio_uintmax_t number;

6112

6113

if (0 == base)

6114

base = BASE_DECIMAL;

6115

6116

if (!TrioReadNumber(data,

6117

&number,

6118

flags,

6119

width,

6120

base))

6121

return assignment;

6122

6123

if (!(flags & FLAGS_IGNORE))

6124

{

6125

assignment++;

6126

6127

pointer = parameters[i].data.pointer;

6128

#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)

6129

if (flags & FLAGS_SIZE_T)

6130

*(size_t *)pointer = (size_t)number;

6131

else

6132

#endif

6133

#if defined(QUALIFIER_PTRDIFF_T)

6134

if (flags & FLAGS_PTRDIFF_T)

6135

*(ptrdiff_t *)pointer = (ptrdiff_t)number;

6136

else

6137

#endif

6138

#if defined(QUALIFIER_INTMAX_T)

6139

if (flags & FLAGS_INTMAX_T)

6140

*(trio_intmax_t *)pointer = (trio_intmax_t)number;

6141

else

6142

#endif

6143

if (flags & FLAGS_QUAD)

6144

*(trio_ulonglong_t *)pointer = (trio_ulonglong_t)number;

6145

else if (flags & FLAGS_LONG)

6146

*(long int *)pointer = (long int)number;

6147

else if (flags & FLAGS_SHORT)

6148

*(short int *)pointer = (short int)number;

6149

else

6150

*(int *)pointer = (int)number;

6151

}

6152

}

6153

break; /* FORMAT_INT */

6154

6155

case FORMAT_STRING:

6156

#if TRIO_WIDECHAR

6157

if (flags & FLAGS_WIDECHAR)

6158

{

6159

if (!TrioReadWideString(data,

6160

(flags & FLAGS_IGNORE)

6161

? NULL

6162

: parameters[i].data.wstring,

6163

flags,

6164

width))

6165

return assignment;

6166

}

6167

else

6168

#endif

6169

{

6170

if (!TrioReadString(data,

6171

(flags & FLAGS_IGNORE)

6172

? NULL

6173

: parameters[i].data.string,

6174

flags,

6175

width))

6176

return assignment;

6177

}

6178

if (!(flags & FLAGS_IGNORE))

6179

assignment++;

6180

break; /* FORMAT_STRING */

6181

6182

case FORMAT_DOUBLE:

6183

{

6184

trio_pointer_t pointer;

6185

6186

if (flags & FLAGS_IGNORE)

6187

{

6188

pointer = NULL;

6189

}

6190

else

6191

{

6192

pointer = (flags & FLAGS_LONGDOUBLE)

6193

? (trio_pointer_t)parameters[i].data.longdoublePointer

6194

: (trio_pointer_t)parameters[i].data.doublePointer;

6195

}

6196

if (!TrioReadDouble(data, pointer, flags, width))

6197

{

6198

return assignment;

6199

}

6200

if (!(flags & FLAGS_IGNORE))

6201

{

6202

assignment++;

6203

}

6204

break; /* FORMAT_DOUBLE */

6205

}

6206

case FORMAT_GROUP:

6207

{

6208

int characterclass[MAX_CHARACTER_CLASS + 1];

6209

int rc;

6210

6211

/* Skip over modifiers */

6212

while (format[index] != SPECIFIER_GROUP)

6213

{

6214

index++;

6215

}

6216

/* Skip over group specifier */

6217

index++;

6218

6219

memset(characterclass, 0, sizeof(characterclass));

6220

rc = TrioGetCharacterClass(format,

6221

&index,

6222

&flags,

6223

characterclass);

6224

if (rc < 0)

6225

return rc;

6226

6227

if (!TrioReadGroup(data,

6228

(flags & FLAGS_IGNORE)

6229

? NULL

6230

: parameters[i].data.string,

6231

characterclass,

6232

flags,

6233

parameters[i].width))

6234

return assignment;

6235

if (!(flags & FLAGS_IGNORE))

6236

assignment++;

6237

}

6238

break; /* FORMAT_GROUP */

6239

6240

case FORMAT_COUNT:

6241

pointer = parameters[i].data.pointer;

6242

if (NULL != pointer)

6243

{

6244

int count = data->committed;

6245

if (ch != EOF)

6246

count--; /* a character is read, but is not consumed yet */

6247

#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)

6248

if (flags & FLAGS_SIZE_T)

6249

*(size_t *)pointer = (size_t)count;

6250

else

6251

#endif

6252

#if defined(QUALIFIER_PTRDIFF_T)

6253

if (flags & FLAGS_PTRDIFF_T)

6254

*(ptrdiff_t *)pointer = (ptrdiff_t)count;

6255

else

6256

#endif

6257

#if defined(QUALIFIER_INTMAX_T)

6258

if (flags & FLAGS_INTMAX_T)

6259

*(trio_intmax_t *)pointer = (trio_intmax_t)count;

6260

else

6261

#endif

6262

if (flags & FLAGS_QUAD)

6263

{

6264

*(trio_ulonglong_t *)pointer = (trio_ulonglong_t)count;

6265

}

6266

else if (flags & FLAGS_LONG)

6267

{

6268

*(long int *)pointer = (long int)count;

6269

}

6270

else if (flags & FLAGS_SHORT)

6271

{

6272

*(short int *)pointer = (short int)count;

6273

}

6274

else

6275

{

6276

*(int *)pointer = (int)count;

6277

}

6278

}

6279

break; /* FORMAT_COUNT */

6280

6281

case FORMAT_CHAR:

6282

#if TRIO_WIDECHAR

6283

if (flags & FLAGS_WIDECHAR)

6284

{

6285

if (TrioReadWideChar(data,

6286

(flags & FLAGS_IGNORE)

6287

? NULL

6288

: parameters[i].data.wstring,

6289

flags,

6290

(width == NO_WIDTH) ? 1 : width) == 0)

6291

return assignment;

6292

}

6293

else

6294

#endif

6295

{

6296

if (TrioReadChar(data,

6297

(flags & FLAGS_IGNORE)

6298

? NULL

6299

: parameters[i].data.string,

6300

flags,

6301

(width == NO_WIDTH) ? 1 : width) == 0)

6302

return assignment;

6303

}

6304

if (!(flags & FLAGS_IGNORE))

6305

assignment++;

6306

break; /* FORMAT_CHAR */

6307

6308

case FORMAT_POINTER:

6309

if (!TrioReadPointer(data,

6310

(flags & FLAGS_IGNORE)

6311

? NULL

6312

: (trio_pointer_t *)parameters[i].data.pointer,

6313

flags))

6314

return assignment;

6315

if (!(flags & FLAGS_IGNORE))

6316

assignment++;

6317

break; /* FORMAT_POINTER */

6318

6319

case FORMAT_PARAMETER:

6320

break; /* FORMAT_PARAMETER */

6321

6322

default:

6323

return TRIO_ERROR_RETURN(TRIO_EINVAL, index);

6324

}

6325

ch = data->current;

6326

index = parameters[i].indexAfterSpecifier;

6327

i++;

6328

}

6329

else /* Not an % identifier */

6330

{

6331

if (isspace((int)format[index]))

6332

{

6333

/* Whitespaces may match any amount of whitespaces */

6334

ch = TrioSkipWhitespaces(data);

6335

}

6336

else if (ch == format[index])

6337

{

6338

data->InStream(data, &ch);

6339

}

6340

else

6341

return assignment;

6342

6343

index++;

6344

}

6345

}

6346

return assignment;

6347

}

6348

6349

/*************************************************************************

6350

* TrioScan

6351

6352

TRIO_PRIVATE int

6353

TrioScan

6354

TRIO_ARGS6((source, sourceSize, InStream, format, arglist, argarray),

6355

trio_pointer_t source,

6356

size_t sourceSize,

6357

void (*InStream) TRIO_PROTO((trio_class_t *, int *)),

6358

TRIO_CONST char *format,

6359

va_list *arglist,

6360

trio_pointer_t *argarray)

6361

{

6362

int status;

6363

trio_parameter_t parameters[MAX_PARAMETERS];

6364

trio_class_t data;

6365

6366

assert(VALID(InStream));

6367

assert(VALID(format));

6368

6369

memset(&data, 0, sizeof(data));

6370

data.InStream = InStream;

6371

data.location = (trio_pointer_t)source;

6372

data.max = sourceSize;

6373

data.error = 0;

6374

6375

#if defined(USE_LOCALE)

6376

if (NULL == internalLocaleValues)

6377

{

6378

TrioSetLocale();

6379

}

6380

#endif

6381

6382

status = TrioParse(TYPE_SCAN, format, parameters, arglist, argarray);

6383

if (status < 0)

6384

return status;

6385

6386

status = TrioScanProcess(&data, format, parameters);

6387

if (data.error != 0)

6388

{

6389

status = data.error;

6390

}

6391

return status;

6392

}

6393

6394

/*************************************************************************

6395

* TrioInStreamFile

6396

6397

TRIO_PRIVATE void

6398

TrioInStreamFile

6399

TRIO_ARGS2((self, intPointer),

6400

trio_class_t *self,

6401

int *intPointer)

6402

{

6403

FILE *file = (FILE *)self->location;

6404

6405

assert(VALID(self));

6406

assert(VALID(file));

6407

6408

self->current = fgetc(file);

6409

if (self->current == EOF)

6410

{

6411

self->error = (ferror(file))

6412

? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)

6413

: TRIO_ERROR_RETURN(TRIO_EOF, 0);

6414

}

6415

else

6416

{

6417

self->processed++;

6418

self->committed++;

6419

}

6420

6421

if (VALID(intPointer))

6422

{

6423

*intPointer = self->current;

6424

}

6425

}

6426

6427

/*************************************************************************

6428

* TrioInStreamFileDescriptor

6429

6430

TRIO_PRIVATE void

6431

TrioInStreamFileDescriptor

6432

TRIO_ARGS2((self, intPointer),

6433

trio_class_t *self,

6434

int *intPointer)

6435

{

6436

int fd = *((int *)self->location);

6437

int size;

6438

unsigned char input;

6439

6440

assert(VALID(self));

6441

6442

size = read(fd, &input, sizeof(char));

6443

if (size == -1)

6444

{

6445

self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);

6446

self->current = EOF;

6447

}

6448

else

6449

{

6450

self->current = (size == 0) ? EOF : input;

6451

}

6452

if (self->current != EOF)

6453

{

6454

self->committed++;

6455

self->processed++;

6456

}

6457

6458

if (VALID(intPointer))

6459

{

6460

*intPointer = self->current;

6461

}

6462

}

6463

6464

/*************************************************************************

6465

* TrioInStreamCustom

6466

6467

TRIO_PRIVATE void

6468

TrioInStreamCustom

6469

TRIO_ARGS2((self, intPointer),

6470

trio_class_t *self,

6471

int *intPointer)

6472

{

6473

trio_custom_t *data;

6474

6475

assert(VALID(self));

6476

assert(VALID(self->location));

6477

6478

data = (trio_custom_t *)self->location;

6479

6480

self->current = (data->stream.in == NULL)

6481

? NIL

6482

: (data->stream.in)(data->closure);

6483

6484

if (self->current == NIL)

6485

{

6486

self->current = EOF;

6487

}

6488

else

6489

{

6490

self->processed++;

6491

self->committed++;

6492

}

6493

6494

if (VALID(intPointer))

6495

{

6496

*intPointer = self->current;

6497

}

6498

}

6499

6500

/*************************************************************************

6501

* TrioInStreamString

6502

6503

TRIO_PRIVATE void

6504

TrioInStreamString

6505

TRIO_ARGS2((self, intPointer),

6506

trio_class_t *self,

6507

int *intPointer)

6508

{

6509

unsigned char **buffer;

6510

6511

assert(VALID(self));

6512

assert(VALID(self->location));

6513

6514

buffer = (unsigned char **)self->location;

6515

self->current = (*buffer)[0];

6516

if (self->current == NIL)

6517

{

6518

self->current = EOF;

6519

}

6520

else

6521

{

6522

(*buffer)++;

6523

self->processed++;

6524

self->committed++;

6525

}

6526

6527

if (VALID(intPointer))

6528

{

6529

*intPointer = self->current;

6530

}

6531

}

6532

6533

/*************************************************************************

6534

6535

* Formatted scanning functions

6536

6537

************************************************************************/

6538

6539

#if defined(TRIO_DOCUMENTATION)

6540

# include "doc/doc_scanf.h"

6541

#endif

6542

/** @addtogroup Scanf

6543

6544

6545

6546

/*************************************************************************

6547

* scanf

6548

6549

6550

/**

6551

Scan characters from standard input stream.

6552

6553

@param format Formatting string.

6554

@param ... Arguments.

6555

@return Number of scanned characters.

6556

6557

TRIO_PUBLIC int

6558

trio_scanf

6559

TRIO_VARGS2((format, va_alist),

6560

TRIO_CONST char *format,

6561

TRIO_VA_DECL)

6562

{

6563

int status;

6564

va_list args;

6565

6566

assert(VALID(format));

6567

6568

TRIO_VA_START(args, format);

6569

status = TrioScan((trio_pointer_t)stdin, 0,

6570

TrioInStreamFile,

6571

format, &args, NULL);

6572

TRIO_VA_END(args);

6573

return status;

6574

}

6575

6576

TRIO_PUBLIC int

6577

trio_vscanf

6578

TRIO_ARGS2((format, args),

6579

TRIO_CONST char *format,

6580

va_list args)

6581

{

6582

assert(VALID(format));

6583

6584

return TrioScan((trio_pointer_t)stdin, 0,

6585

TrioInStreamFile,

6586

format, &args, NULL);

6587

}

6588

6589

TRIO_PUBLIC int

6590

trio_scanfv

6591

TRIO_ARGS2((format, args),

6592

TRIO_CONST char *format,

6593

trio_pointer_t *args)

6594

{

6595

assert(VALID(format));

6596

6597

return TrioScan((trio_pointer_t)stdin, 0,

6598

TrioInStreamFile,

6599

format, NULL, args);

6600

}

6601

6602

/*************************************************************************

6603

* fscanf

6604

6605

TRIO_PUBLIC int

6606

trio_fscanf

6607

TRIO_VARGS3((file, format, va_alist),

6608

FILE *file,

6609

TRIO_CONST char *format,

6610

TRIO_VA_DECL)

6611

{

6612

int status;

6613

va_list args;

6614

6615

assert(VALID(file));

6616

assert(VALID(format));

6617

6618

TRIO_VA_START(args, format);

6619

status = TrioScan((trio_pointer_t)file, 0,

6620

TrioInStreamFile,

6621

format, &args, NULL);

6622

TRIO_VA_END(args);

6623

return status;

6624

}

6625

6626

TRIO_PUBLIC int

6627

trio_vfscanf

6628

TRIO_ARGS3((file, format, args),

6629

FILE *file,

6630

TRIO_CONST char *format,

6631

va_list args)

6632

{

6633

assert(VALID(file));

6634

assert(VALID(format));

6635

6636

return TrioScan((trio_pointer_t)file, 0,

6637

TrioInStreamFile,

6638

format, &args, NULL);

6639

}

6640

6641

TRIO_PUBLIC int

6642

trio_fscanfv

6643

TRIO_ARGS3((file, format, args),

6644

FILE *file,

6645

TRIO_CONST char *format,

6646

trio_pointer_t *args)

6647

{

6648

assert(VALID(file));

6649

assert(VALID(format));

6650

6651

return TrioScan((trio_pointer_t)file, 0,

6652

TrioInStreamFile,

6653

format, NULL, args);

6654

}

6655

6656

/*************************************************************************

6657

* dscanf

6658

6659

TRIO_PUBLIC int

6660

trio_dscanf

6661

TRIO_VARGS3((fd, format, va_alist),

6662

int fd,

6663

TRIO_CONST char *format,

6664

TRIO_VA_DECL)

6665

{

6666

int status;

6667

va_list args;

6668

6669

assert(VALID(format));

6670

6671

TRIO_VA_START(args, format);

6672

status = TrioScan((trio_pointer_t)&fd, 0,

6673

TrioInStreamFileDescriptor,

6674

format, &args, NULL);

6675

TRIO_VA_END(args);

6676

return status;

6677

}

6678

6679

TRIO_PUBLIC int

6680

trio_vdscanf

6681

TRIO_ARGS3((fd, format, args),

6682

int fd,

6683

TRIO_CONST char *format,

6684

va_list args)

6685

{

6686

assert(VALID(format));

6687

6688

return TrioScan((trio_pointer_t)&fd, 0,

6689

TrioInStreamFileDescriptor,

6690

format, &args, NULL);

6691

}

6692

6693

TRIO_PUBLIC int

6694

trio_dscanfv

6695

TRIO_ARGS3((fd, format, args),

6696

int fd,

6697

TRIO_CONST char *format,

6698

trio_pointer_t *args)

6699

{

6700

assert(VALID(format));

6701

6702

return TrioScan((trio_pointer_t)&fd, 0,

6703

TrioInStreamFileDescriptor,

6704

format, NULL, args);

6705

}

6706

6707

/*************************************************************************

6708

* cscanf

6709

6710

TRIO_PUBLIC int

6711

trio_cscanf

6712

TRIO_VARGS4((stream, closure, format, va_alist),

6713

trio_instream_t stream,

6714

trio_pointer_t closure,

6715

TRIO_CONST char *format,

6716

TRIO_VA_DECL)

6717

{

6718

int status;

6719

va_list args;

6720

trio_custom_t data;

6721

6722

assert(VALID(stream));

6723

assert(VALID(format));

6724

6725

TRIO_VA_START(args, format);

6726

data.stream.in = stream;

6727

data.closure = closure;

6728

status = TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);

6729

TRIO_VA_END(args);

6730

return status;

6731

}

6732

6733

TRIO_PUBLIC int

6734

trio_vcscanf

6735

TRIO_ARGS4((stream, closure, format, args),

6736

trio_instream_t stream,

6737

trio_pointer_t closure,

6738

TRIO_CONST char *format,

6739

va_list args)

6740

{

6741

trio_custom_t data;

6742

6743

assert(VALID(stream));

6744

assert(VALID(format));

6745

6746

data.stream.in = stream;

6747

data.closure = closure;

6748

return TrioScan(&data, 0, TrioInStreamCustom, format, &args, NULL);

6749

}

6750

6751

TRIO_PUBLIC int

6752

trio_cscanfv

6753

TRIO_ARGS4((stream, closure, format, args),

6754

trio_instream_t stream,

6755

trio_pointer_t closure,

6756

TRIO_CONST char *format,

6757

trio_pointer_t *args)

6758

{

6759

trio_custom_t data;

6760

6761

assert(VALID(stream));

6762

assert(VALID(format));

6763

6764

data.stream.in = stream;

6765

data.closure = closure;

6766

return TrioScan(&data, 0, TrioInStreamCustom, format, NULL, args);

6767

}

6768

6769

/*************************************************************************

6770

* sscanf

6771

6772

TRIO_PUBLIC int

6773

trio_sscanf

6774

TRIO_VARGS3((buffer, format, va_alist),

6775

TRIO_CONST char *buffer,

6776

TRIO_CONST char *format,

6777

TRIO_VA_DECL)

6778

{

6779

int status;

6780

va_list args;

6781

6782

assert(VALID(buffer));

6783

assert(VALID(format));

6784

6785

TRIO_VA_START(args, format);

6786

status = TrioScan((trio_pointer_t)&buffer, 0,

6787

TrioInStreamString,

6788

format, &args, NULL);

6789

TRIO_VA_END(args);

6790

return status;

6791

}

6792

6793

TRIO_PUBLIC int

6794

trio_vsscanf

6795

TRIO_ARGS3((buffer, format, args),

6796

TRIO_CONST char *buffer,

6797

TRIO_CONST char *format,

6798

va_list args)

6799

{

6800

assert(VALID(buffer));

6801

assert(VALID(format));

6802

6803

return TrioScan((trio_pointer_t)&buffer, 0,

6804

TrioInStreamString,

6805

format, &args, NULL);

6806

}

6807

6808

TRIO_PUBLIC int

6809

trio_sscanfv

6810

TRIO_ARGS3((buffer, format, args),

6811

TRIO_CONST char *buffer,

6812

TRIO_CONST char *format,

6813

trio_pointer_t *args)

6814

{

6815

assert(VALID(buffer));

6816

assert(VALID(format));

6817

6818

return TrioScan((trio_pointer_t)&buffer, 0,

6819

TrioInStreamString,

6820

format, NULL, args);

6821

}

6822

6823

/** @} End of Scanf documentation module */

6824

6825

/*************************************************************************

6826

* trio_strerror

6827

6828

TRIO_PUBLIC TRIO_CONST char *

6829

trio_strerror

6830

TRIO_ARGS1((errorcode),

6831

int errorcode)

6832

{

6833

/* Textual versions of the error codes */

6834

switch (TRIO_ERROR_CODE(errorcode))

6835

{

6836

case TRIO_EOF:

6837

return "End of file";

6838

case TRIO_EINVAL:

6839

return "Invalid argument";

6840

case TRIO_ETOOMANY:

6841

return "Too many arguments";

6842

case TRIO_EDBLREF:

6843

return "Double reference";

6844

case TRIO_EGAP:

6845

return "Reference gap";

6846

case TRIO_ENOMEM:

6847

return "Out of memory";

6848

case TRIO_ERANGE:

6849

return "Invalid range";

6850

case TRIO_ECUSTOM:

6851

return "Custom error";

6852

default:

6853

return "Unknown";

6854

}

6855

}

Older »