diff options
Diffstat (limited to 'plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h')
| -rw-r--r-- | plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h | 2924 |
1 files changed, 2924 insertions, 0 deletions
diff --git a/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h b/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h new file mode 100644 index 0000000000..8e3f74786a --- /dev/null +++ b/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h @@ -0,0 +1,2924 @@ +/************************************************************************************************* + * Utility functions + * Copyright (C) 2009-2012 FAL Labs + * This file is part of Kyoto Cabinet. + * This program is free software: you can redistribute it and/or modify it under the terms of + * the GNU General Public License as published by the Free Software Foundation, either version + * 3 of the License, or any later version. + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * You should have received a copy of the GNU General Public License along with this program. + * If not, see <http://www.gnu.org/licenses/>. + *************************************************************************************************/ + + +#ifndef _KCUTIL_H // duplication check +#define _KCUTIL_H + +#include <kccommon.h> + +namespace kyotocabinet { // common namespace + + +/** The maximum value of int8_t. */ +const int8_t INT8MAX = (std::numeric_limits<int8_t>::max)(); + + +/** The maximum value of int16_t. */ +const int16_t INT16MAX = (std::numeric_limits<int16_t>::max)(); + + +/** The maximum value of int32_t. */ +const int32_t INT32MAX = (std::numeric_limits<int32_t>::max)(); + + +/** The maximum value of int64_t. */ +const int64_t INT64MAX = (std::numeric_limits<int64_t>::max)(); + + +/** The minimum value of int8_t. */ +const int8_t INT8MIN = (std::numeric_limits<int8_t>::min)(); + + +/** The minimum value of int16_t. */ +const int16_t INT16MIN = (std::numeric_limits<int16_t>::min)(); + + +/** The minimum value of int32_t. */ +const int32_t INT32MIN = (std::numeric_limits<int32_t>::min)(); + + +/** The minimum value of int64_t. */ +const int64_t INT64MIN = (std::numeric_limits<int64_t>::min)(); + + +/** The maximum value of uint8_t. */ +const uint8_t UINT8MAX = (std::numeric_limits<uint8_t>::max)(); + + +/** The maximum value of uint16_t. */ +const uint16_t UINT16MAX = (std::numeric_limits<uint16_t>::max)(); + + +/** The maximum value of uint32_t. */ +const uint32_t UINT32MAX = (std::numeric_limits<uint32_t>::max)(); + + +/** The maximum value of uint64_t. */ +const uint64_t UINT64MAX = (std::numeric_limits<uint64_t>::max)(); + + +/** The maximum value of size_t. */ +const size_t SIZEMAX = (std::numeric_limits<size_t>::max)(); + + +/** The maximum value of float. */ +const float FLTMAX = (std::numeric_limits<float>::max)(); + + +/** The maximum value of double. */ +const double DBLMAX = (std::numeric_limits<double>::max)(); + + +/** An alias of hash map of strings. */ +typedef std::unordered_map<std::string, std::string> StringHashMap; + + +/** An alias of tree map of strings. */ +typedef std::map<std::string, std::string> StringTreeMap; + + +/** The package version. */ +extern const char* const VERSION; + + +/** The library version. */ +extern const int32_t LIBVER; + + +/** The library revision. */ +extern const int32_t LIBREV; + + +/** The database format version. */ +extern const int32_t FMTVER; + + +/** The system name. */ +extern const char* const OSNAME; + + +/** The flag for big endian environments. */ +extern const bool BIGEND; + + +/** The clock tick of interruption. */ +extern const int32_t CLOCKTICK; + + +/** The size of a page. */ +extern const int32_t PAGESIZ; + + +/** The extra feature list. */ +extern const char* const FEATURES; + + +/** The buffer size for numeric data. */ +const size_t NUMBUFSIZ = 32; + + +/** The maximum memory size for debugging. */ +const size_t MEMMAXSIZ = INT32MAX / 2; + + +/** + * Convert a decimal string to an integer. + * @param str the decimal string. + * @return the integer. If the string does not contain numeric expression, 0 is returned. + */ +int64_t atoi(const char* str); + + +/** + * Convert a decimal string with a metric prefix to an integer. + * @param str the decimal string, which can be trailed by a binary metric prefix. "K", "M", "G", + * "T", "P", and "E" are supported. They are case-insensitive. + * @return the integer. If the string does not contain numeric expression, 0 is returned. If + * the integer overflows the domain, kyotocabinet::INT64MAX or kyotocabinet::INT64_MIN is + * returned according to the sign. + */ +int64_t atoix(const char* str); + + +/** + * Convert a hexadecimal string to an integer. + * @param str the hexadecimal string. + * @return the integer. If the string does not contain numeric expression, 0 is returned. + */ +int64_t atoih(const char* str); + + +/** + * Convert a decimal byte array to an integer. + * @param ptr the decimal byte array. + * @param size the size of the decimal byte array. + * @return the integer. If the string does not contain numeric expression, 0 is returned. + */ +int64_t atoin(const char* ptr, size_t size); + + +/** + * Convert a decimal string to a real number. + * @param str the decimal string. + * @return the real number. If the string does not contain numeric expression, 0.0 is returned. + */ +double atof(const char* str); + + +/** + * Convert a decimal byte array to a real number. + * @param ptr the decimal byte array. + * @param size the size of the decimal byte array. + * @return the real number. If the string does not contain numeric expression, 0.0 is returned. + */ +double atofn(const char* ptr, size_t size); + + +/** + * Normalize a 16-bit number in the native order into the network byte order. + * @param num the 16-bit number in the native order. + * @return the number in the network byte order. + */ +uint16_t hton16(uint16_t num); + + +/** + * Normalize a 32-bit number in the native order into the network byte order. + * @param num the 32-bit number in the native order. + * @return the number in the network byte order. + */ +uint32_t hton32(uint32_t num); + + +/** + * Normalize a 64-bit number in the native order into the network byte order. + * @param num the 64-bit number in the native order. + * @return the number in the network byte order. + */ +uint64_t hton64(uint64_t num); + + +/** + * Denormalize a 16-bit number in the network byte order into the native order. + * @param num the 16-bit number in the network byte order. + * @return the converted number in the native order. + */ +uint16_t ntoh16(uint16_t num); + + +/** + * Denormalize a 32-bit number in the network byte order into the native order. + * @param num the 32-bit number in the network byte order. + * @return the converted number in the native order. + */ +uint32_t ntoh32(uint32_t num); + + +/** + * Denormalize a 64-bit number in the network byte order into the native order. + * @param num the 64-bit number in the network byte order. + * @return the converted number in the native order. + */ +uint64_t ntoh64(uint64_t num); + + +/** + * Write a number in fixed length format into a buffer. + * @param buf the desitination buffer. + * @param num the number. + * @param width the width. + */ +void writefixnum(void* buf, uint64_t num, size_t width); + + +/** + * Read a number in fixed length format from a buffer. + * @param buf the source buffer. + * @param width the width. + * @return the read number. + */ +uint64_t readfixnum(const void* buf, size_t width); + + +/** + * Write a number in variable length format into a buffer. + * @param buf the desitination buffer. + * @param num the number. + * @return the length of the written region. + */ +size_t writevarnum(void* buf, uint64_t num); + + +/** + * Read a number in variable length format from a buffer. + * @param buf the source buffer. + * @param size the size of the source buffer. + * @param np the pointer to the variable into which the read number is assigned. + * @return the length of the read region, or 0 on failure. + */ +size_t readvarnum(const void* buf, size_t size, uint64_t* np); + + +/** + * Check the size of variable length format of a number. + * @return the size of variable length format. + */ +size_t sizevarnum(uint64_t num); + + +/** + * Get the hash value by MurMur hashing. + * @param buf the source buffer. + * @param size the size of the source buffer. + * @return the hash value. + */ +uint64_t hashmurmur(const void* buf, size_t size); + + +/** + * Get the hash value by FNV hashing. + * @param buf the source buffer. + * @param size the size of the source buffer. + * @return the hash value. + */ +uint64_t hashfnv(const void* buf, size_t size); + + +/** + * Get the hash value suitable for a file name. + * @param buf the source buffer. + * @param size the size of the source buffer. + * @param obuf the buffer into which the result hash string is written. It must be more than + * NUMBUFSIZ. + * @return the auxiliary hash value. + */ +uint32_t hashpath(const void* buf, size_t size, char* obuf); + + +/** + * Get a prime number nearby a number. + * @param num a natural number. + * @return the result number. + */ +uint64_t nearbyprime(uint64_t num); + + +/** + * Get the quiet Not-a-Number value. + * @return the quiet Not-a-Number value. + */ +double nan(); + + +/** + * Get the positive infinity value. + * @return the positive infinity value. + */ +double inf(); + + +/** + * Check a number is a Not-a-Number value. + * @return true for the number is a Not-a-Number value, or false if not. + */ +bool chknan(double num); + + +/** + * Check a number is an infinity value. + * @return true for the number is an infinity value, or false if not. + */ +bool chkinf(double num); + + +/** + * Append a formatted string at the end of a string. + * @param dest the destination string. + * @param format the printf-like format string. The conversion character `%' can be used with + * such flag characters as `s', `d', `o', `u', `x', `X', `c', `e', `E', `f', `g', `G', and `%'. + * @param ap used according to the format string. + */ +void vstrprintf(std::string* dest, const char* format, va_list ap); + + +/** + * Append a formatted string at the end of a string. + * @param dest the destination string. + * @param format the printf-like format string. The conversion character `%' can be used with + * such flag characters as `s', `d', `o', `u', `x', `X', `c', `e', `E', `f', `g', `G', and `%'. + * @param ... used according to the format string. + */ +void strprintf(std::string* dest, const char* format, ...); + + +/** + * Generate a formatted string. + * @param format the printf-like format string. The conversion character `%' can be used with + * such flag characters as `s', `d', `o', `u', `x', `X', `c', `e', `E', `f', `g', `G', and `%'. + * @param ... used according to the format string. + * @return the result string. + */ +std::string strprintf(const char* format, ...); + + +/** + * Split a string with a delimiter. + * @param str the string. + * @param delim the delimiter. + * @param elems a vector object into which the result elements are pushed. + * @return the number of result elements. + */ +size_t strsplit(const std::string& str, char delim, std::vector<std::string>* elems); + + +/** + * Split a string with delimiters. + * @param str the string. + * @param delims the delimiters. + * @param elems a vector object into which the result elements are pushed. + * @return the number of result elements. + */ +size_t strsplit(const std::string& str, const std::string& delims, + std::vector<std::string>* elems); + + +/** + * Convert the letters of a string into upper case. + * @param str the string to convert. + * @return the string itself. + */ +std::string* strtoupper(std::string* str); + + +/** + * Convert the letters of a string into lower case. + * @param str the string to convert. + * @return the string itself. + */ +std::string* strtolower(std::string* str); + + +/** + * Check whether a string begins with a key. + * @param str the string. + * @param key the forward matching key string. + * @return true if the target string begins with the key, else, it is false. + */ +bool strfwm(const std::string& str, const std::string& key); + + +/** + * Check whether a string ends with a key. + * @param str the string. + * @param key the backward matching key string. + * @return true if the target string ends with the key, else, it is false. + */ +bool strbwm(const std::string& str, const std::string& key); + + +/** + * Cut space characters at head or tail of a string. + * @param str the string to convert. + * @return the string itself. + */ +std::string* strtrim(std::string* str); + + +/** + * Convert a UTF-8 string into a UCS-4 array. + * @param src the source object. + * @param dest the destination object. + */ +void strutftoucs(const std::string& src, std::vector<uint32_t>* dest); + + +/** + * Convert a UCS-4 array into a UTF-8 string. + * @param src the source object. + * @param dest the destination object. + */ +void strucstoutf(const std::vector<uint32_t>& src, std::string* dest); + + +/** + * Serialize a string vector object into a string object. + * @param src the source object. + * @param dest the destination object. + */ +void strvecdump(const std::vector<std::string>& src, std::string* dest); + + +/** + * Deserialize a string object into a string vector object. + * @param src the source object. + * @param dest the destination object. + */ +void strvecload(const std::string& src, std::vector<std::string>* dest); + + +/** + * Serialize a string vector object into a string object. + * @param src the source object. + * @param dest the destination object. + */ +void strmapdump(const std::map<std::string, std::string>& src, std::string* dest); + + +/** + * Deserialize a string object into a string map object. + * @param src the source object. + * @param dest the destination object. + */ +void strmapload(const std::string& src, std::map<std::string, std::string>* dest); + + +/** + * Encode a serial object by hexadecimal encoding. + * @param buf the pointer to the region. + * @param size the size of the region. + * @return the result string. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* hexencode(const void* buf, size_t size); + + +/** + * Decode a string encoded by hexadecimal encoding. + * @param str specifies the encoded string. + * @param sp the pointer to the variable into which the size of the region of the return value + * is assigned. + * @return the pointer to the region of the result. + * @note Because an additional zero code is appended at the end of the region of the return + * value, the return value can be treated as a character string. Because the region of the + * return value is allocated with the the new[] operator, it should be released with the delete[] + * operator when it is no longer in use. + */ +char* hexdecode(const char* str, size_t* sp); + + +/** + * Encode a serial object by URL encoding. + * @param buf the pointer to the region. + * @param size the size of the region. + * @return the result string. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* urlencode(const void* buf, size_t size); + + +/** + * Decode a string encoded by URL encoding. + * @param str specifies the encoded string. + * @param sp the pointer to the variable into which the size of the region of the return value + * is assigned. + * @return the pointer to the region of the result. + * @note Because an additional zero code is appended at the end of the region of the return + * value, the return value can be treated as a character string. Because the region of the + * return value is allocated with the the new[] operator, it should be released with the delete[] + * operator when it is no longer in use. + */ +char* urldecode(const char* str, size_t* sp); + + +/** + * Encode a serial object by Quoted-printable encoding. + * @param buf the pointer to the region. + * @param size the size of the region. + * @return the result string. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* quoteencode(const void* buf, size_t size); + + +/** + * Decode a string encoded by Quoted-printable encoding. + * @param str specifies the encoded string. + * @param sp the pointer to the variable into which the size of the region of the return value + * is assigned. + * @return the pointer to the region of the result. + * @note Because an additional zero code is appended at the end of the region of the return + * value, the return value can be treated as a character string. Because the region of the + * return value is allocated with the the new[] operator, it should be released with the delete[] + * operator when it is no longer in use. + */ +char* quotedecode(const char* str, size_t* sp); + + +/** + * Encode a serial object by Base64 encoding. + * @param buf the pointer to the region. + * @param size the size of the region. + * @return the result string. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* baseencode(const void* buf, size_t size); + + +/** + * Decode a string encoded by Base64 encoding. + * @param str specifies the encoded string. + * @param sp the pointer to the variable into which the size of the region of the return value + * is assigned. + * @return the pointer to the region of the result. + * @note Because an additional zero code is appended at the end of the region of the return + * value, the return value can be treated as a character string. Because the region of the + * return value is allocated with the the new[] operator, it should be released with the delete[] + * operator when it is no longer in use. + */ +char* basedecode(const char* str, size_t* sp); + + +/** + * Cipher or decipher a serial object with the Arcfour stream cipher. + * @param ptr the pointer to the region. + * @param size the size of the region. + * @param kbuf the pointer to the region of the cipher key. + * @param ksiz the size of the region of the cipher key. + * @param obuf the pointer to the region into which the result data is written. The size of the + * buffer should be equal to or more than the input region. The region can be the same as the + * source region. + */ +void arccipher(const void* ptr, size_t size, const void* kbuf, size_t ksiz, void* obuf); + + +/** + * Duplicate a region on memory. + * @param ptr the source buffer. + * @param size the size of the source buffer. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* memdup(const char* ptr, size_t size); + + +/** + * Compare two regions by case insensitive evaluation. + * @param abuf a buffer. + * @param bbuf the other buffer. + * @param size the size of each buffer. + * @return positive if the former is big, negative if the latter is big, 0 if both are + * equivalent. + */ +int32_t memicmp(const void* abuf, const void* bbuf, size_t size); + + +/** + * Find the first occurrence of a sub pattern. + * @param hbuf the target pattern buffer. + * @param hsiz the size of the target pattern buffer. + * @param nbuf the sub pattern buffer. + * @param nsiz the size of the sub pattern buffer. + * @return the pointer to the beginning of the sub pattern in the target pattern buffer, or NULL + * if the sub pattern is not found. + */ +void* memmem(const void* hbuf, size_t hsiz, const void* nbuf, size_t nsiz); + + +/** + * Find the first occurrence of a sub pattern by case insensitive evaluation. + * @param hbuf the target pattern buffer. + * @param hsiz the size of the target pattern buffer. + * @param nbuf the sub pattern buffer. + * @param nsiz the size of the sub pattern buffer. + * @return the pointer to the beginning of the sub pattern in the target pattern buffer, or NULL + * if the sub pattern is not found. + */ +void* memimem(const void* hbuf, size_t hsiz, const void* nbuf, size_t nsiz); + + +/** + * Calculate the levenshtein distance of two regions in bytes. + * @param abuf the pointer to the region of one buffer. + * @param asiz the size of the region of one buffer. + * @param bbuf the pointer to the region of the other buffer. + * @param bsiz the size of the region of the other buffer. + * @return the levenshtein distance of two regions. + */ +size_t memdist(const void* abuf, size_t asiz, const void* bbuf, size_t bsiz); + + +/** + * Duplicate a string on memory. + * @param str the source string. + * @note Because the region of the return value is allocated with the the new[] operator, it + * should be released with the delete[] operator when it is no longer in use. + */ +char* strdup(const char* str); + + +/** + * Convert the letters of a string into upper case. + * @param str the string to convert. + * @return the string itself. + */ +char* strtoupper(char* str); + + +/** + * Convert the letters of a string into lower case. + * @param str the string to convert. + * @return the string itself. + */ +char* strtolower(char* str); + + +/** + * Cut space characters at head or tail of a string. + * @param str the string to convert. + * @return the string itself. + */ +char* strtrim(char* str); + + +/** + * Squeeze space characters in a string and trim it. + * @param str the string to convert. + * @return the string itself. + */ +char* strsqzspc(char* str); + + +/** + * Normalize space characters in a string and trim it. + * @param str the string to convert. + * @return the string itself. + */ +char* strnrmspc(char* str); + + +/** + * Compare two strings by case insensitive evaluation. + * @param astr a string. + * @param bstr the other string. + * @return positive if the former is big, negative if the latter is big, 0 if both are + * equivalent. + */ +int32_t stricmp(const char* astr, const char* bstr); + + +/** + * Find the first occurrence of a substring by case insensitive evaluation. + * @param hstr the target string. + * @param nstr the substring. + * @return the pointer to the beginning of the substring in the target string, or NULL if the + * substring is not found. + */ +char* stristr(const char* hstr, const char* nstr); + + +/** + * Check whether a string begins with a key. + * @param str the string. + * @param key the forward matching key string. + * @return true if the target string begins with the key, else, it is false. + */ +bool strfwm(const char* str, const char* key); + + +/** + * Check whether a string begins with a key by case insensitive evaluation. + * @param str the string. + * @param key the forward matching key string. + * @return true if the target string begins with the key, else, it is false. + */ +bool strifwm(const char* str, const char* key); + + +/** + * Check whether a string ends with a key. + * @param str the string. + * @param key the backward matching key string. + * @return true if the target string ends with the key, else, it is false. + */ +bool strbwm(const char* str, const char* key); + + +/** + * Check whether a string ends with a key by case insensitive evaluation. + * @param str the string. + * @param key the backward matching key string. + * @return true if the target string ends with the key, else, it is false. + */ +bool stribwm(const char* str, const char* key); + + +/** + * Get the number of characters in a UTF-8 string. + * @param str the UTF-8 string. + * @return the number of characters in the string. + */ +size_t strutflen(const char* str); + + +/** + * Convert a UTF-8 string into a UCS-4 array. + * @param src the source object. + * @param dest the destination object. It must have enough size. + * @param np the pointer to the variable into which the number of elements in the destination + * object is assgined. + */ +void strutftoucs(const char* src, uint32_t* dest, size_t* np); + + +/** + * Convert a UTF-8 string into a UCS-4 array. + * @param src the source object which does not have to be trailed by zero code. + * @param slen the length of the source object. + * @param dest the destination object. It must have enough size. + * @param np the pointer to the variable into which the number of elements in the destination + * object is assgined. + */ +void strutftoucs(const char* src, size_t slen, uint32_t* dest, size_t* np); + + +/** + * Convert a UCS-4 array into a UTF-8 string. + * @param src the source object. + * @param snum the number of elements in the source object. + * @param dest the destination object. It must have enough size. + * @return the size of the result string. + */ +size_t strucstoutf(const uint32_t* src, size_t snum, char* dest); + + +/** + * Calculate the levenshtein distance of two UTF-8 strings. + * @param astr one UTF-8 string. + * @param bstr the other UTF-8 string. + * @return the levenshtein distance of two arrays. + */ +size_t strutfdist(const char* astr, const char* bstr); + + +/** + * Calculate the levenshtein distance of two UCS-4 arrays. + * @param aary one UCS-4 array. + * @param anum the number of elements of one array. + * @param bary the other UCS-4 array. + * @param bnum the number of elements of the other array. + * @return the levenshtein distance of two arrays. + */ +size_t strucsdist(const uint32_t* aary, size_t anum, const uint32_t* bary, size_t bnum); + + +/** + * Allocate a region on memory. + * @param size the size of the region. + * @return the pointer to the allocated region. + */ +void* xmalloc(size_t size); + + +/** + * Allocate a nullified region on memory. + * @param nmemb the number of elements. + * @param size the size of each element. + * @return the pointer to the allocated region. + */ +void* xcalloc(size_t nmemb, size_t size); + + +/** + * Re-allocate a region on memory. + * @param ptr the pointer to the region. + * @param size the size of the region. + * @return the pointer to the re-allocated region. + */ +void* xrealloc(void* ptr, size_t size); + + +/** + * Free a region on memory. + * @param ptr the pointer to the region. + */ +void xfree(void* ptr); + + +/** + * Allocate a nullified region on mapped memory. + * @param size the size of the region. + * @return the pointer to the allocated region. It should be released with the memfree call. + */ +void* mapalloc(size_t size); + + +/** + * Free a region on mapped memory. + * @param ptr the pointer to the allocated region. + */ +void mapfree(void* ptr); + + +/** + * Get the time of day in seconds. + * @return the time of day in seconds. The accuracy is in microseconds. + */ +double time(); + + +/** + * Get the process ID. + * @return the process ID. + */ +int64_t getpid(); + + +/** + * Get the value of an environment variable. + * @return the value of the environment variable, or NULL on failure. + */ +const char* getenv(const char* name); + + +/** + * Get system information of the environment. + * @param strmap a string map to contain the result. + */ +void getsysinfo(std::map<std::string, std::string>* strmap); + + +/** + * Set the standard streams into the binary mode. + */ +void setstdiobin(); + + +/** + * Dummy test driver. + * @return always true. + */ +bool _dummytest(); + + +/** + * Convert a decimal string to an integer. + */ +inline int64_t atoi(const char* str) { + _assert_(str); + while (*str > '\0' && *str <= ' ') { + str++; + } + int32_t sign = 1; + int64_t num = 0; + if (*str == '-') { + str++; + sign = -1; + } else if (*str == '+') { + str++; + } + while (*str != '\0') { + if (*str < '0' || *str > '9') break; + num = num * 10 + *str - '0'; + str++; + } + return num * sign; +} + + +/** + * Convert a decimal string with a metric prefix to an integer. + */ +inline int64_t atoix(const char* str) { + _assert_(str); + while (*str > '\0' && *str <= ' ') { + str++; + } + int32_t sign = 1; + if (*str == '-') { + str++; + sign = -1; + } else if (*str == '+') { + str++; + } + long double num = 0; + while (*str != '\0') { + if (*str < '0' || *str > '9') break; + num = num * 10 + *str - '0'; + str++; + } + if (*str == '.') { + str++; + long double base = 10; + while (*str != '\0') { + if (*str < '0' || *str > '9') break; + num += (*str - '0') / base; + str++; + base *= 10; + } + } + num *= sign; + while (*str > '\0' && *str <= ' ') { + str++; + } + if (*str == 'k' || *str == 'K') { + num *= 1LL << 10; + } else if (*str == 'm' || *str == 'M') { + num *= 1LL << 20; + } else if (*str == 'g' || *str == 'G') { + num *= 1LL << 30; + } else if (*str == 't' || *str == 'T') { + num *= 1LL << 40; + } else if (*str == 'p' || *str == 'P') { + num *= 1LL << 50; + } else if (*str == 'e' || *str == 'E') { + num *= 1LL << 60; + } + if (num > INT64MAX) return INT64MAX; + if (num < INT64MIN) return INT64MIN; + return (int64_t)num; +} + + +/** + * Convert a hexadecimal string to an integer. + */ +inline int64_t atoih(const char* str) { + _assert_(str); + while (*str > '\0' && *str <= ' ') { + str++; + } + if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) { + str += 2; + } + int64_t num = 0; + while (true) { + if (*str >= '0' && *str <= '9') { + num = num * 0x10 + *str - '0'; + } else if (*str >= 'a' && *str <= 'f') { + num = num * 0x10 + *str - 'a' + 10; + } else if (*str >= 'A' && *str <= 'F') { + num = num * 0x10 + *str - 'A' + 10; + } else { + break; + } + str++; + } + return num; +} + + +/** + * Convert a decimal byte array to an integer. + */ +inline int64_t atoin(const char* ptr, size_t size) { + _assert_(ptr && size <= MEMMAXSIZ); + while (size > 0 && *ptr >= '\0' && *ptr <= ' ') { + ptr++; + size--; + } + int32_t sign = 1; + int64_t num = 0; + if (size > 0) { + if (*ptr == '-') { + ptr++; + size--; + sign = -1; + } else if (*ptr == '+') { + ptr++; + size--; + } + } + while (size > 0) { + if (*ptr < '0' || *ptr > '9') break; + num = num * 10 + *ptr - '0'; + ptr++; + size--; + } + return num * sign; +} + + +/** + * Convert a decimal string to a real number. + */ +inline double atof(const char* str) { + _assert_(str); + while (*str > '\0' && *str <= ' ') { + str++; + } + int32_t sign = 1; + if (*str == '-') { + str++; + sign = -1; + } else if (*str == '+') { + str++; + } + if ((str[0] == 'i' || str[0] == 'I') && (str[1] == 'n' || str[1] == 'N') && + (str[2] == 'f' || str[2] == 'F')) return HUGE_VAL * sign; + if ((str[0] == 'n' || str[0] == 'N') && (str[1] == 'a' || str[1] == 'A') && + (str[2] == 'n' || str[2] == 'N')) return nan(); + long double num = 0; + int32_t col = 0; + while (*str != '\0') { + if (*str < '0' || *str > '9') break; + num = num * 10 + *str - '0'; + str++; + if (num > 0) col++; + } + if (*str == '.') { + str++; + long double fract = 0.0; + long double base = 10; + while (col < 16 && *str != '\0') { + if (*str < '0' || *str > '9') break; + fract += (*str - '0') / base; + str++; + col++; + base *= 10; + } + num += fract; + } + if (*str == 'e' || *str == 'E') { + str++; + num *= std::pow((long double)10, (long double)atoi(str)); + } + return num * sign; +} + + +/** + * Convert a decimal byte array to a real number. + */ +inline double atofn(const char* ptr, size_t size) { + _assert_(ptr && size <= MEMMAXSIZ); + while (size > 0 && *ptr >= '\0' && *ptr <= ' ') { + ptr++; + size--; + } + int32_t sign = 1; + if (size > 0) { + if (*ptr == '-') { + ptr++; + size--; + sign = -1; + } else if (*ptr == '+') { + ptr++; + size--; + } + } + if (size > 2) { + if ((ptr[0] == 'i' || ptr[0] == 'I') && (ptr[1] == 'n' || ptr[1] == 'N') && + (ptr[2] == 'f' || ptr[2] == 'F')) return HUGE_VAL * sign; + if ((ptr[0] == 'n' || ptr[0] == 'N') && (ptr[1] == 'a' || ptr[1] == 'A') && + (ptr[2] == 'n' || ptr[2] == 'N')) return nan(); + } + long double num = 0; + int32_t col = 0; + while (size > 0) { + if (*ptr < '0' || *ptr > '9') break; + num = num * 10 + *ptr - '0'; + ptr++; + size--; + if (num > 0) col++; + } + if (size > 0 && *ptr == '.') { + ptr++; + size--; + long double fract = 0.0; + long double base = 10; + while (col < 16 && size > 0) { + if (*ptr < '0' || *ptr > '9') break; + fract += (*ptr - '0') / base; + ptr++; + size--; + col++; + base *= 10; + } + num += fract; + } + if (size > 0 && (*ptr == 'e' || *ptr == 'E')) { + ptr++; + size--; + num *= std::pow((long double)10, (long double)atoin(ptr, size)); + } + return num * sign; +} + + + +/** + * Normalize a 16-bit number in the native order into the network byte order. + */ +inline uint16_t hton16(uint16_t num) { + _assert_(true); + if (BIGEND) return num; + return ((num & 0x00ffU) << 8) | ((num & 0xff00U) >> 8); +} + + +/** + * Normalize a 32-bit number in the native order into the network byte order. + */ +inline uint32_t hton32(uint32_t num) { + _assert_(true); + if (BIGEND) return num; + return ((num & 0x000000ffUL) << 24) | ((num & 0x0000ff00UL) << 8) | \ + ((num & 0x00ff0000UL) >> 8) | ((num & 0xff000000UL) >> 24); +} + + +/** + * Normalize a 64-bit number in the native order into the network byte order. + */ +inline uint64_t hton64(uint64_t num) { + _assert_(true); + if (BIGEND) return num; + return ((num & 0x00000000000000ffULL) << 56) | ((num & 0x000000000000ff00ULL) << 40) | + ((num & 0x0000000000ff0000ULL) << 24) | ((num & 0x00000000ff000000ULL) << 8) | + ((num & 0x000000ff00000000ULL) >> 8) | ((num & 0x0000ff0000000000ULL) >> 24) | + ((num & 0x00ff000000000000ULL) >> 40) | ((num & 0xff00000000000000ULL) >> 56); +} + + +/** + * Denormalize a 16-bit number in the network byte order into the native order. + */ +inline uint16_t ntoh16(uint16_t num) { + _assert_(true); + return hton16(num); +} + + +/** + * Denormalize a 32-bit number in the network byte order into the native order. + */ +inline uint32_t ntoh32(uint32_t num) { + _assert_(true); + return hton32(num); +} + + +/** + * Denormalize a 64-bit number in the network byte order into the native order. + */ +inline uint64_t ntoh64(uint64_t num) { + _assert_(true); + return hton64(num); +} + + +/** + * Write a number in fixed length format into a buffer. + */ +inline void writefixnum(void* buf, uint64_t num, size_t width) { + _assert_(buf && width <= sizeof(int64_t)); + num = hton64(num); + std::memcpy(buf, (const char*)&num + sizeof(num) - width, width); +} + + +/** + * Read a number in fixed length format from a buffer. + */ +inline uint64_t readfixnum(const void* buf, size_t width) { + _assert_(buf && width <= sizeof(int64_t)); + uint64_t num = 0; + std::memcpy(&num, buf, width); + return ntoh64(num) >> ((sizeof(num) - width) * 8); +} + + +/** + * Write a number in variable length format into a buffer. + */ +inline size_t writevarnum(void* buf, uint64_t num) { + _assert_(buf); + unsigned char* wp = (unsigned char*)buf; + if (num < (1ULL << 7)) { + *(wp++) = num; + } else if (num < (1ULL << 14)) { + *(wp++) = (num >> 7) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 21)) { + *(wp++) = (num >> 14) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 28)) { + *(wp++) = (num >> 21) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 35)) { + *(wp++) = (num >> 28) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 42)) { + *(wp++) = (num >> 35) | 0x80; + *(wp++) = ((num >> 28) & 0x7f) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 49)) { + *(wp++) = (num >> 42) | 0x80; + *(wp++) = ((num >> 35) & 0x7f) | 0x80; + *(wp++) = ((num >> 28) & 0x7f) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 56)) { + *(wp++) = (num >> 49) | 0x80; + *(wp++) = ((num >> 42) & 0x7f) | 0x80; + *(wp++) = ((num >> 35) & 0x7f) | 0x80; + *(wp++) = ((num >> 28) & 0x7f) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else if (num < (1ULL << 63)) { + *(wp++) = (num >> 56) | 0x80; + *(wp++) = ((num >> 49) & 0x7f) | 0x80; + *(wp++) = ((num >> 42) & 0x7f) | 0x80; + *(wp++) = ((num >> 35) & 0x7f) | 0x80; + *(wp++) = ((num >> 28) & 0x7f) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } else { + *(wp++) = (num >> 63) | 0x80; + *(wp++) = ((num >> 56) & 0x7f) | 0x80; + *(wp++) = ((num >> 49) & 0x7f) | 0x80; + *(wp++) = ((num >> 42) & 0x7f) | 0x80; + *(wp++) = ((num >> 35) & 0x7f) | 0x80; + *(wp++) = ((num >> 28) & 0x7f) | 0x80; + *(wp++) = ((num >> 21) & 0x7f) | 0x80; + *(wp++) = ((num >> 14) & 0x7f) | 0x80; + *(wp++) = ((num >> 7) & 0x7f) | 0x80; + *(wp++) = num & 0x7f; + } + return wp - (unsigned char*)buf; +} + + +/** + * Read a number in variable length format from a buffer. + */ +inline size_t readvarnum(const void* buf, size_t size, uint64_t* np) { + _assert_(buf && size <= MEMMAXSIZ && np); + const unsigned char* rp = (const unsigned char*)buf; + const unsigned char* ep = rp + size; + uint64_t num = 0; + uint32_t c; + do { + if (rp >= ep) { + *np = 0; + return 0; + } + c = *rp; + num = (num << 7) + (c & 0x7f); + rp++; + } while (c >= 0x80); + *np = num; + return rp - (const unsigned char*)buf; +} + + +/** + * Check the size of variable length format of a number. + */ +inline size_t sizevarnum(uint64_t num) { + _assert_(true); + if (num < (1ULL << 7)) return 1; + if (num < (1ULL << 14)) return 2; + if (num < (1ULL << 21)) return 3; + if (num < (1ULL << 28)) return 4; + if (num < (1ULL << 35)) return 5; + if (num < (1ULL << 42)) return 6; + if (num < (1ULL << 49)) return 7; + if (num < (1ULL << 56)) return 8; + if (num < (1ULL << 63)) return 9; + return 10; +} + + +/** + * Get the hash value by MurMur hashing. + */ +inline uint64_t hashmurmur(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + const uint64_t mul = 0xc6a4a7935bd1e995ULL; + const int32_t rtt = 47; + uint64_t hash = 19780211ULL ^ (size * mul); + const unsigned char* rp = (const unsigned char*)buf; + while (size >= sizeof(uint64_t)) { + uint64_t num = ((uint64_t)rp[0] << 0) | ((uint64_t)rp[1] << 8) | + ((uint64_t)rp[2] << 16) | ((uint64_t)rp[3] << 24) | + ((uint64_t)rp[4] << 32) | ((uint64_t)rp[5] << 40) | + ((uint64_t)rp[6] << 48) | ((uint64_t)rp[7] << 56); + num *= mul; + num ^= num >> rtt; + num *= mul; + hash *= mul; + hash ^= num; + rp += sizeof(uint64_t); + size -= sizeof(uint64_t); + } + switch (size) { + case 7: hash ^= (uint64_t)rp[6] << 48; + case 6: hash ^= (uint64_t)rp[5] << 40; + case 5: hash ^= (uint64_t)rp[4] << 32; + case 4: hash ^= (uint64_t)rp[3] << 24; + case 3: hash ^= (uint64_t)rp[2] << 16; + case 2: hash ^= (uint64_t)rp[1] << 8; + case 1: hash ^= (uint64_t)rp[0]; + hash *= mul; + }; + hash ^= hash >> rtt; + hash *= mul; + hash ^= hash >> rtt; + return hash; +} + + +/** + * Get the hash value by FNV hashing. + */ +inline uint64_t hashfnv(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + uint64_t hash = 14695981039346656037ULL; + const unsigned char* rp = (unsigned char*)buf; + const unsigned char* ep = rp + size; + while (rp < ep) { + hash = (hash ^ *(rp++)) * 109951162811ULL; + } + return hash; +} + + +/** + * Get the hash value suitable for a file name. + */ +inline uint32_t hashpath(const void* buf, size_t size, char* obuf) { + _assert_(buf && size <= MEMMAXSIZ && obuf); + const unsigned char* rp = (const unsigned char*)buf; + uint32_t rv; + char* wp = obuf; + if (size <= 10) { + if (size > 0) { + const unsigned char* ep = rp + size; + while (rp < ep) { + int32_t num = *rp >> 4; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + num = *rp & 0x0f; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + rp++; + } + } else { + *(wp++) = '0'; + } + uint64_t hash = hashmurmur(buf, size); + rv = (((hash & 0xffff000000000000ULL) >> 48) | ((hash & 0x0000ffff00000000ULL) >> 16)) ^ + (((hash & 0x000000000000ffffULL) << 16) | ((hash & 0x00000000ffff0000ULL) >> 16)); + } else { + *(wp++) = 'f' + 1 + (size & 0x0f); + for (int32_t i = 0; i <= 6; i += 3) { + uint32_t num = (rp[i] ^ rp[i+1] ^ rp[i+2] ^ + rp[size-i-1] ^ rp[size-i-2] ^ rp[size-i-3]) % 36; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + } + uint64_t hash = hashmurmur(buf, size); + rv = (((hash & 0xffff000000000000ULL) >> 48) | ((hash & 0x0000ffff00000000ULL) >> 16)) ^ + (((hash & 0x000000000000ffffULL) << 16) | ((hash & 0x00000000ffff0000ULL) >> 16)); + uint64_t inc = hashfnv(buf, size); + inc = (((inc & 0xffff000000000000ULL) >> 48) | ((inc & 0x0000ffff00000000ULL) >> 16)) ^ + (((inc & 0x000000000000ffffULL) << 16) | ((inc & 0x00000000ffff0000ULL) >> 16)); + for (size_t i = 0; i < sizeof(hash); i++) { + uint32_t least = hash >> ((sizeof(hash) - 1) * 8); + uint64_t num = least >> 4; + if (inc & 0x01) num += 0x10; + inc = inc >> 1; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + num = least & 0x0f; + if (inc & 0x01) num += 0x10; + inc = inc >> 1; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + hash = hash << 8; + } + } + *wp = '\0'; + return rv; +} + + +/** + * Get a prime number nearby a number. + */ +inline uint64_t nearbyprime(uint64_t num) { + _assert_(true); + static uint64_t table[] = { + 2ULL, 3ULL, 5ULL, 7ULL, 11ULL, 13ULL, 17ULL, 19ULL, 23ULL, 29ULL, 31ULL, 37ULL, 41ULL, + 43ULL, 47ULL, 53ULL, 59ULL, 61ULL, 67ULL, 71ULL, 79ULL, 97ULL, 107ULL, 131ULL, 157ULL, + 181ULL, 223ULL, 257ULL, 307ULL, 367ULL, 431ULL, 521ULL, 613ULL, 727ULL, 863ULL, 1031ULL, + 1217ULL, 1451ULL, 1723ULL, 2053ULL, 2437ULL, 2897ULL, 3449ULL, 4099ULL, 4871ULL, 5801ULL, + 6899ULL, 8209ULL, 9743ULL, 11587ULL, 13781ULL, 16411ULL, 19483ULL, 23173ULL, 27581ULL, + 32771ULL, 38971ULL, 46349ULL, 55109ULL, 65537ULL, 77951ULL, 92681ULL, 110221ULL, 131101ULL, + 155887ULL, 185363ULL, 220447ULL, 262147ULL, 311743ULL, 370759ULL, 440893ULL, 524309ULL, + 623521ULL, 741457ULL, 881743ULL, 1048583ULL, 1246997ULL, 1482919ULL, 1763491ULL, + 2097169ULL, 2493949ULL, 2965847ULL, 3526987ULL, 4194319ULL, 4987901ULL, 5931641ULL, + 7053971ULL, 8388617ULL, 9975803ULL, 11863289ULL, 14107921ULL, 16777259ULL, 19951597ULL, + 23726569ULL, 28215809ULL, 33554467ULL, 39903197ULL, 47453149ULL, 56431657ULL, + 67108879ULL, 79806341ULL, 94906297ULL, 112863217ULL, 134217757ULL, 159612679ULL, + 189812533ULL, 225726419ULL, 268435459ULL, 319225391ULL, 379625083ULL, 451452839ULL, + 536870923ULL, 638450719ULL, 759250133ULL, 902905657ULL, 1073741827ULL, 1276901429ULL, + 1518500279ULL, 1805811341ULL, 2147483659ULL, 2553802871ULL, 3037000507ULL, 3611622607ULL, + 4294967311ULL, 5107605691ULL, 6074001001ULL, 7223245229ULL, 8589934609ULL, 10215211387ULL, + 12148002047ULL, 14446490449ULL, 17179869209ULL, 20430422699ULL, 24296004011ULL, + 28892980877ULL, 34359738421ULL, 40860845437ULL, 48592008053ULL, 57785961671ULL, + 68719476767ULL, 81721690807ULL, 97184016049ULL, 115571923303ULL, 137438953481ULL, + 163443381347ULL, 194368032011ULL, 231143846587ULL, 274877906951ULL, 326886762733ULL, + 388736063999ULL, 462287693167ULL, 549755813911ULL, 653773525393ULL, 777472128049ULL, + 924575386373ULL, 1099511627791ULL, 1307547050819ULL, 1554944255989ULL, 1849150772699ULL, + 2199023255579ULL, 2615094101561ULL, 3109888512037ULL, 3698301545321ULL, + 4398046511119ULL, 5230188203153ULL, 6219777023959ULL, 7396603090651ULL, + 8796093022237ULL, 10460376406273ULL, 12439554047911ULL, 14793206181251ULL, + 17592186044423ULL, 20920752812471ULL, 24879108095833ULL, 29586412362491ULL, + 35184372088891ULL, 41841505624973ULL, 49758216191633ULL, 59172824724919ULL, + 70368744177679ULL, 83683011249917ULL, 99516432383281ULL, 118345649449813ULL, + 140737488355333ULL, 167366022499847ULL, 199032864766447ULL, 236691298899683ULL, + 281474976710677ULL, 334732044999557ULL, 398065729532981ULL, 473382597799229ULL, + 562949953421381ULL, 669464089999087ULL, 796131459065743ULL, 946765195598473ULL, + 1125899906842679ULL, 1338928179998197ULL, 1592262918131449ULL, 1893530391196921ULL, + 2251799813685269ULL, 2677856359996339ULL, 3184525836262943ULL, 3787060782393821ULL, + 4503599627370517ULL, 5355712719992603ULL, 6369051672525833ULL, 7574121564787633ULL + }; + static const size_t tnum = sizeof(table) / sizeof(table[0]); + uint64_t* ub = std::lower_bound(table, table + tnum, num); + return ub == (uint64_t*)table + tnum ? num : *ub; +} + + +/** + * Get the quiet Not-a-Number value. + */ +inline double nan() { + _assert_(true); + return std::numeric_limits<double>::quiet_NaN(); +} + + +/** + * Get the positive infinity value. + */ +inline double inf() { + _assert_(true); + return std::numeric_limits<double>::infinity(); +} + + +/** + * Check a number is a Not-a-Number value. + */ +inline bool chknan(double num) { + _assert_(true); + return num != num; +} + + +/** + * Check a number is an infinity value. + */ +inline bool chkinf(double num) { + _assert_(true); + return num == inf() || num == -inf(); +} + + +/** + * Append a formatted string at the end of a string. + */ +inline void vstrprintf(std::string* dest, const char* format, va_list ap) { + _assert_(dest && format); + while (*format != '\0') { + if (*format == '%') { + char cbuf[NUMBUFSIZ]; + cbuf[0] = '%'; + size_t cbsiz = 1; + int32_t lnum = 0; + format++; + while (std::strchr("0123456789 .+-hlLz", *format) && *format != '\0' && + cbsiz < NUMBUFSIZ - 1) { + if (*format == 'l' || *format == 'L') lnum++; + cbuf[cbsiz++] = *(format++); + } + cbuf[cbsiz++] = *format; + cbuf[cbsiz] = '\0'; + switch (*format) { + case 's': { + const char* tmp = va_arg(ap, const char*); + if (tmp) { + dest->append(tmp); + } else { + dest->append("(null)"); + } + break; + } + case 'd': { + char tbuf[NUMBUFSIZ*4]; + size_t tsiz; + if (lnum >= 2) { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, long long)); + } else if (lnum >= 1) { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, long)); + } else { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, int)); + } + dest->append(tbuf, tsiz); + break; + } + case 'o': case 'u': case 'x': case 'X': case 'c': { + char tbuf[NUMBUFSIZ*4]; + size_t tsiz; + if (lnum >= 2) { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, unsigned long long)); + } else if (lnum >= 1) { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, unsigned long)); + } else { + tsiz = std::sprintf(tbuf, cbuf, va_arg(ap, unsigned int)); + } + dest->append(tbuf, tsiz); + break; + } + case 'e': case 'E': case 'f': case 'g': case 'G': { + char tbuf[NUMBUFSIZ*4]; + size_t tsiz; + if (lnum >= 1) { + tsiz = std::snprintf(tbuf, sizeof(tbuf), cbuf, va_arg(ap, long double)); + } else { + tsiz = std::snprintf(tbuf, sizeof(tbuf), cbuf, va_arg(ap, double)); + } + if (tsiz > sizeof(tbuf)) { + tbuf[sizeof(tbuf)-1] = '*'; + tsiz = sizeof(tbuf); + } + dest->append(tbuf, tsiz); + break; + } + case 'p': { + char tbuf[NUMBUFSIZ*4]; + size_t tsiz = std::sprintf(tbuf, "%p", va_arg(ap, void*)); + dest->append(tbuf, tsiz); + break; + } + case '%': { + dest->append("%", 1); + break; + } + } + } else { + dest->append(format, 1); + } + format++; + } +} + + +/** + * Append a formatted string at the end of a string. + */ +inline void strprintf(std::string* dest, const char* format, ...) { + _assert_(dest && format); + va_list ap; + va_start(ap, format); + vstrprintf(dest, format, ap); + va_end(ap); +} + + +/** + * Generate a formatted string on memory. + */ +inline std::string strprintf(const char* format, ...) { + _assert_(format); + std::string str; + va_list ap; + va_start(ap, format); + vstrprintf(&str, format, ap); + va_end(ap); + return str; +} + + +/** + * Split a string with a delimiter + */ +inline size_t strsplit(const std::string& str, char delim, std::vector<std::string>* elems) { + _assert_(elems); + elems->clear(); + std::string::const_iterator it = str.begin(); + std::string::const_iterator pv = it; + while (it != str.end()) { + if (*it == delim) { + std::string col(pv, it); + elems->push_back(col); + pv = it + 1; + } + ++it; + } + std::string col(pv, it); + elems->push_back(col); + return elems->size(); +} + + +/** + * Split a string with delimiters. + */ +inline size_t strsplit(const std::string& str, const std::string& delims, + std::vector<std::string>* elems) { + _assert_(elems); + elems->clear(); + std::string::const_iterator it = str.begin(); + std::string::const_iterator pv = it; + while (it != str.end()) { + while (delims.find(*it, 0) != std::string::npos) { + std::string col(pv, it); + elems->push_back(col); + pv = it + 1; + break; + } + ++it; + } + std::string col(pv, it); + elems->push_back(col); + return elems->size(); +} + + +/** + * Convert the letters of a string into upper case. + */ +inline std::string* strtoupper(std::string* str) { + _assert_(str); + size_t size = str->size(); + for (size_t i = 0; i < size; i++) { + int32_t c = (unsigned char)(*str)[i]; + if (c >= 'a' && c <= 'z') (*str)[i] = c - ('a' - 'A'); + } + return str; +} + + +/** + * Convert the letters of a string into lower case. + */ +inline std::string* strtolower(std::string* str) { + _assert_(str); + size_t size = str->size(); + for (size_t i = 0; i < size; i++) { + int32_t c = (unsigned char)(*str)[i]; + if (c >= 'A' && c <= 'Z') (*str)[i] = c + ('a' - 'A'); + } + return str; +} + + +/** + * Check whether a string begins with a key. + */ +inline bool strfwm(const std::string& str, const std::string& key) { + _assert_(true); + size_t ksiz = key.size(); + if (ksiz > str.size()) return false; + return !std::memcmp(str.data(), key.data(), ksiz); +} + + +/** + * Check whether a string ends with a key. + */ +inline bool strbwm(const std::string& str, const std::string& key) { + _assert_(true); + size_t ksiz = key.size(); + if (ksiz > str.size()) return false; + return !std::memcmp(str.data() + str.size() - ksiz, key.data(), ksiz); +} + + +/** + * Cut space characters at head or tail of a string. + */ +inline std::string* strtrim(std::string* str) { + _assert_(str); + size_t size = str->size(); + size_t wi = 0; + size_t li = 0; + for (size_t i = 0; i < size; i++) { + int32_t c = (unsigned char)(*str)[i]; + if (c >= '\0' && c <= ' ') { + if (wi > 0) (*str)[wi++] = c; + } else { + (*str)[wi++] = c; + li = wi; + } + } + str->resize(li); + return str; +} + + +/** + * Convert a UTF-8 string into a UCS-4 array. + */ +inline void strutftoucs(const std::string& src, std::vector<uint32_t>* dest) { + _assert_(dest); + dest->reserve(dest->size() + src.size()); + size_t size = src.size(); + size_t ri = 0; + while (ri < size) { + uint32_t c = (unsigned char)src[ri]; + if (c < 0x80) { + dest->push_back(c); + } else if (c < 0xe0) { + if (c >= 0xc0 && ri + 1 < size) { + c = ((c & 0x1f) << 6) | (src[ri+1] & 0x3f); + if (c >= 0x80) dest->push_back(c); + ri++; + } + } else if (c < 0xf0) { + if (ri + 2 < size) { + c = ((c & 0x0f) << 12) | ((src[ri+1] & 0x3f) << 6) | (src[ri+2] & 0x3f); + if (c >= 0x800) dest->push_back(c); + ri += 2; + } + } else if (c < 0xf8) { + if (ri + 3 < size) { + c = ((c & 0x07) << 18) | ((src[ri+1] & 0x3f) << 12) | ((src[ri+2] & 0x3f) << 6) | + (src[ri+3] & 0x3f); + if (c >= 0x10000) dest->push_back(c); + ri += 3; + } + } else if (c < 0xfc) { + if (ri + 4 < size) { + c = ((c & 0x03) << 24) | ((src[ri+1] & 0x3f) << 18) | ((src[ri+2] & 0x3f) << 12) | + ((src[ri+3] & 0x3f) << 6) | (src[ri+4] & 0x3f); + if (c >= 0x200000) dest->push_back(c); + ri += 4; + } + } else if (c < 0xfe) { + if (ri + 5 < size) { + c = ((c & 0x01) << 30) | ((src[ri+1] & 0x3f) << 24) | ((src[ri+2] & 0x3f) << 18) | + ((src[ri+3] & 0x3f) << 12) | ((src[ri+4] & 0x3f) << 6) | (src[ri+5] & 0x3f); + if (c >= 0x4000000) dest->push_back(c); + ri += 5; + } + } + ri++; + } +} + + +/** + * Convert a UCS-4 array into a UTF-8 string. + */ +inline void strucstoutf(const std::vector<uint32_t>& src, std::string* dest) { + _assert_(dest); + dest->reserve(dest->size() + src.size() * 3); + std::vector<uint32_t>::const_iterator it = src.begin(); + std::vector<uint32_t>::const_iterator itend = src.end(); + while (it != itend) { + uint32_t c = *it; + if (c < 0x80) { + dest->append(1, c); + } else if (c < 0x800) { + dest->append(1, 0xc0 | (c >> 6)); + dest->append(1, 0x80 | (c & 0x3f)); + } else if (c < 0x10000) { + dest->append(1, 0xe0 | (c >> 12)); + dest->append(1, 0x80 | ((c & 0xfff) >> 6)); + dest->append(1, 0x80 | (c & 0x3f)); + } else if (c < 0x200000) { + dest->append(1, 0xf0 | (c >> 18)); + dest->append(1, 0x80 | ((c & 0x3ffff) >> 12)); + dest->append(1, 0x80 | ((c & 0xfff) >> 6)); + dest->append(1, 0x80 | (c & 0x3f)); + } else if (c < 0x4000000) { + dest->append(1, 0xf8 | (c >> 24)); + dest->append(1, 0x80 | ((c & 0xffffff) >> 18)); + dest->append(1, 0x80 | ((c & 0x3ffff) >> 12)); + dest->append(1, 0x80 | ((c & 0xfff) >> 6)); + dest->append(1, 0x80 | (c & 0x3f)); + } else if (c < 0x80000000) { + dest->append(1, 0xfc | (c >> 30)); + dest->append(1, 0x80 | ((c & 0x3fffffff) >> 24)); + dest->append(1, 0x80 | ((c & 0xffffff) >> 18)); + dest->append(1, 0x80 | ((c & 0x3ffff) >> 12)); + dest->append(1, 0x80 | ((c & 0xfff) >> 6)); + dest->append(1, 0x80 | (c & 0x3f)); + } + ++it; + } +} + + +/** + * Serialize a string vector object into a string object. + */ +inline void strvecdump(const std::vector<std::string>& src, std::string* dest) { + _assert_(dest); + std::vector<std::string>::const_iterator it = src.begin(); + std::vector<std::string>::const_iterator itend = src.end(); + size_t dsiz = 1; + while (it != itend) { + dsiz += 2 + it->size(); + ++it; + } + dest->reserve(dest->size() + dsiz); + it = src.begin(); + while (it != itend) { + char nbuf[NUMBUFSIZ]; + size_t nsiz = writevarnum(nbuf, it->size()); + dest->append(nbuf, nsiz); + dest->append(it->data(), it->size()); + ++it; + } +} + + +/** + * Deserialize a string object into a string vector object. + */ +inline void strvecload(const std::string& src, std::vector<std::string>* dest) { + _assert_(dest); + const char* rp = src.data(); + size_t size = src.size(); + while (size > 0) { + uint64_t vsiz; + size_t step = readvarnum(rp, size, &vsiz); + rp += step; + size -= step; + if (vsiz > size) break; + dest->push_back(std::string(rp, vsiz)); + rp += vsiz; + size -= vsiz; + } +} + + +/** + * Serialize a string vector object into a string object. + */ +inline void strmapdump(const std::map<std::string, std::string>& src, std::string* dest) { + _assert_(dest); + std::map<std::string, std::string>::const_iterator it = src.begin(); + std::map<std::string, std::string>::const_iterator itend = src.end(); + size_t dsiz = 1; + while (it != itend) { + dsiz += 4 + it->first.size() + it->second.size(); + ++it; + } + dest->reserve(dest->size() + dsiz); + it = src.begin(); + while (it != itend) { + char nbuf[NUMBUFSIZ*2]; + size_t nsiz = writevarnum(nbuf, it->first.size()); + nsiz += writevarnum(nbuf + nsiz, it->second.size()); + dest->append(nbuf, nsiz); + dest->append(it->first.data(), it->first.size()); + dest->append(it->second.data(), it->second.size()); + ++it; + } +} + + +/** + * Deserialize a string object into a string map object. + */ +inline void strmapload(const std::string& src, std::map<std::string, std::string>* dest) { + _assert_(dest); + const char* rp = src.data(); + int64_t size = src.size(); + while (size > 1) { + uint64_t ksiz; + size_t step = readvarnum(rp, size, &ksiz); + rp += step; + size -= step; + if (size < 1) break; + uint64_t vsiz; + step = readvarnum(rp, size, &vsiz); + rp += step; + size -= step; + int64_t rsiz = ksiz + vsiz; + if (rsiz > size) break; + (*dest)[std::string(rp, ksiz)] = std::string(rp + ksiz, vsiz); + rp += rsiz; + size -= rsiz; + } +} + + +/** + * Encode a serial object by hexadecimal encoding. + */ +inline char* hexencode(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + const unsigned char* rp = (const unsigned char*)buf; + char* zbuf = new char[size*2+1]; + char* wp = zbuf; + for (const unsigned char* ep = rp + size; rp < ep; rp++) { + int32_t num = *rp >> 4; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + num = *rp & 0x0f; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + } + *wp = '\0'; + return zbuf; +} + + +/** + * Decode a string encoded by hexadecimal encoding. + */ +inline char* hexdecode(const char* str, size_t* sp) { + _assert_(str && sp); + char* zbuf = new char[std::strlen(str)+1]; + char* wp = zbuf; + while (true) { + while (*str > '\0' && *str <= ' ') { + str++; + } + int32_t num = 0; + int32_t c = *(str++); + if (c >= '0' && c <= '9') { + num = c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = c - 'A' + 10; + } else if (c == '\0') { + break; + } + c = *(str++); + if (c >= '0' && c <= '9') { + num = num * 0x10 + c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = num * 0x10 + c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = num * 0x10 + c - 'A' + 10; + } else if (c == '\0') { + *(wp++) = num; + break; + } + *(wp++) = num; + } + *wp = '\0'; + *sp = wp - zbuf; + return zbuf; +} + + +/** + * Encode a serial object by URL encoding. + */ +inline char* urlencode(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + const unsigned char* rp = (const unsigned char*)buf; + char* zbuf = new char[size*3+1]; + char* wp = zbuf; + for (const unsigned char* ep = rp + size; rp < ep; rp++) { + int32_t c = *rp; + if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || + (c >= '0' && c <= '9') || (c != '\0' && std::strchr("_-.~", c))) { + *(wp++) = c; + } else { + *(wp++) = '%'; + int32_t num = c >> 4; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + num = c & 0x0f; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'a' + num - 10; + } + } + } + *wp = '\0'; + return zbuf; +} + + +/** + * Decode a string encoded by URL encoding. + */ +inline char* urldecode(const char* str, size_t* sp) { + _assert_(str && sp); + size_t zsiz = std::strlen(str); + char* zbuf = new char[zsiz+1]; + char* wp = zbuf; + const char* ep = str + zsiz; + while (str < ep) { + int32_t c = *str; + if (c == '%') { + int32_t num = 0; + if (++str >= ep) break; + c = *str; + if (c >= '0' && c <= '9') { + num = c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = c - 'A' + 10; + } + if (++str >= ep) break; + c = *str; + if (c >= '0' && c <= '9') { + num = num * 0x10 + c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = num * 0x10 + c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = num * 0x10 + c - 'A' + 10; + } + *(wp++) = num; + str++; + } else if (c == '+') { + *(wp++) = ' '; + str++; + } else if (c <= ' ' || c == 0x7f) { + str++; + } else { + *(wp++) = c; + str++; + } + } + *wp = '\0'; + *sp = wp - zbuf; + return zbuf; +} + + +/** + * Encode a serial object by Quoted-printable encoding. + */ +inline char* quoteencode(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + const unsigned char* rp = (const unsigned char*)buf; + char* zbuf = new char[size*3+1]; + char* wp = zbuf; + for (const unsigned char* ep = rp + size; rp < ep; rp++) { + int32_t c = *rp; + if (c == '=' || c < ' ' || c > 0x7e) { + *(wp++) = '='; + int32_t num = c >> 4; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'A' + num - 10; + } + num = c & 0x0f; + if (num < 10) { + *(wp++) = '0' + num; + } else { + *(wp++) = 'A' + num - 10; + } + } else { + *(wp++) = c; + } + } + *wp = '\0'; + return zbuf; +} + + +/** + * Decode a string encoded by Quoted-printable encoding. + */ +inline char* quotedecode(const char* str, size_t* sp) { + _assert_(str && sp); + size_t zsiz = std::strlen(str); + char* zbuf = new char[zsiz+1]; + char* wp = zbuf; + const char* ep = str + zsiz; + while (str < ep) { + int32_t c = *str; + if (c == '=') { + int32_t num = 0; + if (++str >= ep) break; + c = *str; + if (c == '\r') { + if (++str >= ep) break; + if (*str == '\n') str++; + } else if (c == '\n') { + str++; + } else { + if (c >= '0' && c <= '9') { + num = c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = c - 'A' + 10; + } + if (++str >= ep) break; + c = *str; + if (c >= '0' && c <= '9') { + num = num * 0x10 + c - '0'; + } else if (c >= 'a' && c <= 'f') { + num = num * 0x10 + c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + num = num * 0x10 + c - 'A' + 10; + } + *(wp++) = num; + str++; + } + } else if (c < ' ' || c == 0x7f) { + str++; + } else { + *(wp++) = c; + str++; + } + } + *wp = '\0'; + *sp = wp - zbuf; + return zbuf; +} + + +/** + * Encode a serial object by Base64 encoding. + */ +inline char* baseencode(const void* buf, size_t size) { + _assert_(buf && size <= MEMMAXSIZ); + const char* tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + const unsigned char* rp = (const unsigned char*)buf; + char* zbuf = new char[size*4/3+5]; + char* wp = zbuf; + for (size_t i = 0; i < size; i += 3) { + switch (size - i) { + case 1: { + *(wp++) = tbl[rp[0] >> 2]; + *(wp++) = tbl[(rp[0] & 3) << 4]; + *(wp++) = '='; + *(wp++) = '='; + break; + } + case 2: { + *(wp++) = tbl[rp[0] >> 2]; + *(wp++) = tbl[((rp[0] & 3) << 4) + (rp[1] >> 4)]; + *(wp++) = tbl[(rp[1] & 0xf) << 2]; + *(wp++) = '='; + break; + } + default: { + *(wp++) = tbl[rp[0] >> 2]; + *(wp++) = tbl[((rp[0] & 3) << 4) + (rp[1] >> 4)]; + *(wp++) = tbl[((rp[1] & 0xf) << 2) + (rp[2] >> 6)]; + *(wp++) = tbl[rp[2] & 0x3f]; + break; + } + } + rp += 3; + } + *wp = '\0'; + return zbuf; +} + + +/** + * Decode a string encoded by Base64 encoding. + */ +inline char* basedecode(const char* str, size_t* sp) { + _assert_(str && sp); + size_t bpos = 0; + size_t eqcnt = 0; + size_t len = std::strlen(str); + unsigned char* zbuf = new unsigned char[len+4]; + unsigned char* wp = zbuf; + size_t zsiz = 0; + while (bpos < len && eqcnt == 0) { + size_t bits = 0; + size_t i; + for (i = 0; bpos < len && i < 4; bpos++) { + if (str[bpos] >= 'A' && str[bpos] <= 'Z') { + bits = (bits << 6) | (str[bpos] - 'A'); + i++; + } else if (str[bpos] >= 'a' && str[bpos] <= 'z') { + bits = (bits << 6) | (str[bpos] - 'a' + 26); + i++; + } else if (str[bpos] >= '0' && str[bpos] <= '9') { + bits = (bits << 6) | (str[bpos] - '0' + 52); + i++; + } else if (str[bpos] == '+') { + bits = (bits << 6) | 62; + i++; + } else if (str[bpos] == '/') { + bits = (bits << 6) | 63; + i++; + } else if (str[bpos] == '=') { + bits <<= 6; + i++; + eqcnt++; + } + } + if (i == 0 && bpos >= len) continue; + switch (eqcnt) { + case 0: { + *wp++ = (bits >> 16) & 0xff; + *wp++ = (bits >> 8) & 0xff; + *wp++ = bits & 0xff; + zsiz += 3; + break; + } + case 1: { + *wp++ = (bits >> 16) & 0xff; + *wp++ = (bits >> 8) & 0xff; + zsiz += 2; + break; + } + case 2: { + *wp++ = (bits >> 16) & 0xff; + zsiz += 1; + break; + } + } + } + zbuf[zsiz] = '\0'; + *sp = zsiz; + return (char*)zbuf; +} + + +/** + * Cipher or decipher a serial object with the Arcfour stream cipher. + */ +inline void arccipher(const void* ptr, size_t size, const void* kbuf, size_t ksiz, void* obuf) { + _assert_(ptr && size <= MEMMAXSIZ && kbuf && ksiz <= MEMMAXSIZ && obuf); + if (ksiz < 1) { + kbuf = ""; + ksiz = 1; + } + uint32_t sbox[0x100], kbox[0x100]; + for (int32_t i = 0; i < 0x100; i++) { + sbox[i] = i; + kbox[i] = ((uint8_t*)kbuf)[i%ksiz]; + } + uint32_t sidx = 0; + for (int32_t i = 0; i < 0x100; i++) { + sidx = (sidx + sbox[i] + kbox[i]) & 0xff; + uint32_t swap = sbox[i]; + sbox[i] = sbox[sidx]; + sbox[sidx] = swap; + } + uint32_t x = 0; + uint32_t y = 0; + for (size_t i = 0; i < size; i++) { + x = (x + 1) & 0xff; + y = (y + sbox[x]) & 0xff; + uint32_t swap = sbox[x]; + sbox[x] = sbox[y]; + sbox[y] = swap; + ((uint8_t*)obuf)[i] = ((uint8_t*)ptr)[i] ^ sbox[(sbox[x]+sbox[y])&0xff]; + } +} + + +/** + * Duplicate a region on memory. + */ +inline char* memdup(const char* ptr, size_t size) { + _assert_(ptr && size <= MEMMAXSIZ); + char* obuf = new char[size+1]; + std::memcpy(obuf, ptr, size); + return obuf; +} + + +/** + * Compare two regions by case insensitive evaluation. + */ +inline int32_t memicmp(const void* abuf, const void* bbuf, size_t size) { + _assert_(abuf && bbuf && size <= MEMMAXSIZ); + const unsigned char* ap = (unsigned char*)abuf; + const unsigned char* bp = (unsigned char*)bbuf; + const unsigned char* ep = ap + size; + while (ap < ep) { + int32_t ac = *ap; + if (ac >= 'A' && ac <= 'Z') ac += 'a' - 'A'; + int32_t bc = *bp; + if (bc >= 'A' && bc <= 'Z') bc += 'a' - 'A'; + if (ac != bc) return ac - bc; + ap++; + bp++; + } + return 0; +} + + +/** + * Find the first occurrence of a sub pattern. + */ +inline void* memmem(const void* hbuf, size_t hsiz, const void* nbuf, size_t nsiz) { + _assert_(hbuf && hsiz <= MEMMAXSIZ && nbuf && nsiz <= MEMMAXSIZ); + if (nsiz < 1) return (void*)hbuf; + if (hsiz < nsiz) return NULL; + int32_t tc = *(unsigned char*)nbuf; + const unsigned char* rp = (unsigned char*)hbuf; + const unsigned char* ep = (unsigned char*)hbuf + hsiz - nsiz; + while (rp <= ep) { + if (*rp == tc) { + bool hit = true; + for (size_t i = 1; i < nsiz; i++) { + if (rp[i] != ((unsigned char*)nbuf)[i]) { + hit = false; + break; + } + } + if (hit) return (void*)rp; + } + rp++; + } + return NULL; +} + + +/** + * Find the first occurrence of a sub pattern by case insensitive evaluation. + */ +inline void* memimem(const void* hbuf, size_t hsiz, const void* nbuf, size_t nsiz) { + _assert_(hbuf && hsiz <= MEMMAXSIZ && nbuf && nsiz <= MEMMAXSIZ); + if (nsiz < 1) return (void*)hbuf; + if (hsiz < nsiz) return NULL; + int32_t tc = *(unsigned char*)nbuf; + if (tc >= 'A' && tc <= 'Z') tc += 'a' - 'A'; + const unsigned char* rp = (unsigned char*)hbuf; + const unsigned char* ep = (unsigned char*)hbuf + hsiz - nsiz; + while (rp <= ep) { + int32_t cc = *rp; + if (cc >= 'A' && cc <= 'Z') cc += 'a' - 'A'; + if (cc == tc) { + bool hit = true; + for (size_t i = 1; i < nsiz; i++) { + int32_t hc = rp[i]; + if (hc >= 'A' && hc <= 'Z') hc += 'a' - 'A'; + int32_t nc = ((unsigned char*)nbuf)[i]; + if (nc >= 'A' && nc <= 'Z') nc += 'a' - 'A'; + if (hc != nc) { + hit = false; + break; + } + } + if (hit) return (void*)rp; + } + rp++; + } + return NULL; +} + + +/** + * Duplicate a string on memory. + */ +inline char* strdup(const char* str) { + _assert_(str); + size_t size = std::strlen(str); + char* obuf = memdup(str, size); + obuf[size] = '\0'; + return obuf; +} + + +/** + * Convert the letters of a string into upper case. + */ +inline char* strtoupper(char* str) { + _assert_(str); + char* wp = str; + while (*wp != '\0') { + if (*wp >= 'a' && *wp <= 'z') *wp -= 'a' - 'A'; + wp++; + } + return str; +} + + +/** + * Convert the letters of a string into lower case. + */ +inline char* strtolower(char* str) { + _assert_(str); + char* wp = str; + while (*wp != '\0') { + if (*wp >= 'A' && *wp <= 'Z') *wp += 'a' - 'A'; + wp++; + } + return str; +} + + +/** + * Cut space characters at head or tail of a string. + */ +inline char* strtrim(char* str) { + _assert_(str); + const char* rp = str; + char* wp = str; + bool head = true; + while (*rp != '\0') { + if (*rp > '\0' && *rp <= ' ') { + if (!head) *(wp++) = *rp; + } else { + *(wp++) = *rp; + head = false; + } + rp++; + } + *wp = '\0'; + while (wp > str && wp[-1] > '\0' && wp[-1] <= ' ') { + *(--wp) = '\0'; + } + return str; +} + + +/** + * Squeeze space characters in a string and trim it. + */ +inline char* strsqzspc(char* str) { + _assert_(str); + const char* rp = str; + char* wp = str; + bool spc = true; + while (*rp != '\0') { + if (*rp > '\0' && *rp <= ' ') { + if (!spc) *(wp++) = *rp; + spc = true; + } else { + *(wp++) = *rp; + spc = false; + } + rp++; + } + *wp = '\0'; + for (wp--; wp >= str; wp--) { + if (*wp > '\0' && *wp <= ' ') { + *wp = '\0'; + } else { + break; + } + } + return str; +} + + +/** + * Normalize space characters in a string and trim it. + */ +inline char* strnrmspc(char* str) { + _assert_(str); + const char* rp = str; + char* wp = str; + bool spc = true; + while (*rp != '\0') { + if ((*rp > '\0' && *rp <= ' ') || *rp == 0x7f) { + if (!spc) *(wp++) = ' '; + spc = true; + } else { + *(wp++) = *rp; + spc = false; + } + rp++; + } + *wp = '\0'; + for (wp--; wp >= str; wp--) { + if (*wp == ' ') { + *wp = '\0'; + } else { + break; + } + } + return str; +} + + + +/** + * Compare two strings by case insensitive evaluation. + */ +inline int32_t stricmp(const char* astr, const char* bstr) { + _assert_(astr && bstr); + while (*astr != '\0') { + if (*bstr == '\0') return 1; + int32_t ac = *(unsigned char*)astr; + if (ac >= 'A' && ac <= 'Z') ac += 'a' - 'A'; + int32_t bc = *(unsigned char*)bstr; + if (bc >= 'A' && bc <= 'Z') bc += 'a' - 'A'; + if (ac != bc) return ac - bc; + astr++; + bstr++; + } + return (*bstr == '\0') ? 0 : -1; +} + + +/** + * Find the first occurrence of a substring by case insensitive evaluation. + */ +inline char* stristr(const char* hstr, const char* nstr) { + _assert_(hstr && nstr); + if (*nstr == '\0') return (char*)hstr; + int32_t tc = *nstr; + if (tc >= 'A' && tc <= 'Z') tc += 'a' - 'A'; + const char* rp = hstr; + while (*rp != '\0') { + int32_t cc = *rp; + if (cc >= 'A' && cc <= 'Z') cc += 'a' - 'A'; + if (cc == tc) { + bool hit = true; + for (size_t i = 1; nstr[i] != '\0'; i++) { + int32_t hc = rp[i]; + if (hc >= 'A' && hc <= 'Z') hc += 'a' - 'A'; + int32_t nc = nstr[i]; + if (nc >= 'A' && nc <= 'Z') nc += 'a' - 'A'; + if (hc != nc) { + hit = false; + break; + } + } + if (hit) return (char*)rp; + } + rp++; + } + return NULL; +} + + +/** + * Check whether a string begins with a key. + */ +inline bool strfwm(const char* str, const char* key) { + _assert_(str && key); + while (*key != '\0') { + if (*str != *key || *str == '\0') return false; + key++; + str++; + } + return true; +} + + +/** + * Check whether a string begins with a key by case insensitive evaluation. + */ +inline bool strifwm(const char* str, const char* key) { + _assert_(str && key); + while (*key != '\0') { + if (*str == '\0') return false; + int32_t sc = *str; + if (sc >= 'A' && sc <= 'Z') sc += 'a' - 'A'; + int32_t kc = *key; + if (kc >= 'A' && kc <= 'Z') kc += 'a' - 'A'; + if (sc != kc) return false; + key++; + str++; + } + return true; +} + + +/** + * Check whether a string ends with a key. + */ +inline bool strbwm(const char* str, const char* key) { + _assert_(str && key); + size_t slen = std::strlen(str); + size_t klen = std::strlen(key); + for (size_t i = 1; i <= klen; i++) { + if (i > slen || str[slen-i] != key[klen-i]) return false; + } + return true; +} + + +/** + * Check whether a string ends with a key by case insensitive evaluation. + */ +inline bool stribwm(const char* str, const char* key) { + _assert_(str && key); + size_t slen = std::strlen(str); + size_t klen = std::strlen(key); + for (size_t i = 1; i <= klen; i++) { + if (i > slen) return false; + int32_t sc = str[slen-i]; + if (sc >= 'A' && sc <= 'Z') sc += 'a' - 'A'; + int32_t kc = key[klen-i]; + if (kc >= 'A' && kc <= 'Z') kc += 'a' - 'A'; + if (sc != kc) return false; + } + return true; +} + + +/** + * Get the number of characters in a UTF-8 string. + */ +inline size_t strutflen(const char* str) { + _assert_(str); + size_t len = 0; + while (*str != '\0') { + len += (*(unsigned char*)str & 0xc0) != 0x80; + str++; + } + return len; +} + + +/** + * Convert a UTF-8 string into a UCS-4 array. + */ +inline void strutftoucs(const char* src, uint32_t* dest, size_t* np) { + _assert_(src && dest && np); + const unsigned char* rp = (unsigned char*)src; + size_t dnum = 0; + while (*rp != '\0') { + uint32_t c = *rp; + if (c < 0x80) { + dest[dnum++] = c; + } else if (c < 0xe0) { + if (rp[1] != '\0') { + c = ((c & 0x1f) << 6) | (rp[1] & 0x3f); + if (c >= 0x80) dest[dnum++] = c; + rp++; + } + } else if (c < 0xf0) { + if (rp[1] != '\0' && rp[2] != '\0') { + c = ((c & 0x0f) << 12) | ((rp[1] & 0x3f) << 6) | (rp[2] & 0x3f); + if (c >= 0x800) dest[dnum++] = c; + rp += 2; + } + } else if (c < 0xf8) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0') { + c = ((c & 0x07) << 18) | ((rp[1] & 0x3f) << 12) | ((rp[2] & 0x3f) << 6) | + (rp[3] & 0x3f); + if (c >= 0x10000) dest[dnum++] = c; + rp += 3; + } + } else if (c < 0xfc) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0' && rp[4] != '\0') { + c = ((c & 0x03) << 24) | ((rp[1] & 0x3f) << 18) | ((rp[2] & 0x3f) << 12) | + ((rp[3] & 0x3f) << 6) | (rp[4] & 0x3f); + if (c >= 0x200000) dest[dnum++] = c; + rp += 4; + } + } else if (c < 0xfe) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0' && rp[4] != '\0' && rp[5] != '\0') { + c = ((c & 0x01) << 30) | ((rp[1] & 0x3f) << 24) | ((rp[2] & 0x3f) << 18) | + ((rp[3] & 0x3f) << 12) | ((rp[4] & 0x3f) << 6) | (rp[5] & 0x3f); + if (c >= 0x4000000) dest[dnum++] = c; + rp += 5; + } + } + rp++; + } + *np = dnum; +} + + +/** + * Convert a UTF-8 string into a UCS-4 array. + */ +inline void strutftoucs(const char* src, size_t slen, uint32_t* dest, size_t* np) { + _assert_(src && slen <= MEMMAXSIZ && dest && np); + const unsigned char* rp = (unsigned char*)src; + const unsigned char* ep = rp + slen; + size_t dnum = 0; + while (rp < ep) { + uint32_t c = *rp; + if (c < 0x80) { + dest[dnum++] = c; + } else if (c < 0xe0) { + if (rp[1] != '\0') { + c = ((c & 0x1f) << 6) | (rp[1] & 0x3f); + if (c >= 0x80) dest[dnum++] = c; + rp++; + } + } else if (c < 0xf0) { + if (rp[1] != '\0' && rp[2] != '\0') { + c = ((c & 0x0f) << 12) | ((rp[1] & 0x3f) << 6) | (rp[2] & 0x3f); + if (c >= 0x800) dest[dnum++] = c; + rp += 2; + } + } else if (c < 0xf8) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0') { + c = ((c & 0x07) << 18) | ((rp[1] & 0x3f) << 12) | ((rp[2] & 0x3f) << 6) | + (rp[3] & 0x3f); + if (c >= 0x10000) dest[dnum++] = c; + rp += 3; + } + } else if (c < 0xfc) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0' && rp[4] != '\0') { + c = ((c & 0x03) << 24) | ((rp[1] & 0x3f) << 18) | ((rp[2] & 0x3f) << 12) | + ((rp[3] & 0x3f) << 6) | (rp[4] & 0x3f); + if (c >= 0x200000) dest[dnum++] = c; + rp += 4; + } + } else if (c < 0xfe) { + if (rp[1] != '\0' && rp[2] != '\0' && rp[3] != '\0' && rp[4] != '\0' && rp[5] != '\0') { + c = ((c & 0x01) << 30) | ((rp[1] & 0x3f) << 24) | ((rp[2] & 0x3f) << 18) | + ((rp[3] & 0x3f) << 12) | ((rp[4] & 0x3f) << 6) | (rp[5] & 0x3f); + if (c >= 0x4000000) dest[dnum++] = c; + rp += 5; + } + } + rp++; + } + *np = dnum; +} + + +/** + * Convert a UCS-4 array into a UTF-8 string. + */ +inline size_t strucstoutf(const uint32_t* src, size_t snum, char* dest) { + _assert_(src && snum <= MEMMAXSIZ && dest); + const uint32_t* ep = src + snum; + unsigned char* wp = (unsigned char*)dest; + while (src < ep) { + uint32_t c = *src; + if (c < 0x80) { + *(wp++) = c; + } else if (c < 0x800) { + *(wp++) = 0xc0 | (c >> 6); + *(wp++) = 0x80 | (c & 0x3f); + } else if (c < 0x10000) { + *(wp++) = 0xe0 | (c >> 12); + *(wp++) = 0x80 | ((c & 0xfff) >> 6); + *(wp++) = 0x80 | (c & 0x3f); + } else if (c < 0x200000) { + *(wp++) = 0xf0 | (c >> 18); + *(wp++) = 0x80 | ((c & 0x3ffff) >> 12); + *(wp++) = 0x80 | ((c & 0xfff) >> 6); + *(wp++) = 0x80 | (c & 0x3f); + } else if (c < 0x4000000) { + *(wp++) = 0xf8 | (c >> 24); + *(wp++) = 0x80 | ((c & 0xffffff) >> 18); + *(wp++) = 0x80 | ((c & 0x3ffff) >> 12); + *(wp++) = 0x80 | ((c & 0xfff) >> 6); + *(wp++) = 0x80 | (c & 0x3f); + } else if (c < 0x80000000) { + *(wp++) = 0xfc | (c >> 30); + *(wp++) = 0x80 | ((c & 0x3fffffff) >> 24); + *(wp++) = 0x80 | ((c & 0xffffff) >> 18); + *(wp++) = 0x80 | ((c & 0x3ffff) >> 12); + *(wp++) = 0x80 | ((c & 0xfff) >> 6); + *(wp++) = 0x80 | (c & 0x3f); + } + src++; + } + *wp = '\0'; + return wp - (unsigned char*)dest; +} + + +/** + * Allocate a region on memory. + */ +inline void* xmalloc(size_t size) { + _assert_(size <= MEMMAXSIZ); + void* ptr = std::malloc(size); + if (!ptr) throw std::bad_alloc(); + return ptr; +} + + +/** + * Allocate a nullified region on memory. + */ +inline void* xcalloc(size_t nmemb, size_t size) { + _assert_(nmemb <= MEMMAXSIZ && size <= MEMMAXSIZ); + void* ptr = std::calloc(nmemb, size); + if (!ptr) throw std::bad_alloc(); + return ptr; +} + + +/** + * Re-allocate a region on memory. + */ +inline void* xrealloc(void* ptr, size_t size) { + _assert_(size <= MEMMAXSIZ); + ptr = std::realloc(ptr, size); + if (!ptr) throw std::bad_alloc(); + return ptr; +} + + +/** + * Free a region on memory. + */ +inline void xfree(void* ptr) { + _assert_(true); + std::free(ptr); +} + + +/** + * Dummy test driver. + */ +inline bool _dummytest() { + _assert_(true); + std::ostringstream oss; + oss << INT8MAX << INT16MAX << INT32MAX << INT64MAX; + oss << INT8MIN << INT16MIN << INT32MIN << INT64MIN; + oss << UINT8MAX << UINT16MAX << UINT32MAX << UINT64MAX; + oss << SIZEMAX << FLTMAX << DBLMAX; + oss << VERSION << LIBVER << LIBREV << FMTVER << OSNAME; + oss << BIGEND << CLOCKTICK << PAGESIZ << FEATURES; + oss << NUMBUFSIZ << MEMMAXSIZ; + return oss.tellp() > 0; +} + + +} // common namespace + +#endif // duplication check + +// END OF FILE |