summaryrefslogtreecommitdiff
path: root/Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh')
-rw-r--r--Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh641
1 files changed, 0 insertions, 641 deletions
diff --git a/Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh b/Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh
deleted file mode 100644
index b5756561684..00000000000
--- a/Build/source/texk/lcdf-typetools/lcdf-typetools-src/include/lcdf/straccum.hh
+++ /dev/null
@@ -1,641 +0,0 @@
-// -*- related-file-name: "../../liblcdf/straccum.cc" -*-
-#ifndef LCDF_STRACCUM_HH
-#define LCDF_STRACCUM_HH
-#include <string.h>
-#include <assert.h>
-#include <lcdf/string.hh>
-#if HAVE_PERMSTRING
-# include <lcdf/permstr.hh>
-#endif
-#if __GNUC__ > 4
-# define LCDF_SNPRINTF_ATTR __attribute__((__format__(__printf__, 3, 4)))
-#else
-# define LCDF_SNPRINTF_ATTR /* nothing */
-#endif
-template<typename T> class Vector;
-
-/** @file <lcdf/straccum.hh>
- @brief Click's StringAccum class, used to construct Strings efficiently from pieces.
-*/
-
-class StringAccum { public:
-
- typedef const char* const_iterator;
- typedef char* iterator;
-
- typedef int (StringAccum::*unspecified_bool_type)() const;
-
- inline StringAccum();
- explicit inline StringAccum(int capacity);
- explicit inline StringAccum(const char *cstr);
- inline StringAccum(const char* s, int len);
- inline StringAccum(const String& str);
- inline StringAccum(const StringAccum& x);
- inline ~StringAccum();
-
- inline const char* data() const;
- inline char* data();
- inline const unsigned char* udata() const;
- inline unsigned char* udata();
- inline int length() const;
- inline int capacity() const;
-
- inline bool empty() const;
- inline bool operator!() const;
- inline bool out_of_memory() const;
-
- inline const_iterator begin() const;
- inline iterator begin();
- inline const_iterator end() const;
- inline iterator end();
-
-
- /** @brief Return true iff the StringAccum contains characters.
- *
- * Returns false for empty and out-of-memory StringAccums. */
- inline operator unspecified_bool_type() const {
- return _len != 0 ? &StringAccum::capacity : 0;
- }
-
-
- /** @brief Null-terminate this StringAccum and return its data.
- *
- * Note that the null character does not contribute to the StringAccum's
- * length(), and later append() and similar operations can overwrite it.
- * If appending the null character fails, the StringAccum becomes
- * out-of-memory and the returned value is a null string. */
- const char *c_str();
-
-
- inline char operator[](int i) const;
- inline char& operator[](int i);
- inline char front() const;
- inline char& front();
- inline char back() const;
- inline char& back();
-
- inline void clear();
-
- inline char* reserve(int n);
- inline void set_length(int len);
-
- /** @brief Set the StringAccum's length to @a len.
- * @pre @a len >= 0
- * @return 0 on success, -ENOMEM on failure */
- int resize(int len);
-
- inline void adjust_length(int delta);
- inline char* extend(int nadjust, int nreserve = 0);
-
- inline void pop_back(int n = 1);
-
-
- inline void append(char c);
- inline void append(unsigned char c);
-
- /** @brief Append @a len copies of character @a c to the StringAccum. */
- void append_fill(int c, int len);
-
- inline void append_utf8(unsigned ch);
-
- /** @brief Append the null-terminated C string @a s to this StringAccum.
- * @param s data to append */
- void append(const char* s);
- inline void append(const char* s, int len);
- inline void append(const unsigned char* s, int len);
- inline void append(const char* begin, const char* end);
- inline void append(const unsigned char* begin, const unsigned char* end);
-
- // word joining
- void append_break_lines(const String &text, int linelen, const String &leftmargin = String());
-
- /** @brief Append result of snprintf() to this StringAccum.
- * @param n maximum number of characters to print
- * @param format format argument to snprintf()
- *
- * The terminating null character is not appended to the string.
- *
- * @note The safe vsnprintf() variant is called if it exists. It does in
- * the Linux kernel, and on modern Unix variants. However, if it does not
- * exist on your machine, then this function is actually unsafe, and you
- * should make sure that the printf() invocation represented by your
- * arguments will never write more than @a n characters, not including the
- * terminating null. */
- StringAccum &snprintf(int n, const char *format, ...) LCDF_SNPRINTF_ATTR;
-
-
- /** @brief Return a String object with this StringAccum's contents.
- *
- * This operation donates the StringAccum's memory to the returned String.
- * After a call to take_string(), the StringAccum object becomes empty,
- * and any future append() operations may cause memory allocations. If
- * the StringAccum is out-of-memory, the returned String is also
- * out-of-memory, but the StringAccum's out-of-memory state is reset. */
- String take_string();
-
-
- inline StringAccum& operator=(const StringAccum& x);
-
- /** @brief Swap this StringAccum's contents with @a x. */
- void swap(StringAccum &x);
-
- // see also operator<< declarations below
-
- private:
-
- enum {
- MEMO_SPACE = String::MEMO_SPACE
- };
-
- unsigned char *_s;
- int _len;
- int _cap;
-
- char *grow(int);
- void assign_out_of_memory();
-
- char *hard_extend(int nadjust, int nreserve);
- void hard_append(const char *s, int len);
- void append_utf8_hard(unsigned ch);
-
- friend StringAccum &operator<<(StringAccum &sa, const char *s);
- friend StringAccum &operator<<(StringAccum &sa, const String &str);
-#if HAVE_PERMSTRING
- friend StringAccum &operator<<(StringAccum &sa, PermString s);
-#endif
-
-};
-
-inline StringAccum &operator<<(StringAccum &, char);
-inline StringAccum &operator<<(StringAccum &, unsigned char);
-inline StringAccum &operator<<(StringAccum &, const char *);
-inline StringAccum &operator<<(StringAccum &, const String &);
-inline StringAccum &operator<<(StringAccum &, const StringAccum &);
-#ifdef HAVE_PERMSTRING
-inline StringAccum &operator<<(StringAccum &, PermString);
-#endif
-
-inline StringAccum &operator<<(StringAccum &, bool);
-inline StringAccum &operator<<(StringAccum &, short);
-inline StringAccum &operator<<(StringAccum &, unsigned short);
-inline StringAccum &operator<<(StringAccum &, int);
-inline StringAccum &operator<<(StringAccum &, unsigned);
-StringAccum &operator<<(StringAccum &, long);
-StringAccum &operator<<(StringAccum &, unsigned long);
-StringAccum &operator<<(StringAccum &, double);
-
-
-/** @brief Construct an empty StringAccum (with length 0). */
-inline StringAccum::StringAccum()
- : _s(0), _len(0), _cap(0) {
-}
-
-/** @brief Construct a StringAccum with room for at least @a capacity
- * characters.
- * @param capacity initial capacity
- *
- * If @a capacity <= 0, the StringAccum is created empty. If @a capacity
- * is too large (so that @a capacity bytes of memory can't be allocated),
- * the StringAccum falls back to a smaller capacity (possibly zero). */
-inline StringAccum::StringAccum(int capacity)
- : _len(0) {
- assert(capacity >= 0);
- if (capacity
- && (_s = new unsigned char[capacity + MEMO_SPACE])) {
- _s += MEMO_SPACE;
- _cap = capacity;
- } else {
- _s = 0;
- _cap = 0;
- }
-}
-
-/** @brief Construct a StringAccum containing the characters in @a s. */
-inline StringAccum::StringAccum(const char *cstr)
- : _s(0), _len(0), _cap(0) {
- append(cstr);
-}
-
-/** @brief Construct a StringAccum containing the characters in @a s. */
-inline StringAccum::StringAccum(const char *s, int len)
- : _s(0), _len(0), _cap(0) {
- append(s, len);
-}
-
-/** @brief Construct a StringAccum containing the characters in @a str. */
-inline StringAccum::StringAccum(const String &str)
- : _s(0), _len(0), _cap(0) {
- append(str.begin(), str.end());
-}
-
-/** @brief Construct a StringAccum containing a copy of @a x. */
-inline StringAccum::StringAccum(const StringAccum &x)
- : _s(0), _len(0), _cap(0) {
- append(x.data(), x.length());
-}
-
-/** @brief Destroy a StringAccum, freeing its memory. */
-inline StringAccum::~StringAccum() {
- if (_cap > 0)
- delete[] (_s - MEMO_SPACE);
-}
-
-/** @brief Return the contents of the StringAccum.
- * @return The StringAccum's contents.
- *
- * The return value is null if the StringAccum is empty or out-of-memory.
- * The returned data() value points to writable memory (unless the
- * StringAccum itself is const). */
-inline const char* StringAccum::data() const {
- return reinterpret_cast<const char *>(_s);
-}
-
-/** @overload */
-inline char* StringAccum::data() {
- return reinterpret_cast<char *>(_s);
-}
-
-inline const unsigned char* StringAccum::udata() const {
- return _s;
-}
-
-inline unsigned char* StringAccum::udata() {
- return _s;
-}
-
-/** @brief Return true iff the StringAccum is empty or out-of-memory. */
-inline bool StringAccum::empty() const {
- return _len == 0;
-}
-
-/** @brief Return the length of the StringAccum. */
-inline int StringAccum::length() const {
- return _len;
-}
-
-/** @brief Return the StringAccum's current capacity.
- *
- * The capacity is the maximum length the StringAccum can hold without
- * incurring a memory allocation. Returns -1 for out-of-memory
- * StringAccums. */
-inline int StringAccum::capacity() const {
- return _cap;
-}
-
-/** @brief Return an iterator for the first character in the StringAccum.
- *
- * StringAccum iterators are simply pointers into string data, so they are
- * quite efficient. @sa StringAccum::data */
-inline StringAccum::const_iterator StringAccum::begin() const {
- return reinterpret_cast<char*>(_s);
-}
-
-/** @overload */
-inline StringAccum::iterator StringAccum::begin() {
- return reinterpret_cast<char*>(_s);
-}
-
-/** @brief Return an iterator for the end of the StringAccum.
- *
- * The return value points one character beyond the last character in the
- * StringAccum. */
-inline StringAccum::const_iterator StringAccum::end() const {
- return reinterpret_cast<char*>(_s + _len);
-}
-
-/** @overload */
-inline StringAccum::iterator StringAccum::end() {
- return reinterpret_cast<char*>(_s + _len);
-}
-
-/** @brief Return true iff the StringAccum does not contain characters.
- *
- * Returns true for empty and out-of-memory StringAccums. */
-inline bool StringAccum::operator!() const {
- return _len == 0;
-}
-
-/** @brief Return true iff the StringAccum is out-of-memory. */
-inline bool StringAccum::out_of_memory() const {
- return _cap < 0;
-}
-
-/** @brief Return the <a>i</a>th character in the string.
- * @param i character index
- * @pre 0 <= @a i < length() */
-inline char StringAccum::operator[](int i) const {
- assert((unsigned) i < (unsigned) _len);
- return static_cast<char>(_s[i]);
-}
-
-/** @brief Return a reference to the <a>i</a>th character in the string.
- * @param i character index
- * @pre 0 <= @a i < length() */
-inline char& StringAccum::operator[](int i) {
- assert((unsigned) i < (unsigned) _len);
- return reinterpret_cast<char &>(_s[i]);
-}
-
-/** @brief Return the first character in the string.
- * @pre length() > 0 */
-inline char StringAccum::front() const {
- assert(_len > 0);
- return static_cast<char>(_s[0]);
-}
-
-/** @brief Return a reference to the first character in the string.
- * @pre length() > 0 */
-inline char& StringAccum::front() {
- assert(_len > 0);
- return reinterpret_cast<char &>(_s[0]);
-}
-
-/** @brief Return the last character in the string.
- * @pre length() > 0 */
-inline char StringAccum::back() const {
- assert(_len > 0);
- return static_cast<char>(_s[_len - 1]);
-}
-
-/** @brief Return a reference to the last character in the string.
- * @pre length() > 0 */
-inline char& StringAccum::back() {
- assert(_len > 0);
- return reinterpret_cast<char &>(_s[_len - 1]);
-}
-
-/** @brief Clear the StringAccum's comments.
- *
- * All characters in the StringAccum are erased. Also resets the
- * StringAccum's out-of-memory status. */
-inline void StringAccum::clear() {
- if (_cap < 0) {
- _cap = 0;
- _s = 0;
- }
- _len = 0;
-}
-
-/** @brief Reserve space for at least @a n characters.
- * @return a pointer to at least @a n characters, or null if allocation
- * fails
- * @pre @a n >= 0
- *
- * reserve() does not change the string's length(), only its capacity().
- * In a frequent usage pattern, code calls reserve(), passing an upper
- * bound on the characters that could be written by a series of
- * operations. After writing into the returned buffer, adjust_length() is
- * called to account for the number of characters actually written.
- *
- * On failure, null is returned and errno is set to ENOMEM. */
-inline char* StringAccum::reserve(int n) {
- assert(n >= 0);
- if (_len + n <= _cap)
- return reinterpret_cast<char *>(_s + _len);
- else
- return grow(_len + n);
-}
-
-/** @brief Set the StringAccum's length to @a len.
- * @param len new length in characters
- * @pre 0 <= @a len <= capacity()
- * @sa adjust_length */
-inline void StringAccum::set_length(int len) {
- assert(len >= 0 && _len <= _cap);
- _len = len;
-}
-
-/** @brief Adjust the StringAccum's length.
- * @param delta length adjustment
- * @pre If @a delta > 0, then length() + @a delta <= capacity().
- * If @a delta < 0, then length() + delta >= 0.
- *
- * The StringAccum's length after adjust_length(@a delta) equals its old
- * length plus @a delta. Generally adjust_length() is used after a call
- * to reserve(). @sa set_length */
-inline void StringAccum::adjust_length(int delta) {
- assert(_len + delta >= 0 && _len + delta <= _cap);
- _len += delta;
-}
-
-/** @brief Reserve space and adjust length in one operation.
- * @param nadjust number of characters to reserve and adjust length
- * @param nreserve additional characters to reserve
- * @pre @a nadjust >= 0 and @a nreserve >= 0
- *
- * This operation combines the effects of reserve(@a nadjust + @a
- * nreserve) and adjust_length(@a nadjust). Returns the result of the
- * reserve() call. */
-inline char* StringAccum::extend(int nadjust, int nreserve) {
- assert(nadjust >= 0 && nreserve >= 0);
- if (_len + nadjust + nreserve <= _cap) {
- char *x = reinterpret_cast<char *>(_s + _len);
- _len += nadjust;
- return x;
- } else
- return hard_extend(nadjust, nreserve);
-}
-
-/** @brief Remove characters from the end of the StringAccum.
- * @param n number of characters to remove
- * @pre @a n >= 0 and @a n <= length()
- *
- * Same as adjust_length(-@a n). */
-inline void StringAccum::pop_back(int n) {
- assert(n >= 0 && _len >= n);
- _len -= n;
-}
-
-/** @brief Append character @a c to the StringAccum.
- * @param c character to append */
-inline void StringAccum::append(char c) {
- if (_len < _cap || grow(_len))
- _s[_len++] = c;
-}
-
-/** @overload */
-inline void StringAccum::append(unsigned char c) {
- append(static_cast<char>(c));
-}
-
-/** @brief Append the UTF-8 encoding of Unicode character @a ch. */
-inline void StringAccum::append_utf8(unsigned ch) {
- if (ch < 0x80)
- append((unsigned char) ch);
- else
- append_utf8_hard(ch);
-}
-
-/** @brief Append the first @a len characters of @a s to this StringAccum.
- * @param s data to append
- * @param len length of data
- * @pre @a len >= 0 */
-inline void StringAccum::append(const char* s, int len) {
- assert(len >= 0);
- if (_len + len <= _cap) {
- memcpy(_s + _len, s, len);
- _len += len;
- } else
- hard_append(s, len);
-}
-
-/** @overload */
-inline void StringAccum::append(const unsigned char* s, int len) {
- append(reinterpret_cast<const char *>(s), len);
-}
-
-/** @brief Append the data from @a begin to @a end to the end of this
- * StringAccum.
- *
- * Does nothing if @a begin >= @a end. */
-inline void StringAccum::append(const char* begin, const char* end) {
- if (begin < end)
- append(begin, end - begin);
-}
-
-/** @overload */
-inline void StringAccum::append(const unsigned char* begin, const unsigned char* end) {
- if (begin < end)
- append(begin, end - begin);
-}
-
-/** @brief Assign this StringAccum to @a x. */
-inline StringAccum& StringAccum::operator=(const StringAccum& x) {
- if (&x != this) {
- if (out_of_memory())
- _s = 0, _cap = 0;
- _len = 0;
- append(x.data(), x.length());
- }
- return *this;
-}
-
-/** @relates StringAccum
- @brief Append character @a c to StringAccum @a sa.
- @return @a sa
- @note Same as @a sa.append(@a c). */
-inline StringAccum &
-operator<<(StringAccum &sa, char c)
-{
- sa.append(c);
- return sa;
-}
-
-/** @relates StringAccum
- @brief Append character @a c to StringAccum @a sa.
- @return @a sa
- @note Same as @a sa.append(@a c). */
-inline StringAccum &
-operator<<(StringAccum &sa, unsigned char c)
-{
- sa.append(c);
- return sa;
-}
-
-/** @relates StringAccum
- @brief Append null-terminated C string @a cstr to StringAccum @a sa.
- @return @a sa
- @note Same as @a sa.append(@a cstr). */
-inline StringAccum &
-operator<<(StringAccum &sa, const char *cstr)
-{
- sa.append(cstr);
- return sa;
-}
-
-/** @relates StringAccum
- @brief Append "true" or "false" to @a sa, depending on @a b.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, bool b)
-{
- static const char truefalse[] = "truefalse";
- if (b)
- sa.append(truefalse, 4);
- else
- sa.append(truefalse + 4, 5);
- return sa;
-}
-
-/** @relates StringAccum
- @brief Append decimal representation of @a i to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, short i)
-{
- return sa << static_cast<long>(i);
-}
-
-/** @relates StringAccum
- @brief Append decimal representation of @a u to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, unsigned short u)
-{
- return sa << static_cast<unsigned long>(u);
-}
-
-/** @relates StringAccum
- @brief Append decimal representation of @a i to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, int i)
-{
- return sa << static_cast<long>(i);
-}
-
-/** @relates StringAccum
- @brief Append decimal representation of @a u to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, unsigned u)
-{
- return sa << static_cast<unsigned long>(u);
-}
-
-/** @relates StringAccum
- @brief Append the contents of @a str to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, const String &str)
-{
- if (!str.out_of_memory())
- sa.hard_append(str.begin(), str.length());
- else
- sa.assign_out_of_memory();
- return sa;
-}
-
-#ifdef HAVE_PERMSTRING
-inline StringAccum &
-operator<<(StringAccum &sa, PermString s)
-{
- sa.append(s.c_str(), s.length());
- return sa;
-}
-#endif
-
-/** @relates StringAccum
- @brief Append the contents of @a sb to @a sa.
- @return @a sa */
-inline StringAccum &
-operator<<(StringAccum &sa, const StringAccum &sb)
-{
- sa.append(sb.begin(), sb.end());
- return sa;
-}
-
-inline bool
-operator==(StringAccum &sa, const char *s)
-{
- return strcmp(sa.c_str(), s) == 0;
-}
-
-inline bool
-operator!=(StringAccum &sa, const char *s)
-{
- return strcmp(sa.c_str(), s) != 0;
-}
-
-#undef LCDF_SNPRINTF_ATTR
-#endif