mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/js/ref/prprintf.c

830 строки
17 KiB
C
Исходник Ответственный История

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/*
* Portable safe sprintf code.
*/
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "prtypes.h"
#include "prassert.h"
#include "prprintf.h"
#include "prlong.h"
typedef struct SprintfStateStr SprintfState;
struct SprintfStateStr {
int (*stuff)(SprintfState *ss, const char *sp, size_t len);
char *base;
char *cur;
size_t maxlen;
int (*func)(void *arg, const char *sp, size_t len);
void *arg;
};
#define PRTYPE_SHORT 0
#define PRTYPE_USHORT 1
#define PRTYPE_INT 2
#define PRTYPE_UINT 3
#define PRTYPE_LONG 4
#define PRTYPE_ULONG 5
#define PRTYPE_LONGLONG 6
#define PRTYPE_ULONGLONG 7
#define PRFORMAT_LEFT 0x1
#define PRFORMAT_SIGNED 0x2
#define PRFORMAT_SPACED 0x4
#define PRFORMAT_ZERO 0x8
#define PRFORMAT_NEG 0x10
#ifdef HAVE_LONG_LONG
#ifndef _WIN32
#define FETCH_LL(d,ap) ((d) = va_arg(ap, long long))
#define FETCH_ULL(d,ap) ((d) = va_arg(ap, unsigned long long))
#else
#define FETCH_LL(d,ap) ((d) = va_arg(ap, LONGLONG))
#define FETCH_ULL(d,ap) ((d) = va_arg(ap, DWORDLONG))
#endif
#else
#define FETCH_LL(d,ap) (((long*)&(d))[0] = va_arg(ap, long), \
((long*)&(d))[1] = va_arg(ap, long))
#define FETCH_ULL(d,ap) FETCH_LL(d,ap)
#endif
/*
* Fill into the buffer using the data in src
*/
static int
fill2(SprintfState *ss, const char *src, int srclen, int width, int flags)
{
char space = ' ';
int rv;
width -= srclen;
if ((width > 0) && ((flags & PRFORMAT_LEFT) == 0)) {
/* Right adjusting */
if (flags & PRFORMAT_ZERO) {
space = '0';
}
while (--width >= 0) {
rv = (*ss->stuff)(ss, &space, 1);
if (rv < 0) {
return rv;
}
}
}
/* Copy out the source data */
rv = (*ss->stuff)(ss, src, srclen);
if (rv < 0) {
return rv;
}
if ((width > 0) && ((flags & PRFORMAT_LEFT) != 0)) {
/* Left adjusting */
while (--width >= 0) {
rv = (*ss->stuff)(ss, &space, 1);
if (rv < 0) {
return rv;
}
}
}
return 0;
}
/*
* Fill a number. The order is: optional-sign zero-filling conversion-digits
*/
static int
fill_n(SprintfState *ss, const char *src, int srclen, int width, int prec,
int type, int flags)
{
int zerowidth = 0;
int precwidth = 0;
int signwidth = 0;
int leftspaces = 0;
int rightspaces = 0;
int cvtwidth;
int rv;
char sign;
if ((type & 1) == 0) {
if (flags & PRFORMAT_NEG) {
sign = '-';
signwidth = 1;
} else if (flags & PRFORMAT_SIGNED) {
sign = '+';
signwidth = 1;
}
}
cvtwidth = signwidth + srclen;
if (prec > 0) {
if (prec > srclen) {
precwidth = prec - srclen; /* Need zero filling */
cvtwidth += precwidth;
}
}
if ((flags & PRFORMAT_ZERO) && (prec < 0)) {
if (width > cvtwidth) {
zerowidth = width - cvtwidth; /* Zero filling */
cvtwidth += zerowidth;
}
}
if (flags & PRFORMAT_LEFT) {
if (width > cvtwidth) {
/* Space filling on the right (i.e. left adjusting) */
rightspaces = width - cvtwidth;
}
} else {
if (width > cvtwidth) {
/* Space filling on the left (i.e. right adjusting) */
leftspaces = width - cvtwidth;
}
}
while (--leftspaces >= 0) {
rv = (*ss->stuff)(ss, " ", 1);
if (rv < 0) {
return rv;
}
}
if (signwidth) {
rv = (*ss->stuff)(ss, &sign, 1);
if (rv < 0) {
return rv;
}
}
while (--precwidth >= 0) {
rv = (*ss->stuff)(ss, "0", 1);
if (rv < 0) {
return rv;
}
}
while (--zerowidth >= 0) {
rv = (*ss->stuff)(ss, "0", 1);
if (rv < 0) {
return rv;
}
}
rv = (*ss->stuff)(ss, src, srclen);
if (rv < 0) {
return rv;
}
while (--rightspaces >= 0) {
rv = (*ss->stuff)(ss, " ", 1);
if (rv < 0) {
return rv;
}
}
return 0;
}
/*
* Convert a long into its printable form
*/
static int
cvt_l(SprintfState *ss, long num, int width, int prec, int radix, int type,
int flags, const char *hexp)
{
char cvtbuf[100];
char *cvt;
int digits;
/* according to the man page this needs to happen */
if ((prec == 0) && (num == 0)) {
return 0;
}
/*
* Converting decimal is a little tricky. In the unsigned case we
* need to stop when we hit 10 digits. In the signed case, we can
* stop when the number is zero.
*/
cvt = cvtbuf + sizeof(cvtbuf);
digits = 0;
while (num) {
int digit = (int)((((unsigned long)num) % radix) & 0xF);
*--cvt = hexp[digit];
digits++;
num = ((unsigned long)num) / radix;
}
if (digits == 0) {
*--cvt = '0';
digits++;
}
/*
* Now that we have the number converted without its sign, deal with
* the sign and zero padding.
*/
return fill_n(ss, cvt, digits, width, prec, type, flags);
}
/*
* Convert a longlong into its printable form
*/
static int
cvt_ll(SprintfState *ss, int64 num, int width, int prec, int radix, int type,
int flags, const char *hexp)
{
char cvtbuf[100];
char *cvt;
int digits;
int64 rad;
/* according to the man page this needs to happen */
if ((prec == 0) && (LL_IS_ZERO(num))) {
return 0;
}
/*
* Converting decimal is a little tricky. In the unsigned case we
* need to stop when we hit 10 digits. In the signed case, we can
* stop when the number is zero.
*/
LL_I2L(rad, radix);
cvt = cvtbuf + sizeof(cvtbuf);
digits = 0;
while (!LL_IS_ZERO(num)) {
int32 digit;
int64 quot, rem;
LL_UDIVMOD(&quot, &rem, num, rad);
LL_L2I(digit, rem);
*--cvt = hexp[digit & 0xf];
digits++;
num = quot;
}
if (digits == 0) {
*--cvt = '0';
digits++;
}
/*
* Now that we have the number converted without its sign, deal with
* the sign and zero padding.
*/
return fill_n(ss, cvt, digits, width, prec, type, flags);
}
/*
* Convert a double precision floating point number into its printable
* form.
*
* XXX stop using sprintf to convert floating point
*/
static int
cvt_f(SprintfState *ss, double d, const char *fmt0, const char *fmt1)
{
char fin[20];
char fout[300];
int amount = fmt1 - fmt0;
PR_ASSERT((amount > 0) && (amount < sizeof(fin)));
if (amount >= sizeof(fin)) {
/* Totally bogus % command to sprintf. Just ignore it */
return 0;
}
memcpy(fin, fmt0, amount);
fin[amount] = 0;
/* Convert floating point using the native sprintf code */
sprintf(fout, fin, (double)d);
/*
* This assert will catch overflow's of fout, when building with
* debugging on. At least this way we can track down the evil piece
* of calling code and fix it!
*/
PR_ASSERT(strlen(fout) < sizeof(fout));
return (*ss->stuff)(ss, fout, strlen(fout));
}
/*
* Convert a string into its printable form. "width" is the output
* width. "prec" is the maximum number of characters of "s" to output,
* where -1 means until NUL.
*/
static int
cvt_s(SprintfState *ss, const char *s, int width, int prec, int flags)
{
int slen;
if (prec == 0)
return 0;
/* Limit string length by precision value */
slen = s ? strlen(s) : 6;
if (prec > 0) {
if (prec < slen) {
slen = prec;
}
}
/* and away we go */
return fill2(ss, s ? s : "(null)", slen, width, flags);
}
/*
* The workhorse sprintf code.
*/
static int
dosprintf(SprintfState *ss, const char *fmt, va_list ap)
{
char c;
int flags, width, prec, radix, type;
union {
char ch;
int i;
long l;
int64 ll;
double d;
const char *s;
int *ip;
} u;
const char *fmt0;
static char *hex = "0123456789abcdef";
static char *HEX = "0123456789ABCDEF";
char *hexp;
int rv;
while ((c = *fmt++) != 0) {
if (c != '%') {
rv = (*ss->stuff)(ss, fmt - 1, 1);
if (rv < 0) {
return rv;
}
continue;
}
fmt0 = fmt - 1;
/*
** Gobble up the % format string. Hopefully we have handled all
** of the strange cases!
*/
flags = 0;
c = *fmt++;
if (c == '%') {
/* quoting a % with %% */
rv = (*ss->stuff)(ss, fmt - 1, 1);
if (rv < 0) {
return rv;
}
continue;
}
/* examine optional flags */
while ((c == '-') || (c == '+') || (c == ' ') || (c == '0')) {
if (c == '-') flags |= PRFORMAT_LEFT;
if (c == '+') flags |= PRFORMAT_SIGNED;
if (c == ' ') flags |= PRFORMAT_SPACED;
if (c == '0') flags |= PRFORMAT_ZERO;
c = *fmt++;
}
if (flags & PRFORMAT_SIGNED) flags &= ~PRFORMAT_SPACED;
if (flags & PRFORMAT_LEFT) flags &= ~PRFORMAT_ZERO;
/* width */
if (c == '*') {
c = *fmt++;
width = va_arg(ap, int);
} else {
width = 0;
while ((c >= '0') && (c <= '9')) {
width = (width * 10) + (c - '0');
c = *fmt++;
}
}
/* precision */
prec = -1;
if (c == '.') {
c = *fmt++;
if (c == '*') {
c = *fmt++;
prec = va_arg(ap, int);
} else {
prec = 0;
while ((c >= '0') && (c <= '9')) {
prec = (prec * 10) + (c - '0');
c = *fmt++;
}
}
}
/* size */
type = PRTYPE_INT;
if (c == 'h') {
type = PRTYPE_SHORT;
c = *fmt++;
} else if (c == 'L') {
/* XXX not quite sure here */
type = PRTYPE_LONGLONG;
c = *fmt++;
} else if (c == 'l') {
type = PRTYPE_LONG;
c = *fmt++;
if (c == 'l') {
type = PRTYPE_LONGLONG;
c = *fmt++;
}
}
/* format */
hexp = hex;
switch (c) {
case 'd': case 'i': /* decimal/integer */
radix = 10;
goto fetch_and_convert;
case 'o': /* octal */
radix = 8;
type |= 1;
goto fetch_and_convert;
case 'u': /* unsigned decimal */
radix = 10;
type |= 1;
goto fetch_and_convert;
case 'x': /* unsigned hex */
radix = 16;
type |= 1;
goto fetch_and_convert;
case 'X': /* unsigned HEX */
radix = 16;
hexp = HEX;
type |= 1;
goto fetch_and_convert;
fetch_and_convert:
switch (type) {
case PRTYPE_SHORT:
u.l = va_arg(ap, int);
if (u.l < 0) {
u.l = -u.l;
flags |= PRFORMAT_NEG;
}
goto do_long;
case PRTYPE_USHORT:
u.l = va_arg(ap, int) & 0xffff;
goto do_long;
case PRTYPE_INT:
u.l = va_arg(ap, int);
if (u.l < 0) {
u.l = -u.l;
flags |= PRFORMAT_NEG;
}
goto do_long;
case PRTYPE_UINT:
u.l = va_arg(ap, int) & 0xffffffffL;
goto do_long;
case PRTYPE_LONG:
u.l = va_arg(ap, long);
if (u.l < 0) {
u.l = -u.l;
flags |= PRFORMAT_NEG;
}
goto do_long;
case PRTYPE_ULONG:
u.l = va_arg(ap, unsigned long);
do_long:
rv = cvt_l(ss, u.l, width, prec, radix, type, flags, hexp);
if (rv < 0) {
return rv;
}
break;
case PRTYPE_LONGLONG:
FETCH_LL(u.ll, ap);
if (!LL_GE_ZERO(u.ll)) {
LL_NEG(u.ll, u.ll);
flags |= PRFORMAT_NEG;
}
goto do_longlong;
case PRTYPE_ULONGLONG:
FETCH_ULL(u.ll, ap);
do_longlong:
rv = cvt_ll(ss, u.ll, width, prec, radix, type, flags, hexp);
if (rv < 0) {
return rv;
}
break;
}
break;
case 'e':
case 'f':
case 'g':
u.d = va_arg(ap, double);
rv = cvt_f(ss, u.d, fmt0, fmt);
if (rv < 0) {
return rv;
}
break;
case 'c':
u.ch = va_arg(ap, int);
rv = (*ss->stuff)(ss, &u.ch, 1);
if (rv < 0) {
return rv;
}
break;
case 'p':
if (sizeof(void *) == sizeof(long)) {
type = PRTYPE_ULONG;
} else if (sizeof(void *) == sizeof(int64)) {
type = PRTYPE_ULONGLONG;
} else if (sizeof(void *) == sizeof(int)) {
type = PRTYPE_UINT;
} else {
PR_ASSERT(0);
break;
}
radix = 16;
goto fetch_and_convert;
case 'C':
case 'S':
case 'E':
case 'G':
/* XXX not supported I suppose */
PR_ASSERT(0);
break;
case 's':
u.s = va_arg(ap, const char*);
rv = cvt_s(ss, u.s, width, prec, flags);
if (rv < 0) {
return rv;
}
break;
case 'n':
u.ip = va_arg(ap, int*);
if (u.ip) {
*u.ip = ss->cur - ss->base;
}
break;
default:
/* Not a % token after all... skip it */
PR_ASSERT(0);
rv = (*ss->stuff)(ss, "%", 1);
if (rv < 0) {
return rv;
}
rv = (*ss->stuff)(ss, fmt - 1, 1);
if (rv < 0) {
return rv;
}
}
}
/* Stuff trailing NUL */
rv = (*ss->stuff)(ss, "\0", 1);
return rv;
}
/************************************************************************/
static int
FuncStuff(SprintfState *ss, const char *sp, size_t len)
{
int rv;
rv = (*ss->func)(ss->arg, sp, len);
if (rv < 0) {
return rv;
}
ss->maxlen += len;
return 0;
}
PR_PUBLIC_API(size_t)
PR_sxprintf(PR_sxprintf_callback func, void *arg, const char *fmt, ...)
{
va_list ap;
int rv;
va_start(ap, fmt);
rv = PR_vsxprintf(func, arg, fmt, ap);
va_end(ap);
return rv;
}
PR_PUBLIC_API(size_t)
PR_vsxprintf(PR_vsxprintf_callback func, void *arg, const char *fmt,
va_list ap)
{
SprintfState ss;
int rv;
ss.stuff = FuncStuff;
ss.func = func;
ss.arg = arg;
ss.maxlen = 0;
rv = dosprintf(&ss, fmt, ap);
return (rv < 0) ? (size_t)-1 : ss.maxlen;
}
/*
* Stuff routine that automatically grows the malloc'd output buffer
* before it overflows.
*/
static int
GrowStuff(SprintfState *ss, const char *sp, size_t len)
{
ptrdiff_t off;
char *newbase;
off = ss->cur - ss->base;
if (off + len >= ss->maxlen) {
/* Grow the buffer */
ss->maxlen += (len > 32) ? len : 32;
if (ss->base) {
newbase = (char*) realloc(ss->base, ss->maxlen);
} else {
newbase = (char*) malloc(ss->maxlen);
}
if (!newbase) {
/* Ran out of memory */
return -1;
}
ss->base = newbase;
ss->cur = ss->base + off;
}
/* Copy data */
while (len) {
--len;
*ss->cur++ = *sp++;
}
PR_ASSERT((size_t)(ss->cur - ss->base) <= ss->maxlen);
return 0;
}
/*
* sprintf into a malloc'd buffer
*/
PR_PUBLIC_API(char *)
PR_smprintf(const char *fmt, ...)
{
va_list ap;
char *rv;
va_start(ap, fmt);
rv = PR_vsmprintf(fmt, ap);
va_end(ap);
return rv;
}
PR_PUBLIC_API(char *)
PR_vsmprintf(const char *fmt, va_list ap)
{
SprintfState ss;
int rv;
ss.stuff = GrowStuff;
ss.base = 0;
ss.cur = 0;
ss.maxlen = 0;
rv = dosprintf(&ss, fmt, ap);
if (rv < 0) {
if (ss.base) {
free(ss.base);
}
return 0;
}
return ss.base;
}
/*
* Stuff routine that discards overflow data
*/
static int
LimitStuff(SprintfState *ss, const char *sp, size_t len)
{
char *cp = ss->cur;
size_t limit = ss->maxlen - (cp - ss->base);
if (len > limit) {
len = limit;
}
while (len) {
--len;
*cp++ = *sp++;
}
ss->cur = cp;
return 0;
}
/*
* sprintf into a fixed size buffer. Make sure there is a NUL at the end
* when finished.
*/
PR_PUBLIC_API(size_t)
PR_snprintf(char *out, size_t outlen, const char *fmt, ...)
{
va_list ap;
int rv;
PR_ASSERT((int)outlen > 0);
if ((int32)outlen < 0) {
return 0;
}
va_start(ap, fmt);
rv = PR_vsnprintf(out, outlen, fmt, ap);
va_end(ap);
return rv;
}
PR_PUBLIC_API(size_t)
PR_vsnprintf(char *out, size_t outlen, const char *fmt, va_list ap)
{
SprintfState ss;
size_t n;
PR_ASSERT((int)outlen > 0);
if ((int32)outlen < 0) {
return 0;
}
ss.stuff = LimitStuff;
ss.base = out;
ss.cur = out;
ss.maxlen = outlen;
(void) dosprintf(&ss, fmt, ap);
/* Make sure there is a NUL at the end */
if (outlen) {
out[outlen-1] = 0;
}
n = ss.cur - ss.base;
return n ? n - 1 : n;
}
PR_PUBLIC_API(char *)
PR_sprintf_append(char *last, const char *fmt, ...)
{
va_list ap;
char *rv;
va_start(ap, fmt);
rv = PR_vsprintf_append(last, fmt, ap);
va_end(ap);
return rv;
}
PR_PUBLIC_API(char *)
PR_vsprintf_append(char *last, const char *fmt, va_list ap)
{
SprintfState ss;
int rv;
ss.stuff = GrowStuff;
if (last) {
int lastlen = strlen(last);
ss.base = last;
ss.cur = last + lastlen;
ss.maxlen = lastlen;
} else {
ss.base = 0;
ss.cur = 0;
ss.maxlen = 0;
}
rv = dosprintf(&ss, fmt, ap);
if (rv < 0) {
if (ss.base) {
free(ss.base);
}
return 0;
}
return ss.base;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку