From 1612bfd9e3f1db86e943626640b71cdf3df5b9a0 Mon Sep 17 00:00:00 2001 From: Peter Breitenlohner Date: Fri, 22 Aug 2014 07:04:01 +0000 Subject: poppler 0.26.4 git-svn-id: svn://tug.org/texlive/trunk@35006 c570f23f-e606-0410-a88d-b1316a301751 --- .../libs/poppler/poppler-0.26.4/goo/GooString.h | 224 +++++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 Build/source/libs/poppler/poppler-0.26.4/goo/GooString.h (limited to 'Build/source/libs/poppler/poppler-0.26.4/goo/GooString.h') diff --git a/Build/source/libs/poppler/poppler-0.26.4/goo/GooString.h b/Build/source/libs/poppler/poppler-0.26.4/goo/GooString.h new file mode 100644 index 00000000000..b8020b62992 --- /dev/null +++ b/Build/source/libs/poppler/poppler-0.26.4/goo/GooString.h @@ -0,0 +1,224 @@ +//======================================================================== +// +// GooString.h +// +// 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 +// Copyright (C) 2006 Krzysztof Kowalczyk +// Copyright (C) 2008-2010, 2012 Albert Astals Cid +// Copyright (C) 2012-2014 Fabio D'Urso +// Copyright (C) 2013 Jason Crain +// +// 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 +// +//======================================================================== + +#ifndef GooString_H +#define GooString_H + +#ifdef USE_GCC_PRAGMAS +#pragma interface +#endif + +#include // for LLONG_MAX and ULLONG_MAX + +/* and/or the compiler may or may not define these. */ +/* Minimum and maximum values a `signed long long int' can hold. */ +#ifndef LLONG_MAX +# define LLONG_MAX 9223372036854775807LL +#endif +#ifndef LLONG_MIN +# define LLONG_MIN (-LLONG_MAX - 1LL) +#endif + +/* Maximum value an `unsigned long long int' can hold. (Minimum is 0.) */ +#ifndef ULLONG_MAX +# define ULLONG_MAX 18446744073709551615ULL +#endif + +#include +#include // for NULL +#include "gtypes.h" + +#ifdef __clang__ +# define GOOSTRING_FORMAT __attribute__((__annotate__("gooformat"))) +#else +# define GOOSTRING_FORMAT +#endif + +class GooString { +public: + + // Create an empty string. + GooString(); + + // Create a string from a C string. + explicit GooString(const char *sA); + + // Create a string from chars at . This string + // can contain null characters. + GooString(const char *sA, int lengthA); + + // Create a string from chars at in . + GooString(GooString *str, int idx, int lengthA); + + // Set content of a string to concatination of and . They can both + // be NULL. if or is CALC_STRING_LEN, then length of the string + // will be calculated with strlen(). Otherwise we assume they are a valid + // length of string (or its substring) + GooString* Set(const char *s1, int s1Len=CALC_STRING_LEN, const char *s2=NULL, int s2Len=CALC_STRING_LEN); + + // Copy a string. + explicit GooString(const GooString *str); + GooString *copy() const { return new GooString(this); } + + // Concatenate two strings. + GooString(GooString *str1, GooString *str2); + + // Convert an integer to a string. + static GooString *fromInt(int x); + + // Create a formatted string. Similar to printf, but without the + // string overflow issues. Formatting elements consist of: + // {:[][.]} + // where: + // - is the argument number (arg 0 is the first argument + // following the format string) -- NB: args must be first used in + // order; they can be reused in any order + // - is the field width -- negative to reverse the alignment; + // starting with a leading zero to zero-fill (for integers) + // - is the number of digits to the right of the decimal + // point (for floating point numbers) + // - is one of: + // d, x, X, o, b -- int in decimal, lowercase hex, uppercase hex, octal, binary + // ud, ux, uX, uo, ub -- unsigned int + // ld, lx, lX, lo, lb, uld, ulx, ulX, ulo, ulb -- long, unsigned long + // lld, llx, llX, llo, llb, ulld, ullx, ullX, ullo, ullb + // -- long long, unsigned long long + // f, g, gs -- floating point (float or double) + // f -- always prints trailing zeros (eg 1.0 with .2f will print 1.00) + // g -- omits trailing zeros and, if possible, the dot (eg 1.0 shows up as 1) + // gs -- is like g, but treats as number of significant + // digits to show (eg 0.0123 with .2gs will print 0.012) + // c -- character (char, short or int) + // s -- string (char *) + // t -- GooString * + // w -- blank space; arg determines width + // To get literal curly braces, use {{ or }}. + static GooString *format(const char *fmt, ...) GOOSTRING_FORMAT; + static GooString *formatv(const char *fmt, va_list argList); + + // Destructor. + ~GooString(); + + // Get length. + int getLength() { return length; } + + // Get C string. + char *getCString() const { return s; } + + // Get th character. + char getChar(int i) { return s[i]; } + + // Change th character. + void setChar(int i, char c) { s[i] = c; } + + // Clear string to zero length. + GooString *clear(); + + // Append a character or string. + GooString *append(char c); + GooString *append(GooString *str); + GooString *append(const char *str, int lengthA=CALC_STRING_LEN); + + // Append a formatted string. + GooString *appendf(const char *fmt, ...) GOOSTRING_FORMAT; + GooString *appendfv(const char *fmt, va_list argList); + + // Insert a character or string. + GooString *insert(int i, char c); + GooString *insert(int i, GooString *str); + GooString *insert(int i, const char *str, int lengthA=CALC_STRING_LEN); + + // Delete a character or range of characters. + GooString *del(int i, int n = 1); + + // Convert string to all-upper/all-lower case. + GooString *upperCase(); + GooString *lowerCase(); + + // Compare two strings: -1:< 0:= +1:> + int cmp(GooString *str) const; + int cmpN(GooString *str, int n) const; + int cmp(const char *sA) const; + int cmpN(const char *sA, int n) const; + + // Return true if string ends with suffix + GBool endsWith(const char *suffix) const; + + GBool hasUnicodeMarker(void); + + // Sanitizes the string so that it does + // not contain any ( ) < > [ ] { } / % + // The postscript mode also has some more strict checks + // The caller owns the return value + GooString *sanitizedName(GBool psmode); + +private: + GooString(const GooString &other); + GooString& operator=(const GooString &other); + + // you can tweak this number for a different speed/memory usage tradeoffs. + // In libc malloc() rounding is 16 so it's best to choose a value that + // results in sizeof(GooString) be a multiple of 16. + // 24 makes sizeof(GooString) to be 32. + static const int STR_STATIC_SIZE = 24; + // a special value telling that the length of the string is not given + // so it must be calculated from the strings + static const int CALC_STRING_LEN = -1; + + int roundedSize(int len); + + char sStatic[STR_STATIC_SIZE]; + int length; + char *s; + + void resize(int newLength); +#ifdef LLONG_MAX + static void formatInt(long long x, char *buf, int bufSize, + GBool zeroFill, int width, int base, + char **p, int *len, GBool upperCase = gFalse); +#else + static void formatInt(long x, char *buf, int bufSize, + GBool zeroFill, int width, int base, + char **p, int *len, GBool upperCase = gFalse); +#endif +#ifdef ULLONG_MAX + static void formatUInt(unsigned long long x, char *buf, int bufSize, + GBool zeroFill, int width, int base, + char **p, int *len, GBool upperCase = gFalse); +#else + static void formatUInt(Gulong x, char *buf, int bufSize, + GBool zeroFill, int width, int base, + char **p, int *len, GBool upperCase = gFalse); +#endif + static void formatDouble(double x, char *buf, int bufSize, int prec, + GBool trim, char **p, int *len); + static void formatDoubleSmallAware(double x, char *buf, int bufSize, int prec, + GBool trim, char **p, int *len); +}; + +#endif -- cgit v1.2.3