Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory : /usr/share/emscripten/tests/poppler/goo/
Upload File :
Current File : //usr/share/emscripten/tests/poppler/goo/GooString.cc
//========================================================================
//
// GooString.cc
//
// Simple variable-length string type.
//
// Copyright 1996-2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2006 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2006 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
// Copyright (C) 2007 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2008-2011 Albert Astals Cid <aacid@kde.org>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#include <config.h>
#ifdef USE_GCC_PRAGMAS
#pragma implementation
#endif
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <math.h>
#include "gmem.h"
#include "GooString.h"
static const int MAXIMUM_DOUBLE_PREC = 16;
//------------------------------------------------------------------------
union GooStringFormatArg {
int i;
Guint ui;
long l;
Gulong ul;
double f;
char c;
char *s;
GooString *gs;
};
enum GooStringFormatType {
fmtIntDecimal,
fmtIntHex,
fmtIntOctal,
fmtIntBinary,
fmtUIntDecimal,
fmtUIntHex,
fmtUIntOctal,
fmtUIntBinary,
fmtLongDecimal,
fmtLongHex,
fmtLongOctal,
fmtLongBinary,
fmtULongDecimal,
fmtULongHex,
fmtULongOctal,
fmtULongBinary,
fmtDouble,
fmtDoubleTrimSmallAware,
fmtDoubleTrim,
fmtChar,
fmtString,
fmtGooString,
fmtSpace
};
static char *formatStrings[] = {
"d", "x", "o", "b", "ud", "ux", "uo", "ub",
"ld", "lx", "lo", "lb", "uld", "ulx", "ulo", "ulb",
"f", "gs", "g",
"c",
"s",
"t",
"w",
NULL
};
//------------------------------------------------------------------------
int inline GooString::roundedSize(int len) {
int delta;
if (len <= STR_STATIC_SIZE-1)
return STR_STATIC_SIZE;
delta = len < 256 ? 7 : 255;
return ((len + 1) + delta) & ~delta;
}
// Make sure that the buffer is big enough to contain <newLength> characters
// plus terminating 0.
// We assume that if this is being called from the constructor, <s> was set
// to NULL and <length> was set to 0 to indicate unused string before calling us.
void inline GooString::resize(int newLength) {
char *s1 = s;
if (!s || (roundedSize(length) != roundedSize(newLength))) {
// requires re-allocating data for string
if (newLength < STR_STATIC_SIZE) {
s1 = sStatic;
} else {
// allocate a rounded amount
if (s == sStatic)
s1 = (char*)gmalloc(roundedSize(newLength));
else
s1 = (char*)grealloc(s, roundedSize(newLength));
}
if (s == sStatic || s1 == sStatic) {
// copy the minimum, we only need to if are moving to or
// from sStatic.
// assert(s != s1) the roundedSize condition ensures this
if (newLength < length) {
memcpy(s1, s, newLength);
} else {
memcpy(s1, s, length);
}
}
}
s = s1;
length = newLength;
s[length] = '\0';
}
GooString* GooString::Set(const char *s1, int s1Len, const char *s2, int s2Len)
{
int newLen = 0;
char *p;
if (s1) {
if (CALC_STRING_LEN == s1Len) {
s1Len = strlen(s1);
} else
assert(s1Len >= 0);
newLen += s1Len;
}
if (s2) {
if (CALC_STRING_LEN == s2Len) {
s2Len = strlen(s2);
} else
assert(s2Len >= 0);
newLen += s2Len;
}
resize(newLen);
p = s;
if (s1) {
memcpy(p, s1, s1Len);
p += s1Len;
}
if (s2) {
memcpy(p, s2, s2Len);
p += s2Len;
}
return this;
}
GooString::GooString() {
s = NULL;
length = 0;
Set(NULL);
}
GooString::GooString(const char *sA) {
s = NULL;
length = 0;
Set(sA, CALC_STRING_LEN);
}
GooString::GooString(const char *sA, int lengthA) {
s = NULL;
length = 0;
Set(sA, lengthA);
}
GooString::GooString(GooString *str, int idx, int lengthA) {
s = NULL;
length = 0;
assert(idx + lengthA <= str->length);
Set(str->getCString() + idx, lengthA);
}
GooString::GooString(const GooString *str) {
s = NULL;
length = 0;
Set(str->getCString(), str->length);
}
GooString::GooString(GooString *str1, GooString *str2) {
s = NULL;
length = 0;
Set(str1->getCString(), str1->length, str2->getCString(), str2->length);
}
GooString *GooString::fromInt(int x) {
char buf[24]; // enough space for 64-bit ints plus a little extra
char *p;
int len;
formatInt(x, buf, sizeof(buf), gFalse, 0, 10, &p, &len);
return new GooString(p, len);
}
GooString *GooString::format(char *fmt, ...) {
va_list argList;
GooString *s;
s = new GooString();
va_start(argList, fmt);
s->appendfv(fmt, argList);
va_end(argList);
return s;
}
GooString *GooString::formatv(char *fmt, va_list argList) {
GooString *s;
s = new GooString();
s->appendfv(fmt, argList);
return s;
}
GooString::~GooString() {
if (s != sStatic)
gfree(s);
}
GooString *GooString::clear() {
resize(0);
return this;
}
GooString *GooString::append(char c) {
return append((const char*)&c, 1);
}
GooString *GooString::append(GooString *str) {
return append(str->getCString(), str->getLength());
}
GooString *GooString::append(const char *str, int lengthA) {
int prevLen = length;
if (CALC_STRING_LEN == lengthA)
lengthA = strlen(str);
resize(length + lengthA);
memcpy(s + prevLen, str, lengthA);
return this;
}
GooString *GooString::appendf(char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
appendfv(fmt, argList);
va_end(argList);
return this;
}
GooString *GooString::appendfv(char *fmt, va_list argList) {
GooStringFormatArg *args;
int argsLen, argsSize;
GooStringFormatArg arg;
int idx, width, prec;
GBool reverseAlign, zeroFill;
GooStringFormatType ft;
char buf[65];
int len, i;
char *p0, *p1, *str;
argsLen = 0;
argsSize = 8;
args = (GooStringFormatArg *)gmallocn(argsSize, sizeof(GooStringFormatArg));
p0 = fmt;
while (*p0) {
if (*p0 == '{') {
++p0;
if (*p0 == '{') {
++p0;
append('{');
} else {
// parse the format string
if (!(*p0 >= '0' && *p0 <= '9')) {
break;
}
idx = *p0 - '0';
for (++p0; *p0 >= '0' && *p0 <= '9'; ++p0) {
idx = 10 * idx + (*p0 - '0');
}
if (*p0 != ':') {
break;
}
++p0;
if (*p0 == '-') {
reverseAlign = gTrue;
++p0;
} else {
reverseAlign = gFalse;
}
width = 0;
zeroFill = *p0 == '0';
for (; *p0 >= '0' && *p0 <= '9'; ++p0) {
width = 10 * width + (*p0 - '0');
}
if (*p0 == '.') {
++p0;
prec = 0;
for (; *p0 >= '0' && *p0 <= '9'; ++p0) {
prec = 10 * prec + (*p0 - '0');
}
} else {
prec = 0;
}
for (ft = (GooStringFormatType)0;
formatStrings[ft];
ft = (GooStringFormatType)(ft + 1)) {
if (!strncmp(p0, formatStrings[ft], strlen(formatStrings[ft]))) {
break;
}
}
if (!formatStrings[ft]) {
break;
}
p0 += strlen(formatStrings[ft]);
if (*p0 != '}') {
break;
}
++p0;
// fetch the argument
if (idx > argsLen) {
break;
}
if (idx == argsLen) {
if (argsLen == argsSize) {
argsSize *= 2;
args = (GooStringFormatArg *)greallocn(args, argsSize,
sizeof(GooStringFormatArg));
}
switch (ft) {
case fmtIntDecimal:
case fmtIntHex:
case fmtIntOctal:
case fmtIntBinary:
case fmtSpace:
args[argsLen].i = va_arg(argList, int);
break;
case fmtUIntDecimal:
case fmtUIntHex:
case fmtUIntOctal:
case fmtUIntBinary:
args[argsLen].ui = va_arg(argList, Guint);
break;
case fmtLongDecimal:
case fmtLongHex:
case fmtLongOctal:
case fmtLongBinary:
args[argsLen].l = va_arg(argList, long);
break;
case fmtULongDecimal:
case fmtULongHex:
case fmtULongOctal:
case fmtULongBinary:
args[argsLen].ul = va_arg(argList, Gulong);
break;
case fmtDouble:
case fmtDoubleTrim:
case fmtDoubleTrimSmallAware:
args[argsLen].f = va_arg(argList, double);
break;
case fmtChar:
args[argsLen].c = (char)va_arg(argList, int);
break;
case fmtString:
args[argsLen].s = va_arg(argList, char *);
break;
case fmtGooString:
args[argsLen].gs = va_arg(argList, GooString *);
break;
}
++argsLen;
}
// format the argument
arg = args[idx];
switch (ft) {
case fmtIntDecimal:
formatInt(arg.i, buf, sizeof(buf), zeroFill, width, 10, &str, &len);
break;
case fmtIntHex:
formatInt(arg.i, buf, sizeof(buf), zeroFill, width, 16, &str, &len);
break;
case fmtIntOctal:
formatInt(arg.i, buf, sizeof(buf), zeroFill, width, 8, &str, &len);
break;
case fmtIntBinary:
formatInt(arg.i, buf, sizeof(buf), zeroFill, width, 2, &str, &len);
break;
case fmtUIntDecimal:
formatUInt(arg.ui, buf, sizeof(buf), zeroFill, width, 10,
&str, &len);
break;
case fmtUIntHex:
formatUInt(arg.ui, buf, sizeof(buf), zeroFill, width, 16,
&str, &len);
break;
case fmtUIntOctal:
formatUInt(arg.ui, buf, sizeof(buf), zeroFill, width, 8, &str, &len);
break;
case fmtUIntBinary:
formatUInt(arg.ui, buf, sizeof(buf), zeroFill, width, 2, &str, &len);
break;
case fmtLongDecimal:
formatInt(arg.l, buf, sizeof(buf), zeroFill, width, 10, &str, &len);
break;
case fmtLongHex:
formatInt(arg.l, buf, sizeof(buf), zeroFill, width, 16, &str, &len);
break;
case fmtLongOctal:
formatInt(arg.l, buf, sizeof(buf), zeroFill, width, 8, &str, &len);
break;
case fmtLongBinary:
formatInt(arg.l, buf, sizeof(buf), zeroFill, width, 2, &str, &len);
break;
case fmtULongDecimal:
formatUInt(arg.ul, buf, sizeof(buf), zeroFill, width, 10,
&str, &len);
break;
case fmtULongHex:
formatUInt(arg.ul, buf, sizeof(buf), zeroFill, width, 16,
&str, &len);
break;
case fmtULongOctal:
formatUInt(arg.ul, buf, sizeof(buf), zeroFill, width, 8, &str, &len);
break;
case fmtULongBinary:
formatUInt(arg.ul, buf, sizeof(buf), zeroFill, width, 2, &str, &len);
break;
case fmtDouble:
formatDouble(arg.f, buf, sizeof(buf), prec, gFalse, &str, &len);
break;
case fmtDoubleTrim:
formatDouble(arg.f, buf, sizeof(buf), prec, gTrue, &str, &len);
break;
case fmtDoubleTrimSmallAware:
formatDoubleSmallAware(arg.f, buf, sizeof(buf), prec, gTrue, &str, &len);
break;
case fmtChar:
buf[0] = arg.c;
str = buf;
len = 1;
reverseAlign = !reverseAlign;
break;
case fmtString:
str = arg.s;
len = strlen(str);
reverseAlign = !reverseAlign;
break;
case fmtGooString:
str = arg.gs->getCString();
len = arg.gs->getLength();
reverseAlign = !reverseAlign;
break;
case fmtSpace:
str = buf;
len = 0;
width = arg.i;
break;
}
// append the formatted arg, handling width and alignment
if (!reverseAlign && len < width) {
for (i = len; i < width; ++i) {
append(' ');
}
}
append(str, len);
if (reverseAlign && len < width) {
for (i = len; i < width; ++i) {
append(' ');
}
}
}
} else if (*p0 == '}') {
++p0;
if (*p0 == '}') {
++p0;
}
append('}');
} else {
for (p1 = p0 + 1; *p1 && *p1 != '{' && *p1 != '}'; ++p1) ;
append(p0, p1 - p0);
p0 = p1;
}
}
gfree(args);
return this;
}
void GooString::formatInt(long x, char *buf, int bufSize,
GBool zeroFill, int width, int base,
char **p, int *len) {
static char vals[17] = "0123456789abcdef";
GBool neg;
int start, i, j;
i = bufSize;
if ((neg = x < 0)) {
x = -x;
}
start = neg ? 1 : 0;
if (x == 0) {
buf[--i] = '0';
} else {
while (i > start && x) {
buf[--i] = vals[x % base];
x /= base;
}
}
if (zeroFill) {
for (j = bufSize - i; i > start && j < width - start; ++j) {
buf[--i] = '0';
}
}
if (neg) {
buf[--i] = '-';
}
*p = buf + i;
*len = bufSize - i;
}
void GooString::formatUInt(Gulong x, char *buf, int bufSize,
GBool zeroFill, int width, int base,
char **p, int *len) {
static char vals[17] = "0123456789abcdef";
int i, j;
i = bufSize;
if (x == 0) {
buf[--i] = '0';
} else {
while (i > 0 && x) {
buf[--i] = vals[x % base];
x /= base;
}
}
if (zeroFill) {
for (j = bufSize - i; i > 0 && j < width; ++j) {
buf[--i] = '0';
}
}
*p = buf + i;
*len = bufSize - i;
}
void GooString::formatDouble(double x, char *buf, int bufSize, int prec,
GBool trim, char **p, int *len) {
GBool neg, started;
double x2;
int d, i, j;
if ((neg = x < 0)) {
x = -x;
}
x = floor(x * pow((double)10, prec) + 0.5);
i = bufSize;
started = !trim;
for (j = 0; j < prec && i > 1; ++j) {
x2 = floor(0.1 * (x + 0.5));
d = (int)floor(x - 10 * x2 + 0.5);
if (started || d != 0) {
buf[--i] = '0' + d;
started = gTrue;
}
x = x2;
}
if (i > 1 && started) {
buf[--i] = '.';
}
if (i > 1) {
do {
x2 = floor(0.1 * (x + 0.5));
d = (int)floor(x - 10 * x2 + 0.5);
buf[--i] = '0' + d;
x = x2;
} while (i > 1 && x);
}
if (neg) {
buf[--i] = '-';
}
*p = buf + i;
*len = bufSize - i;
}
void GooString::formatDoubleSmallAware(double x, char *buf, int bufSize, int prec,
GBool trim, char **p, int *len)
{
double absX = fabs(x);
if (absX >= 0.1) {
formatDouble(x, buf, bufSize, prec, trim, p, len);
} else {
while (absX < 0.1 && prec < MAXIMUM_DOUBLE_PREC)
{
absX = absX * 10;
prec++;
}
formatDouble(x, buf, bufSize, prec, trim, p, len);
}
}
GooString *GooString::insert(int i, char c) {
return insert(i, (const char*)&c, 1);
}
GooString *GooString::insert(int i, GooString *str) {
return insert(i, str->getCString(), str->getLength());
}
GooString *GooString::insert(int i, const char *str, int lengthA) {
int j;
int prevLen = length;
if (CALC_STRING_LEN == lengthA)
lengthA = strlen(str);
resize(length + lengthA);
for (j = prevLen; j >= i; --j)
s[j+lengthA] = s[j];
memcpy(s+i, str, lengthA);
return this;
}
GooString *GooString::del(int i, int n) {
int j;
if (n > 0) {
if (i + n > length) {
n = length - i;
}
for (j = i; j <= length - n; ++j) {
s[j] = s[j + n];
}
resize(length - n);
}
return this;
}
GooString *GooString::upperCase() {
int i;
for (i = 0; i < length; ++i) {
if (islower(s[i]))
s[i] = toupper(s[i]);
}
return this;
}
GooString *GooString::lowerCase() {
int i;
for (i = 0; i < length; ++i) {
if (isupper(s[i]))
s[i] = tolower(s[i]);
}
return this;
}
int GooString::cmp(GooString *str) const {
int n1, n2, i, x;
char *p1, *p2;
n1 = length;
n2 = str->length;
for (i = 0, p1 = s, p2 = str->s; i < n1 && i < n2; ++i, ++p1, ++p2) {
x = *p1 - *p2;
if (x != 0) {
return x;
}
}
return n1 - n2;
}
int GooString::cmpN(GooString *str, int n) const {
int n1, n2, i, x;
char *p1, *p2;
n1 = length;
n2 = str->length;
for (i = 0, p1 = s, p2 = str->s;
i < n1 && i < n2 && i < n;
++i, ++p1, ++p2) {
x = *p1 - *p2;
if (x != 0) {
return x;
}
}
if (i == n) {
return 0;
}
return n1 - n2;
}
int GooString::cmp(const char *sA) const {
int n1, i, x;
const char *p1, *p2;
n1 = length;
for (i = 0, p1 = s, p2 = sA; i < n1 && *p2; ++i, ++p1, ++p2) {
x = *p1 - *p2;
if (x != 0) {
return x;
}
}
if (i < n1) {
return 1;
}
if (*p2) {
return -1;
}
return 0;
}
int GooString::cmpN(const char *sA, int n) const {
int n1, i, x;
const char *p1, *p2;
n1 = length;
for (i = 0, p1 = s, p2 = sA; i < n1 && *p2 && i < n; ++i, ++p1, ++p2) {
x = *p1 - *p2;
if (x != 0) {
return x;
}
}
if (i == n) {
return 0;
}
if (i < n1) {
return 1;
}
if (*p2) {
return -1;
}
return 0;
}
GBool GooString::hasUnicodeMarker(void)
{
return (s[0] & 0xff) == 0xfe && (s[1] & 0xff) == 0xff;
}
GooString *GooString::sanitizedName(GBool psmode)
{
GooString *name;
char buf[8];
int i;
char c;
name = new GooString();
if (psmode)
{
// ghostscript chokes on names that begin with out-of-limits
// numbers, e.g., 1e4foo is handled correctly (as a name), but
// 1e999foo generates a limitcheck error
c = getChar(0);
if (c >= '0' && c <= '9') {
name->append('f');
}
}
for (i = 0; i < getLength(); ++i) {
c = getChar(i);
if (c <= (char)0x20 || c >= (char)0x7f ||
c == ' ' ||
c == '(' || c == ')' || c == '<' || c == '>' ||
c == '[' || c == ']' || c == '{' || c == '}' ||
c == '/' || c == '%' || c == '#') {
sprintf(buf, "#%02x", c & 0xff);
name->append(buf);
} else {
name->append(c);
}
}
return name;
}
Server : Apache/2.4.41 (Ubuntu)