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, 0 insertions, 2924 deletions
diff --git a/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h b/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h deleted file mode 100644 index 8e3f74786a..0000000000 --- a/plugins/Dbx_kyoto/src/kyotocabinet/kcutil.h +++ /dev/null @@ -1,2924 +0,0 @@ -/************************************************************************************************* - * 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 |