diff options
Diffstat (limited to '')
| -rw-r--r-- | project/dclib/dclib-basics.h | 5252 |
1 files changed, 5252 insertions, 0 deletions
diff --git a/project/dclib/dclib-basics.h b/project/dclib/dclib-basics.h new file mode 100644 index 0000000..7c6e7a2 --- /dev/null +++ b/project/dclib/dclib-basics.h @@ -0,0 +1,5252 @@ + +/*************************************************************************** + * * + * _____ ____ * + * | __ \ / __ \ _ _ _____ * + * | | \ \ / / \_\ | | | | _ \ * + * | | \ \| | | | | | |_| | * + * | | | || | | | | | ___/ * + * | | / /| | __ | | | | _ \ * + * | |__/ / \ \__/ / | |___| | |_| | * + * |_____/ \____/ |_____|_|_____/ * + * * + * Wiimms source code library * + * * + *************************************************************************** + * * + * Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de> * + * * + *************************************************************************** + * * + * 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 2 of the License, or * + * (at your option) 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. * + * * + * See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt * + * * + ***************************************************************************/ + +#ifndef DCLIB_BASICS_H +#define DCLIB_BASICS_H 1 + +#define _GNU_SOURCE 1 + +#include <sys/types.h> +#include <arpa/inet.h> +#include <limits.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include <math.h> + +#ifndef WIN_DCLIB + #include <stdint.h> +#endif + +#include "dclib-types.h" +#include "dclib-debug.h" +#include "dclib-color.h" +#include "dclib-numeric.h" + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// helpers /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define SIZEOFMEMBER(type,a) sizeof(((type*)0)->a) + +#define SIZEOFRANGE(type,a,b) \ + ( offsetof(type,b) + sizeof(((type*)0)->b) - offsetof(type,a) ) + +#define PTR_DISTANCE(a,b) ( (u8*)(a) - (u8*)(b) ) +#define PTR_DISTANCE_INT(a,b) ( (int)( (u8*)(a) - (u8*)(b) )) + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// bits /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern const uchar TableBitCount[0x100]; +extern const char TableLowest0Bit[0x100]; +extern const char TableLowest1Bit[0x100]; +extern const char TableHighest0Bit[0x100]; +extern const char TableHighest1Bit[0x100]; + +uint Count1Bits ( cvp addr, uint size ); +static inline uint Count0Bits ( cvp addr, uint size ) + { return CHAR_BIT * size - Count1Bits(addr,size); } + +#define Count1BitsObj(obj) Count1Bits(&(obj),sizeof(obj)) +#define Count0BitsObj(obj) Count1Bits(&(obj),sizeof(obj)) + +static inline uint Count1Bits8 ( u8 data ) +{ + return TableBitCount[data]; +} + +static inline uint Count1Bits16 ( u16 data ) +{ + const u8 * d = (u8*)&data; + return TableBitCount[d[0]] + + TableBitCount[d[1]]; +} + +static inline uint Count1Bits32 ( u32 data ) +{ + // __builtin_popcount(unsigned int) is slower than table based summary + + const u8 * d = (u8*)&data; + return TableBitCount[d[0]] + + TableBitCount[d[1]] + + TableBitCount[d[2]] + + TableBitCount[d[3]]; +} + +static inline uint Count1Bits64 ( u64 data ) +{ + #if __GNUC__ > 3 + return __builtin_popcountll(data); + #else + const u8 * d = (u8*)&data; + return TableBitCount[d[0]] + + TableBitCount[d[1]] + + TableBitCount[d[2]] + + TableBitCount[d[3]] + + TableBitCount[d[4]] + + TableBitCount[d[5]] + + TableBitCount[d[6]] + + TableBitCount[d[7]]; + #endif +} + +/////////////////////////////////////////////////////////////////////////////// + +int FindLowest0BitBE ( cvp addr, uint size ); +int FindLowest1BitBE ( cvp addr, uint size ); +int FindHighest0BitBE ( cvp addr, uint size ); +int FindHighest1BitBE ( cvp addr, uint size ); + +int FindLowest0BitLE ( cvp addr, uint size ); +int FindLowest1BitLE ( cvp addr, uint size ); +int FindHighest0BitLE ( cvp addr, uint size ); +int FindHighest1BitLE ( cvp addr, uint size ); + +#if __BYTE_ORDER == 1234 + #define FindLowest0Bit FindLowest0BitLE + #define FindLowest1Bit FindLowest1BitLE + #define FindHighest0Bit FindHighest0BitLE + #define FindHighest1Bit FindHighest1BitLE +#else + #define FindLowest0Bit FindLowest0BitBE + #define FindLowest1Bit FindLowest1BitBE + #define FindHighest0Bit FindHighest0BitBE + #define FindHighest1Bit FindHighest1BitBE +#endif + +u32 GetAlign32 ( u32 data ); +u64 GetAlign64 ( u64 data ); + +/////////////////////////////////////////////////////////////////////////////// + +static inline void SetBit ( void *addr, uint bit_num ) + { ((u8*)addr)[ bit_num >> 3 ] |= 1 << ( bit_num & 7 ); } + +static inline void ClearBit ( void *addr, uint bit_num ) + { ((u8*)addr)[ bit_num >> 3 ] &= ~(1 << ( bit_num & 7 )); } + +static inline void InvertBit ( void *addr, uint bit_num ) + { ((u8*)addr)[ bit_num >> 3 ] ^= 1 << ( bit_num & 7 ); } + +static inline bool TestBit ( const void *addr, uint bit_num ) + { return ( ((u8*)addr)[ bit_num >> 3 ] & 1 << ( bit_num & 7 ) ) != 0; } + +// change a single bit and return the previous state +bool TestSetBit ( void *addr, uint bit_num ); +bool TestClearBit ( void *addr, uint bit_num ); +bool TestInvertBit ( void *addr, uint bit_num ); + +// change bits inclusive 'beg' to exclusive 'end' if beg_bitnum<end_bitnum +void SetBits ( void *addr, uint beg_bitnum, uint end_bitnum ); +void ClearBits ( void *addr, uint beg_bitnum, uint end_bitnum ); +void InvertBits ( void *addr, uint beg_bitnum, uint end_bitnum ); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +int PrintBitfieldEx +( + // returns the number of printed characters, or -1 if buffer is to small + + char *buf, // buffer + uint buf_size, // size of 'buf' + cvp bit_field, // address of bit field + uint min_idx, // minimal index (inclusive) to check + uint max_idx, // maximal index (inclusive) to check + bool use_ranges, // true: create ranges 'a:b' + int mult, // each printed index is first multiplyed by 'mult' + int add // ... and then added to 'add'. +); + +static inline int PrintBitfield +( + // returns the number of printed characters, or -1 if buffer is to small + + char *buf, // buffer + uint buf_size, // size of 'buf' + cvp bit_field, // address of bit field + uint bit_field_size, // size of 'bit_field' in bytes + bool use_ranges // true: create ranges 'a:b' +) +{ + return PrintBitfieldEx ( buf, buf_size, bit_field, + 0, 8*bit_field_size-1, use_ranges, 1, 0 ); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// low level endian conversions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +//---------------------------------------------------- +// swapping bytes = inverse byte order +// void dswap16 ( void * data_ptr ); +// void dswap24 ( void * data_ptr ); +// void dswap32 ( void * data_ptr ); +// void dswap48 ( void * data_ptr ); +// void dswap64 ( void * data_ptr ); +//---------------------------------------------------- + +static inline void dswap16 ( void * data_ptr ) +{ + u8 *d = data_ptr; + u8 temp = d[0]; + d[0] = d[1]; + d[1] = temp; +} + +static inline void dswap24 ( void * data_ptr ) +{ + u8 *d = data_ptr; + const u8 temp = d[0]; + d[0] = d[2]; + d[2] = temp; +} + +static inline void dswap32 ( void * data_ptr ) +{ + u8 temp, *d = data_ptr; + temp = d[0]; d[0] = d[3]; d[3] = temp; + temp = d[1]; d[1] = d[2]; d[2] = temp; +} + +static inline void dswap48 ( void * data_ptr ) +{ + u8 temp, *d = data_ptr; + temp = d[0]; d[0] = d[5]; d[5] = temp; + temp = d[1]; d[1] = d[4]; d[4] = temp; + temp = d[2]; d[2] = d[3]; d[3] = temp; +} + +static inline void dswap64 ( void * data_ptr ) +{ + u8 temp, *d = data_ptr; + temp = d[0]; d[0] = d[7]; d[7] = temp; + temp = d[1]; d[1] = d[6]; d[6] = temp; + temp = d[2]; d[2] = d[5]; d[5] = temp; + temp = d[3]; d[3] = d[4]; d[4] = temp; +} + +/////////////////////////////////////////////////////////////////////////////// + +//---------------------------------------------------- +// read data and swap bytes (inverse byte order) +// u16 swap16 ( const void * data_ptr ); +// u32 swap24 ( const void * data_ptr ); +// u32 swap32 ( const void * data_ptr ); +// u64 swap48 ( const void * data_ptr ); +// u64 swap64 ( const void * data_ptr ); +// float swapf4 ( const void * data_ptr ); +// double swapf8 ( const void * data_ptr ); +//---------------------------------------------------- + +static inline u16 swap16 ( const void * data_ptr ) +{ + u8 r[2]; + const u8 *d = data_ptr; + r[1] = *d++; + r[0] = *d; + return *(u16*)r; +} + +static inline u32 swap24 ( const void * data_ptr ) +{ + u8 r[4]; + const u8 *d = data_ptr; + r[3] = 0; + r[2] = *d++; + r[1] = *d++; + r[0] = *d; + return *(u32*)r; +} + +static inline u32 swap32 ( const void * data_ptr ) +{ + u8 r[4]; + const u8 *d = data_ptr; + r[3] = *d++; + r[2] = *d++; + r[1] = *d++; + r[0] = *d; + return *(u32*)r; +} + +static inline u64 swap48 ( const void * data_ptr ) +{ + u8 r[8]; + const u8 *d = data_ptr; + r[7] = 0; + r[6] = 0; + r[5] = *d++; + r[4] = *d++; + r[3] = *d++; + r[2] = *d++; + r[1] = *d++; + r[0] = *d; + return *(u64*)r; +} + +static inline u64 swap64 ( const void * data_ptr ) +{ + u8 r[8]; + const u8 *d = data_ptr; + r[7] = *d++; + r[6] = *d++; + r[5] = *d++; + r[4] = *d++; + r[3] = *d++; + r[2] = *d++; + r[1] = *d++; + r[0] = *d; + return *(u64*)r; +} + +static inline float swapf4 ( const void * data_ptr ) +{ + // assume: local system supports IEEE 754 + union { float f; u32 i; } u; + u.i = swap32(data_ptr); + return u.f; +} + +static inline double swapf8 ( const void * data_ptr ) +{ + // assume: local system supports IEEE 754 + union { double f; u64 i; } u; + u.i = swap64(data_ptr); + return u.f; +} + +/////////////////////////////////////////////////////////////////////////////// + +//---------------------------------------------------- +// convert big endian data to a number in host format +// u16 be16 ( const void * be_data_ptr ); +// u32 be24 ( const void * be_data_ptr ); +// u32 be32 ( const void * be_data_ptr ); +// u64 be40 ( const void * be_data_ptr ); +// u64 be48 ( const void * be_data_ptr ); +// u64 be56 ( const void * be_data_ptr ); +// u64 be64 ( const void * be_data_ptr ); +// float bef4 ( const void * be_data_ptr ); +// double bef8 ( const void * be_data_ptr ); +//---------------------------------------------------- + +static inline u16 be16 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return d[0] << 8 | d[1]; +} + +static inline u32 be24 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return ( d[0] << 8 | d[1] ) << 8 | d[2]; +} + +static inline u32 be32 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return (( d[0] << 8 | d[1] ) << 8 | d[2] ) << 8 | d[3]; +} + +static inline u64 be40 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return (u64)be32(d) << 8 | ((u8*)d)[4]; +} + +static inline u64 be48 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return (u64)be32(d) << 16 | be16(d+4); +} + +static inline u64 be56 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return (u64)be32(d) << 24 | be24(d+4); +} + +static inline u64 be64 ( const void * be_data_ptr ) +{ + const u8 * d = be_data_ptr; + return (u64)be32(d) << 32 | be32(d+4); +} + +static inline float bef4 ( const void * be_data_ptr ) +{ + // assume: local system supports IEEE 754 + union { float f; u32 i; } u; + u.i = be32(be_data_ptr); + return u.f; +} + +static inline double bef8 ( const void * be_data_ptr ) +{ + // assume: local system supports IEEE 754 + union { double f; u64 i; } u; + u.i = be64(be_data_ptr); + return u.f; +} + +/////////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------- +// convert little endian data to a number in host format +// u16 le16 ( const void * le_data_ptr ); +// u32 le24 ( const void * le_data_ptr ); +// u32 le32 ( const void * le_data_ptr ); +// u64 le40 ( const void * le_data_ptr ); +// u64 le48 ( const void * le_data_ptr ); +// u64 le56 ( const void * le_data_ptr ); +// u64 le64 ( const void * le_data_ptr ); +// float lef4 ( const void * le_data_ptr ); +// double lef8 ( const void * le_data_ptr ); +//------------------------------------------------------- + +static inline u16 le16 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return d[1] << 8 | d[0]; +} + +static inline u32 le24 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return ( d[2] << 8 | d[1] ) << 8 | d[0]; +} + +static inline u32 le32 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return (( d[3] << 8 | d[2] ) << 8 | d[1] ) << 8 | d[0]; +} + +static inline u64 le40 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return (u64)le32(d+1) << 8 | ((u8*)d)[0]; +} + +static inline u64 le48 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return (u64)le16(d+4) << 32 | le32(d); +} + +static inline u64 le56 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return (u64)le24(d+4) << 32 | le32(d); +} + +static inline u64 le64 ( const void * le_data_ptr ) +{ + const u8 * d = le_data_ptr; + return (u64)le32(d+4) << 32 | le32(d); +} + +static inline float lef4 ( const void * le_data_ptr ) +{ + // assume: local system supports IEEE 754 + + union { float f; u32 i; } u; + u.i = le32(le_data_ptr); + return u.f; +} + +static inline double lef8 ( const void * le_data_ptr ) +{ + // assume: local system supports IEEE 754 + + union { double f; u64 i; } u; + u.i = le64(le_data_ptr); + return u.f; +} + +/////////////////////////////////////////////////////////////////////////////// + +//------------------------------------------- +// convert u64 from/to network byte order +// be64_t hton64 ( u64 data ); +// u64 ntoh64 ( be64_t data ); +//------------------------------------------- + +static inline be64_t hton64 ( u64 data ) +{ + be64_t result; + ((u32*)&result)[0] = htonl( (u32)(data >> 32) ); + ((u32*)&result)[1] = htonl( (u32)data ); + return result; +} + +static inline u64 ntoh64 ( be64_t data ) +{ + return (u64)ntohl(((u32*)&data)[0]) << 32 | ntohl(((u32*)&data)[1]); +} + +/////////////////////////////////////////////////////////////////////////////// + +// convert a number in host format into big endian data +void write_be16 ( void * be_data_ptr, u16 data ); +void write_be24 ( void * be_data_ptr, u32 data ); +void write_be32 ( void * be_data_ptr, u32 data ); +void write_be40 ( void * be_data_ptr, u64 data ); +void write_be48 ( void * be_data_ptr, u64 data ); +void write_be56 ( void * be_data_ptr, u64 data ); +void write_be64 ( void * be_data_ptr, u64 data ); +void write_bef4 ( void * be_data_ptr, float data ); +void write_bef8 ( void * be_data_ptr, double data ); + +// convert a number in host format into little endian data +void write_le16 ( void * le_data_ptr, u16 data ); +void write_le24 ( void * le_data_ptr, u32 data ); +void write_le32 ( void * le_data_ptr, u32 data ); +void write_le40 ( void * le_data_ptr, u64 data ); +void write_le48 ( void * le_data_ptr, u64 data ); +void write_le56 ( void * le_data_ptr, u64 data ); +void write_le64 ( void * le_data_ptr, u64 data ); +void write_lef4 ( void * le_data_ptr, float data ); +void write_lef8 ( void * le_data_ptr, double data ); + +// convert lists +void be16n ( u16 * dest, const u16 * src, int n ); +void be32n ( u32 * dest, const u32 * src, int n ); +void bef4n ( float32 * dest, const float32 * src, int n ); +void le16n ( u16 * dest, const u16 * src, int n ); +void lef4n ( float32 * dest, const float32 * src, int n ); + +void write_be16n ( u16 * dest, const u16 * src, int n ); +void write_be32n ( u32 * dest, const u32 * src, int n ); +void write_bef4n ( float32 * dest, const float32 * src, int n ); +void write_le16n ( u16 * dest, const u16 * src, int n ); +void write_lef4n ( float32 * dest, const float32 * src, int n ); + +//----------------------------------------------------------------------------- +// [[endian_func_t]] + +typedef struct endian_func_t +{ + //--- info section + + u8 bom[2]; // btye order mark: BE=0xfe,0xff, LE=0xff,0xfe + bool is_be; // true: is big endian + bool is_le; // true: is little endian + dcEndian_t endian; // DC_BIG_ENDIAN or DC_LITTLE_ENDIAN + + //--- read functions + + u16 (*rd16) ( const void * data_ptr ); + u32 (*rd24) ( const void * data_ptr ); + u32 (*rd32) ( const void * data_ptr ); + u64 (*rd40) ( const void * data_ptr ); + u64 (*rd48) ( const void * data_ptr ); + u64 (*rd56) ( const void * data_ptr ); + u64 (*rd64) ( const void * data_ptr ); + float (*rdf4) ( const void * data_ptr ); + double (*rdf8) ( const void * data_ptr ); + + //--- write functions + + void (*wr16) ( void * data_ptr, u16 data ); + void (*wr24) ( void * data_ptr, u32 data ); + void (*wr32) ( void * data_ptr, u32 data ); + void (*wr40) ( void * data_ptr, u64 data ); + void (*wr48) ( void * data_ptr, u64 data ); + void (*wr56) ( void * data_ptr, u64 data ); + void (*wr64) ( void * data_ptr, u64 data ); + void (*wrf4) ( void * data_ptr, float data ); + void (*wrf8) ( void * data_ptr, double data ); + +} endian_func_t; + +extern const endian_func_t be_func; +extern const endian_func_t le_func; + +const endian_func_t * GetEndianFunc ( const void * byte_order_mark ); +uint GetTextBOMLen ( const void * data, uint data_size ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct mem_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[mem_t]] + +typedef struct mem_t +{ + ccp ptr; // NULL or a pointer to the data + int len; // length in bytes of the data +} +mem_t; + +extern mem_t EmptyMem; // mem_t(EmptyString,0) +extern mem_t NullMem; // mem_t(0,0) + +//----------------------------------------------------------------------------- + +static inline mem_t MemByChar ( char ch ) +{ + mem_t mem = { &ch, 1 }; + return mem; +} + +static inline mem_t MemByString0 ( ccp str ) +{ + if (!str) + return NullMem; + + mem_t mem = { str, strlen(str) }; + return mem; +} + +static inline mem_t MemByString ( ccp str ) +{ + mem_t mem = { str, strlen(str) }; + return mem; +} + +static inline mem_t MemByStringS ( ccp str, int len ) +{ + mem_t mem = { str, len < 0 ? strlen(str) : len }; + return mem; +} + +static inline mem_t MemByStringE ( ccp str, ccp end ) +{ + mem_t mem = { str, end ? end-str : strlen(str) }; + return mem; +} + +static inline mem_t MemByS ( ccp str, int len ) +{ + mem_t mem = { str, len }; + return mem; +} + +static inline mem_t MemByE ( ccp str, ccp end ) +{ + mem_t mem = { str, end-str }; + return mem; +} + +//----------------------------------------------------------------------------- + +// Index helpers +// For the 'End' variants, index 0 is end_of_source + +int CheckIndex1 ( int max, int index ); +int CheckIndex1End ( int max, int index ); +int CheckIndex2 ( int max, int * p_begin, int * p_end ); +int CheckIndex2End ( int max, int * p_begin, int * p_end ); + +//----------------------------------------------------------------------------- + +// All functions are robust. +// A negative index is relative to the end of source. +// For RightMem() and ExtractEndMem(), index 0 means: end of source. +// count<0 means: copy left from 'begin' (only MidMem()) or skip bytes. + +mem_t MidMem ( const mem_t src, int begin, int count ); + +static inline mem_t LeftMem ( const mem_t src, int count ) +{ + mem_t res; + res.ptr = src.ptr; + res.len = CheckIndex1(src.len,count); + return res; +} + +static inline mem_t RightMem ( const mem_t src, int count ) +{ + mem_t res; + res.len = src.len - CheckIndex1End(src.len,-count); + res.ptr = src.ptr + src.len - res.len; + return res; +} + +static inline mem_t ExtractMem ( const mem_t src, int begin, int end ) +{ + mem_t res; + res.len = CheckIndex2(src.len,&begin,&end); + res.ptr = src.ptr + begin; + return res; +} + +static inline mem_t ExtractEndMem ( const mem_t src, int begin, int end ) +{ + mem_t res; + res.len = CheckIndex2End(src.len,&begin,&end); + res.ptr = src.ptr + begin; + return res; +} + +mem_t BeforeMem ( const mem_t src, ccp ref ); +mem_t BehindMem ( const mem_t src, ccp ref ); + +//----------------------------------------------------------------------------- + +// Alloc dest buffer and terminate with 0. +// If m*.len < 0, then use strlen(). + +mem_t MemCat2A ( const mem_t m1, const mem_t m2 ); +mem_t MemCat3A ( const mem_t m1, const mem_t m2, const mem_t m3 ); + +//----------------------------------------------------------------------------- + +int CmpMem ( const mem_t s1, const mem_t s2 ); +int StrCmpMem ( const mem_t mem, ccp str ); +bool LeftStrCmpMemEQ ( const mem_t mem, ccp str ); + +// free a string if str is not NULL|EmptyString|MinusString +void FreeString ( ccp str ); + +static inline void FreeMem ( mem_t *mem ) +{ + DASSERT(mem); + FreeString(mem->ptr); + mem->ptr = 0; + mem->len = 0; +} + +static inline void AssignDupMem ( mem_t *dest, mem_t src ) +{ + DASSERT(dest); + FreeString(dest->ptr); + dest->ptr = MEMDUP(src.ptr,src.len); + dest->len = src.len; +} + +static inline mem_t DupMem ( const mem_t src ) +{ + mem_t res = { MEMDUP(src.ptr,src.len), src.len }; + return res; +} + +static inline char * DupStrMem ( const mem_t src ) +{ + return MEMDUP(src.ptr,src.len); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct mem_list_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[mem_list_t]] + +typedef struct mem_list_t +{ + mem_t *list; // List of mem_t objects. + // Elements are always terminated with NULL. + // Content is stored in 'buf' or points to EmptyString. + + uint used; // Number of active 'list' elements + uint size; // Number of alloced 'list' elements + + char *buf; // Alloced temp buffer + uint buf_used; // Usage of 'buf' + uint buf_size; // Size of 'buf' +} +mem_list_t; + +//----------------------------------------------------------------------------- + +void InitializeMemList ( mem_list_t *ml ); +void ResetMemList ( mem_list_t *ml ); +void MoveMemList ( mem_list_t *dest, mem_list_t *src ); + +void GrowBufMemList ( mem_list_t *ml, uint need_size ); +void PrepareMemList ( mem_list_t *ml, uint n_elem, uint buf_size ); + +//----------------------------------------------------------------------------- + +void InsertMemListN +( + mem_list_t *ml, // valid destination mem_list + int pos, // insert position => CheckIndex1() + const mem_t *src, // source list + uint src_len, // number of elements in source list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +); + +//----------------------------------------------------------------------------- + +static inline void InsertMemList2 +( + mem_list_t *ml, // valid destination mem_list + int pos, // insert position => CheckIndex1() + const mem_list_t *src, // source mem_list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + DASSERT(src); + InsertMemListN(ml,pos,src->list,src->used,src_ignore); +} + +//----------------------------------------------------------------------------- + +static inline void AppendMemListN +( + mem_list_t *ml, // valid destination mem_list + const mem_t *src, // source list + uint src_len, // number of elements in source list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + DASSERT(ml); + InsertMemListN(ml,ml->used,src,src_len,src_ignore); +} + +//----------------------------------------------------------------------------- + +static inline void AppendMemList2 +( + mem_list_t *ml, // valid destination mem_list + const mem_list_t *src, // source mem_list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + DASSERT(ml); + DASSERT(src); + InsertMemListN(ml,ml->used,src->list,src->used,src_ignore); +} + +//----------------------------------------------------------------------------- + +static inline void AssignMemListN +( + mem_list_t *ml, // valid destination mem_list + const mem_t *src, // source list + uint src_len, // number of elements in source list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + DASSERT(ml); + ml->used = 0; + InsertMemListN(ml,0,src,src_len,src_ignore); +} + +//----------------------------------------------------------------------------- + +static inline void AssignMemList2 +( + mem_list_t *ml, // valid destination mem_list + const mem_list_t *src, // source mem_list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + DASSERT(ml); + DASSERT(src); + ml->used = 0; + InsertMemListN(ml,0,src->list,src->used,src_ignore); +} + +/////////////////////////////////////////////////////////////////////////////// + +void CatMemListN +( + mem_list_t *dest, // valid destination mem_list + const mem_list_t **src_list, // list with mem lists, element may be NULL + uint n_src_list, // number of elements in 'src' + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +); + +//----------------------------------------------------------------------------- + +static inline void CatMemList2 +( + mem_list_t *dest, // valid destination mem_list + const mem_list_t *src1, // source mem_list + const mem_list_t *src2, // source mem_list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + const mem_list_t *ml[2] = { src1, src2 }; + CatMemListN(dest,ml,2,src_ignore); +} + +//----------------------------------------------------------------------------- + +static inline void CatMemList3 +( + mem_list_t *dest, // valid destination mem_list + const mem_list_t *src1, // source mem_list + const mem_list_t *src2, // source mem_list + const mem_list_t *src3, // source mem_list + uint src_ignore // 0: insert all + // 1: ignore NULL + // 2: ignore NULL and empty + // 3: replace NULL by EmptyString +) +{ + const mem_list_t *ml[3] = { src1, src2, src3 }; + CatMemListN(dest,ml,3,src_ignore); +} + +//----------------------------------------------------------------------------- + +// All functions are robust and modify the current list. +// A negative index is relative to the end of source. +// For RightMemList() and *EndMemList(), index 0 means: end of source. +// count<0 means: copy left from 'begin' (only MidMemList()) or skip bytes. +// All functions return the number of elements aufer operation. + +uint LeftMemList ( mem_list_t *ml, int count ); +uint RightMemList ( mem_list_t *ml, int count ); +uint MidMemList ( mem_list_t *ml, int begin, int count ); +uint ExtractMemList ( mem_list_t *ml, int begin, int end ); +uint ExtractEndMemList ( mem_list_t *ml, int begin, int end ); +uint RemoveMemList ( mem_list_t *ml, int begin, int end ); +uint RemoveEndMemList ( mem_list_t *ml, int begin, int end ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// MemPool_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[MemPoolChunk_t]] + +typedef struct MemPoolChunk_t +{ + struct MemPoolChunk_t *next; + char data[]; +} +MemPoolChunk_t; + +//----------------------------------------------------------------------------- +// [[MemPool_t]] + +typedef struct MemPool_t +{ + MemPoolChunk_t *chunk; // pointer to first (=current) chunk + uint space; // space left in current chunk + uint chunk_size; // wanted chunk size +} +MemPool_t; + +//----------------------------------------------------------------------------- + +static inline void InitializeMemPool ( MemPool_t *mp, uint chunk_size ) + { DASSERT(mp); memset(mp,0,sizeof(*mp)); mp->chunk_size = chunk_size; } + +void ResetMemPool ( MemPool_t *mp ); +void * MallocMemPool ( MemPool_t *mp, uint size ); +void * CallocMemPool ( MemPool_t *mp, uint size ); +void * MallocMemPoolA ( MemPool_t *mp, uint size, uint align ); +void * CallocMemPoolA ( MemPool_t *mp, uint size, uint align ); +void * MemDupMemPool ( MemPool_t *mp, cvp source, uint size ); + +static inline void * StrDupMemPool ( MemPool_t *mp, ccp source ) + { DASSERT(mp); return source ? MemDupMemPool(mp,source,strlen(source)) : 0; } + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CircBuf_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[CircBuf_t]] + +typedef struct CircBuf_t +{ + char *buf; // NULL or alloced buffer + uint pos; // position of first valid byte + uint used; // used bytes in buffer + uint size; // size of 'buf' +} +CircBuf_t; + +/////////////////////////////////////////////////////////////////////////////// + +void InitializeCircBuf ( CircBuf_t *cb, uint size ); +void ResetCircBuf ( CircBuf_t *cb ); +uint WriteCircBuf ( CircBuf_t *cb, cvp data, uint size ); +uint PeakCircBuf ( CircBuf_t *cb, char *buf, uint buf_size ); +uint ReadCircBuf ( CircBuf_t *cb, char *buf, uint buf_size ); +uint DropCircBuf ( CircBuf_t *cb, uint size ); +void ClearCircBuf ( CircBuf_t *cb ); +uint PurgeCircBuf ( CircBuf_t *cb ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CopyMode_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef enum CopyMode_t +{ + CPM_COPY, // make a copy of the data, alloced + CPM_MOVE, // move the alloced data + CPM_LINK, // link the data + +} CopyMode_t; + +/////////////////////////////////////////////////////////////////////////////// + +void * CopyData +( + const void *data, // data to copy/move/link + uint size, // size of 'data' + CopyMode_t mode, // copy mode + bool *res_alloced // not NULL: + // store true, if data must be freed + // otherwise store false +); + +/////////////////////////////////////////////////////////////////////////////// + +void FreeData +( + const void *data, // data to free + CopyMode_t mode // copy mode +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// split strings /////////////// +/////////////////////////////////////////////////////////////////////////////// + +uint SplitByCharMem +( + // 'mem_list' will be padded with {EmptyString,0} + + mem_t *mem_list, // array of mem_t + uint n_mem, // number of elements of 'mem_list' + mem_t source, // source string + char sep // separator character +); + +//----------------------------------------------------------------------------- + +uint SplitByTextMem +( + // 'mem_list' will be padded with {EmptyString,0} + + mem_t *mem_list, // array of mem_t + uint n_mem, // number of elements of 'mem_list' + mem_t source, // source string + mem_t sep // separator text +); + +//----------------------------------------------------------------------------- + +uint SplitByCharMemList +( + mem_list_t *ml, // valid destination mem_list + bool init_ml, // true: initialize 'ml' first + mem_t source, // source string + char sep, // separator character + int max_fields // >0: max number of result fields +); + +//----------------------------------------------------------------------------- + +uint SplitByTextMemList +( + mem_list_t *ml, // valid destination mem_list + bool init_ml, // true: initialize 'ml' first + mem_t source, // source string + mem_t sep, // separator text + int max_fields // >0: max number of result fields +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// alloc info /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern bool alloc_info_calced; +extern uint alloc_info_overhead; +extern uint alloc_info_block_size; +extern uint alloc_info_add1; +extern uint alloc_info_add2; +extern uint alloc_info_mask; + +/////////////////////////////////////////////////////////////////////////////// + +uint SetupAllocInfo(void); + +static inline uint GetGoodAllocSize ( uint need ) +{ + return ( need + alloc_info_add1 & alloc_info_mask ) + + alloc_info_add2; +} + +static inline uint GetGoodAllocSize2 ( uint n_elem, uint itemsize ) +{ + return (( n_elem*itemsize + alloc_info_add1 & alloc_info_mask ) + + alloc_info_add2 ) / itemsize; +} + +static inline uint GetGoodAllocSizeA ( uint need, uint align ) +{ + need = ( need + align - 1) / align * align; + return (( need + alloc_info_add1 & alloc_info_mask ) + + alloc_info_add2 ) / align * align; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// some basic string functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern const char EmptyQuote[]; // »""« Ignored by FreeString() +extern const char EmptyString[4]; // »« + 4*NULL, Ignored by FreeString() +extern const char MinusString[4]; // »-« + 3*NULL, Ignored by FreeString() + +extern const char LoDigits[0x41]; // 0-9 a-z A-Z .+ NULL +extern const char HiDigits[0x41]; // 0-9 A-Z a-z .+ NULL + +extern const char Tabs20[21]; // 20 * TAB + NULL +extern const char LF20[21]; // 20 * LF + NULL +extern const char Space200[201]; // 200 * ' ' + NULL +extern const char Minus300[301]; // 300 * '-' + NULL +extern const char Underline200[201]; // 200 * '_' + NULL +extern const char Hash200[201]; // 200 * '#' + NULL +extern const char Slash200[201]; // 200 * '/' + NULL + +// UTF-8 => 3 bytes per char +extern const char ThinLine300_3[901]; // 300 * '─' (U+2500) + NULL + +//----------------------------------------------------------------------------- + +void SetupMultiProcessing(void); +void PrintSettingsDCLIB ( FILE *f, int indent ); +void SetupProgname ( int argc, char ** argv, + ccp tool_name, ccp tool_vers, ccp tool_title ); + +// return NULL or 'progpath', calc GetProgramPath() once if needed +ccp ProgramPath(void); + +// return NULL or 'progdir', calc ProgramPath() once if needed +ccp ProgramDirectory(void); + +#ifdef __CYGWIN__ + ccp ProgramPathNoExt(void); +#else + static inline ccp ProgramPathNoExt(void) { return ProgramPath(); } +#endif + +int GetProgramPath +( + // returns strlen(buf) on success, -1 on failure + + char *buf, // buffer for the result; empty string on failure. + uint buf_size, // size of buffer + bool check_proc, // true: read files of /proc/... to find path + ccp argv0 // not NULL: analyse this argument (argv[0]) +); + +//----- + +// StringCopy(), StringCopyE(), StringCat*() +// RESULT: end of copied string pointing to a NULL character. +// 'src*' may be a NULL pointer. + +char * StringCopyS ( char * buf, size_t bufsize, ccp src ); +char * StringCopySM ( char * buf, size_t bufsize, ccp src, size_t max_copy ); +char * StringCat2S ( char * buf, size_t bufsize, ccp src1, ccp src2 ); +char * StringCat3S ( char * buf, size_t bufsize, ccp src1, ccp src2, ccp src3 ); + +char * StringCopyE ( char * buf, ccp buf_end, ccp src ); +char * StringCopyEM ( char * buf, ccp buf_end, ccp src, size_t max_copy ); +char * StringCat2E ( char * buf, ccp buf_end, ccp src1, ccp src2 ); +char * StringCat3E ( char * buf, ccp buf_end, ccp src1, ccp src2, ccp src3 ); + +// alloc space and return +char * StringCat2A ( ccp src1, ccp src2 ); +char * StringCat3A ( ccp src1, ccp src2, ccp src3 ); + +static inline char * StringCopySMem ( char * buf, size_t bufsize, mem_t mem ) + { return StringCopySM(buf,bufsize,mem.ptr,mem.len); } +static inline char * StringCopyEMem ( char * buf, ccp buf_end, mem_t mem ) + { return StringCopyEM(buf,buf_end,mem.ptr,mem.len); } + +char * StringLowerS ( char * buf, size_t bufsize, ccp src ); +char * StringLowerE ( char * buf, ccp buf_end, ccp src ); +char * StringUpperS ( char * buf, size_t bufsize, ccp src ); +char * StringUpperE ( char * buf, ccp buf_end, ccp src ); + +// special handling for unsigned decimals +int StrNumCmp ( ccp a, ccp b ); + +// count the number of equal bytes and return a value of 0 to SIZE +uint CountEqual ( cvp m1, cvp m2, uint size ); + +// Concatenate path + path, return pointer to buf +// Return pointer to buf or path1|path2|buf or alloced string +char *PathCatBufPP ( char *buf, size_t bufsize, ccp path1, ccp path2 ); +char *PathCatBufPPE ( char *buf, size_t bufsize, ccp path1, ccp path2, ccp ext ); +ccp PathCatPP ( char *buf, size_t bufsize, ccp path1, ccp path2 ); +//ccp PathCatPPE ( char *buf, size_t bufsize, ccp path1, ccp path2, ccp ext ); +ccp PathAllocPP ( ccp path1, ccp path2 ); +ccp PathAllocPPE ( ccp path1, ccp path2, ccp ext ); + +// inline wrapper +static inline ccp PathCatPPE ( char *buf, size_t bufsize, ccp path1, ccp path2, ccp ext ) + { return PathCatBufPPE(buf,bufsize,path1,path2,ext); } + +// Same as PathCatPP*(), but use 'base' as prefix for relative pathes. +// If 'base' is NULL (but not empty), use getcwd() instead. +// PathCatBufBP() and PathCatBP() are special: path can be part of buf +char *PathCatBufBP ( char *buf, size_t bufsize, ccp base, ccp path ); +char *PathCatBufBPP ( char *buf, size_t bufsize, ccp base, ccp path1, ccp path2 ); +char *PathCatBufBPPE ( char *buf, size_t bufsize, ccp base, ccp path1, ccp path2, ccp ext ); +ccp PathCatBP ( char *buf, size_t bufsize, ccp base, ccp path ); +ccp PathCatBPP ( char *buf, size_t bufsize, ccp base, ccp path1, ccp path2 ); +ccp PathCatBPPE ( char *buf, size_t bufsize, ccp base, ccp path1, ccp path2, ccp ext ); +ccp PathAllocBP ( ccp base, ccp path ); +ccp PathAllocBPP ( ccp base, ccp path1, ccp path2 ); +ccp PathAllocBPPE ( ccp base, ccp path1, ccp path2, ccp ext ); + +char * PathCombine ( char *temp_buf, uint buf_size, ccp path, ccp base_path ); +char * PathCombineFast ( char *dest_buf, uint buf_size, ccp path, ccp base_path ); + +// Remove last extension and add a new one. +// If ext==NULL or emtpy: remove only +// 'ext' may start with '.'. If not, a additional '.' is included +// If 'path' is NULL or path==buf: Inplace job using 'buf' as source. +char * NewFileExtE ( char * buf, ccp buf_end, ccp path, ccp ext ); +char * NewFileExtS ( char * buf, size_t bufsize, ccp path, ccp ext ); + +// eliminate leading './' before comparing +int StrPathCmp ( ccp path1, ccp path2 ); + +int PathCmp +( + ccp path1, // NULL or first path + ccp path2, // NULL or second path + uint mode // bit field: + // 1: skip (multiple) leading './' + // 2: compare case insensitive + // 4: sort with respect for unsigned decimal numbers +); + +int ReplaceToBuf +( + // returns -1 on error (buf to small) or the length of the resulting string. + // In the later case, a 0 byte is appended, but not counting for the length. + + char *buf, // pointer to buf + uint buf_size, // size of 'buf' + + ccp src1, // NULL or source, maybe part of 'buf' + int src1_len, // length of 'src1', if -1: determine by strlen() + int pos, // robust replace position, <0: relative to end + int rm_len, // robust num of chars to remove, <0: rm before 'pos' + + ccp src2, // NULL or source to insert, must not be part of 'buf' + int src2_len // lengh of 'src2', if -1: determine by strlen() +); + +int NormalizeIndent ( int indent ); + +//----------------------------------------------------- + +// skips all character 1..SPACE; 'src' can be NULL +char * SkipControls ( ccp src ); + +// skips all character 0..SPACE; if end==NULL: Use SkipControls(); 'src' can be NULL +char * SkipControlsE ( ccp src, ccp end ); + +// same as above, but skip also 'ch1'; 'src' can be NULL +char * SkipControls1 ( ccp src, char ch1 ); +char * SkipControlsE1 ( ccp src, ccp end, char ch1 ); + +// same as above, but skip also 'ch1' and 'ch2'; 'src' can be NULL +char * SkipControls2 ( ccp src, char ch1, char ch2 ); +char * SkipControlsE2 ( ccp src, ccp end, char ch1, char ch2 ); + +//----------------------------------------------------- + +// return the number of chars until first EOL ( \0 | \r | \n ); +// pointer are NULL save +uint LineLen ( ccp ptr ); +uint LineLenE ( ccp ptr, ccp end ); + +//----------------------------------------------------- + +uint TrimBlanks +( + char *str, // pointer to string, modified + ccp end // NULL or end of string +); + +char * ScanName +( + // return a pointer to the first unused character + char *buf, // destination buffer, terminated with NULL + uint buf_size, // size of 'buf', must be >0 + ccp str, // source string + ccp end, // NULL or end of 'str' + bool allow_signs // true: allow '-' and '+' +); + +//----------------------------------------------------- +// Format of version number: AABBCCDD = A.BB | A.BB.CC +// If D != 0x00 && D != 0xff => append: 'beta' D +//----------------------------------------------------- + +char * PrintVersion +( + char * buf, // result buffer + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 version // version number to print +); + +char * PrintID +( + const void * id, // ID to convert in printable format + size_t id_len, // len of 'id' + void * buf // Pointer to buffer, size >= id_len + 1 + // If NULL, a local circulary static buffer is used +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// circ buf /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define CIRC_BUF_MAX_ALLOC 0x0400 // request limit +#define CIRC_BUF_SIZE 0x4000 // internal buffer size + +char * GetCircBuf +( + // never returns NULL, but always ALIGN(4) + + u32 buf_size // wanted buffer size, caller must add 1 for NULL-term + // if buf_size > CIRC_BUF_MAX_ALLOC: + // ==> ERROR0(ERR_OUT_OF_MEMORY) +); + +char * CopyCircBuf +( + // never returns NULL, but always ALIGN(4) + + cvp data, // source to copy + u32 data_size // see GetCircBuf() +); + +char * CopyCircBuf0 +( + // never returns NULL, but always ALIGN(4) + // an additional char is alloced and set to NULL + + cvp data, // source to copy + u32 data_size // see GetCircBuf() +); + +char * PrintCircBuf +( + ccp format, // format string for vsnprintf() + ... // arguments for 'format' +) +__attribute__ ((__format__(__printf__,1,2))); + +void ReleaseCircBuf +( + ccp end_buf, // pointer to end of previous alloced buffer + uint release_size // number of bytes to give back from end +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct IntMode_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[IntMode_t]] + +typedef enum IntMode_t +{ + IMD_UNSET = 0, // default, always 0 + + //--- big endian modes + + IMD_BE0, // default big endian + IMD_BE1, + IMD_BE2, + IMD_BE3, + IMD_BE4, + IMD_BE5, + IMD_BE6, + IMD_BE7, + IMD_BE8, + + //--- little endian modes + + IMD_LE0, // default little endian + IMD_LE1, + IMD_LE2, + IMD_LE3, + IMD_LE4, + IMD_LE5, + IMD_LE6, + IMD_LE7, + IMD_LE8, + + //--- local endian modes + + #ifdef LITTLE_ENDIAN + + IMD_0 = IMD_LE0, + IMD_1 = IMD_LE1, + IMD_2 = IMD_LE2, + IMD_3 = IMD_LE3, + IMD_4 = IMD_LE4, + IMD_5 = IMD_LE5, + IMD_6 = IMD_LE6, + IMD_7 = IMD_LE7, + IMD_8 = IMD_LE8, + + #else + + IMD_0 = IMD_BE0, + IMD_1 = IMD_BE1, + IMD_2 = IMD_BE2, + IMD_3 = IMD_BE3, + IMD_4 = IMD_BE4, + IMD_5 = IMD_BE5, + IMD_6 = IMD_BE6, + IMD_7 = IMD_BE7, + IMD_8 = IMD_BE8, + + #endif +} +__attribute__ ((packed)) IntMode_t; + +//----------------------------------------------------------------------------- + +ccp GetIntModeName ( IntMode_t mode ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct FastBuf_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[FastBuf_t]] + +typedef struct FastBuf_t +{ + char *buf; // pointer to buffer + char *ptr; // pointer to first unused char (always space for 0-term) + char *end; // pointer to end of buffer := buf+size-1 + + uint fast_buf_size; // size of 'fast_buf+space' + char fast_buf[4]; // first use buffer with minimal space + char space[]; // additional space +} +FastBuf_t; + +/////////////////////////////////////////////////////////////////////////////// + +//------------------------------------------------------------------ +// +// 4 examples for initialization: +// +// FastBuf_t fb1; +// InitializeFastBufAlloc(&fb1,1000); +// printf("fb1: %s: %s\n", GetFastBufStatus(&fb1), fb1.buf ); +// +// FastBuf_t fb2; +// InitializeFastBuf(&fb2,sizeof(fb2)); +// printf("fb2: %s: %s\n", GetFastBufStatus(&fb2), fb2.buf ); +// +// struct { FastBuf_t b; char space[2000]; } fb3; +// InitializeFastBuf(&fb3,sizeof(fb3)); +// printf("fb3: %s: %s\n", GetFastBufStatus(&fb.b), fb3.b.buf ); +// +// char fb4x[2000]; +// FastBuf_t *fb4 = InitializeFastBuf(fb4x,sizeof(fb4x)); +// printf("fb4: %s: %s\n", GetFastBufStatus(fb4), fb4->buf ); +// +//------------------------------------------------------------------ + +FastBuf_t * InitializeFastBuf ( cvp mem, uint size ); +FastBuf_t * InitializeFastBufAlloc ( FastBuf_t *fb, uint size ); + +void ResetFastBuf ( FastBuf_t *fb ); +static inline void ClearFastBuf ( FastBuf_t *fb ) + { DASSERT(fb); fb->ptr = fb->buf; } + +ccp GetFastBufStatus ( const FastBuf_t *fb ); +int ReserveSpaceFastBuf ( FastBuf_t *fb, uint size ); +char * GetSpaceFastBuf ( FastBuf_t *fb, uint size ); + +uint InsertFastBuf ( FastBuf_t *fb, int index, cvp source, int size ); +char * AppendFastBuf ( FastBuf_t *fb, cvp source, int size ); +char * WriteFastBuf ( FastBuf_t *fb, uint offset, cvp source, int size ); +uint AssignFastBuf ( FastBuf_t *fb, cvp source, int size ); +uint DropFastBuf ( FastBuf_t *fb, int index, int size ); + +void CopyFastBuf ( FastBuf_t *dest, const FastBuf_t *src ); +void MoveFastBuf ( FastBuf_t *dest, FastBuf_t *src ); + +static inline void AppendMemFastBuf ( FastBuf_t *fb, const mem_t mem ) + { AppendFastBuf(fb,mem.ptr,mem.len); } + +static inline void AppendCharFastBuf ( FastBuf_t *fb, char ch ) +{ + DASSERT(fb); + GetSpaceFastBuf(fb,1)[0] = ch; +} + +void AppendUTF8CharFastBuf ( FastBuf_t *fb, u32 code ); +void AppendBE16FastBuf ( FastBuf_t *fb, u16 num ); +void AppendBE32FastBuf ( FastBuf_t *fb, u32 num ); +void AppendInt64FastBuf ( FastBuf_t *fb, u64 val, IntMode_t mode ); + +static inline void AppendU16FastBuf ( FastBuf_t *fb, u16 num ) + { AppendFastBuf(fb,&num,sizeof(num)); } +static inline void AppendU32FastBuf ( FastBuf_t *fb, u32 num ) + { AppendFastBuf(fb,&num,sizeof(num)); } +static inline void AppendU64FastBuf ( FastBuf_t *fb, u64 num ) + { AppendFastBuf(fb,&num,sizeof(num)); } + +static inline int GetFastBufLen ( const FastBuf_t *fb ) + { DASSERT(fb); return fb->ptr - fb->buf; } + +//----------------------------------------------------------------------------- +// The resulting strings of GetFastBufString() and GetFastBufMem0() are always +// terminated by an additional NULL byte. +// The resulting strings of GetFastBufMem() is not terminated by a NULL byte. +//----------------------------------------------------------------------------- + +static inline char * GetFastBufString ( const FastBuf_t *fb ) +{ + DASSERT(fb); + *fb->ptr = 0; + return fb->buf; +} + +static inline mem_t GetFastBufMem0 ( const FastBuf_t *fb ) +{ + DASSERT(fb); + *fb->ptr = 0; + mem_t mem = { fb->buf, fb->ptr - fb->buf }; + return mem; +} + +static inline mem_t GetFastBufMem ( const FastBuf_t *fb ) +{ + DASSERT(fb); + mem_t mem = { fb->buf, fb->ptr - fb->buf }; + return mem; +} + +//----------------------------------------------------------------------------- +// The allocated result is always terminated by an additional NULL byte. +// FastBuf_t itself is reset, similar to ResetFastBuf() + +char * MoveFromFastBufString ( FastBuf_t *fb ); +mem_t MoveFromFastBufMem ( FastBuf_t *fb ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// MatchPattern() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define PATTERN_WILDCARDS "*# ?[{" + +bool MatchPatternFull +( + ccp pattern, // pattern text + ccp text // raw text +); + +bool MatchPattern +( + ccp pattern, // pattern text + ccp text, // raw text + char path_sep // path separator character, standard is '/' +); + +char * MatchRuleLine +( + // returns a pointer to the first non scanned char + + int *status, // not NULL: return match status here + // -2: no prefix found (no ruile found) + // -1: empty line (no ruile found) + // 0: rule found, but don't match + // 1: rule found and match + ccp src, // source line, scanned untilCONTROL + char rule_prefix, // NULL or a rule-beginning-char' + ccp path, // path to verify + char path_sep // path separator character, standard is '/' +); + +/////////////////////////////////////////////////////////////////////////////// + +static inline int GetHexDigit ( char ch ) +{ + return ch >= '0' && ch <= '9' ? ch-'0' + : ch >= 'a' && ch <= 'f' ? ch-'a'+10 + : ch >= 'A' && ch <= 'F' ? ch-'A'+10 + : -1; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// SplitArg_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[SplitArg_t]] + +typedef struct SplitArg_t +{ + uint argc; // number of arguments in 'argv' + char **argv; // array with 'argc' arguments + a NULL term, alloced + uint argv_size; // number of alloced pointers for 'argv' without NULL term + + char *temp; // NULL or temporary buffer + uint temp_size; // size of 'temp' +} +SplitArg_t; + +static inline void InitializeSplitArg ( SplitArg_t *sa ) + { DASSERT(sa); memset(sa,0,sizeof(*sa)); } + +void ResetSplitArg ( SplitArg_t *sa ); + +int ScanSplitArg +( + // returns arg->argc; + + SplitArg_t *arg, // pointer to object + bool init_arg, // true: call InitializeSplitArg() + ccp src, // NULL or source string + ccp src_end, // end of 'src'; if NULL: calculated by strlen(src) + char *work_buf // pointer to a buffer for strings, may be 'src' + // size must be: length of 'src' + 1 + // if NULL, a temporary buffer is alloced. +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ContainerData_t, Container_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +//----------------------------------------------------------------------------- +// OVERVIEW +//----------------------------------------------------------------------------- +// Container_t * CreateContainer ( Container_t, protect, data,size, CopyMode_t ) +// Container_t * InheritContainer ( Container_t cur, protect, Container_t parent, data,size ) +// bool AssignContainer ( Container_t, protect, data,size, CopyMode_t ) +// void ResetContainer ( Container_t ) +// void DeleteContainer ( Container_t ) +// void UnlinkContainerData ( Container_t ) +// ContainerData_t * LinkContainerData ( Container_t ) +// ContainerData_t * MoveContainerData ( Container_t ) +// Container_t * CatchContainerData ( Container_t, int protect, ContainerData_t ) +// Container_t * UseContainerData ( Container_t, int protect, Container_t ) +//------------ +// ContainerData_t DisjoinContainerData ( Container_t ) +// void JoinContainerData ( Container_t, ContainerData_t ) +// void FreeContainerData ( ContainerData_t ) +//------------ +// static inline bool ModificationAllowed ( const Container_t ) +// void ModifyAllContainer ( Container_t ) +// void ModifyContainer ( Container_t, data, size, CopyMode_t ) +// int SetProtectContainer ( Container_t, int new_protect ) +// static inline int AddProtectContainer ( Container_t, int add_protect ) +// static inline bool IsValidContainer ( const Container_t * c ) +// static inline bool InContainerP ( const Container_t, cvp ptr ) +// static inline bool InContainerS ( const Container_t, cvp ptr, uint size ) +// static inline bool InContainerE ( const Container_t, cvp ptr, cvp end ) +// uint DumpInfoContainer ( f,colset,indent,prefix, Container_t, hexdump_len ) +// uint DumpInfoContainerData ( f,col,indent,prefix, CData_t, hex_len, hex_indent ) +//----------------------------------------------------------------------------- + +/////////////////////////////////////////////////////////////////////////////// +// [[ContainerData_t]] + +typedef struct ContainerData_t +{ + u8 *data; // data + uint size; // size of 'data' + int ref_count; // reference counter + int protect_count; // >0: don't modify data + bool data_alloced; // true: free data + +} ContainerData_t; + +//----------------------------------------------------------------------------- +// [[Container_t]] + +typedef struct Container_t +{ + ContainerData_t *cdata; // NULL or pointer to ContainerData + int protect_level; // >0: don't modify data + +} Container_t; + +/////////////////////////////////////////////////////////////////////////////// + +Container_t * CreateContainer +( + // returns 'c' or the alloced container + // 'c' is always initialized + + Container_t *c, // valid container, alloc one if NULL + int protect, // initial value for protection + const void *data, // data to copy/move/link + uint size, // size of 'data' + CopyMode_t mode // copy mode on creation +); + +//----------------------------------------------------------------------------- + +Container_t * InheritContainer +( + // returns 'c' or the alloced container + + Container_t *c, // valid container, alloc one if NULL + int protect, // initial value for protection + const Container_t *parent, // NULL or valid parent container + const void *data, // data to copy/move/link + uint size // size of 'data' +); + +//----------------------------------------------------------------------------- + +bool AssignContainer +( + // return TRUE on new ContainerData_t + + Container_t *c, // valid container; if NULL: only FREE(data) + int protect, // new protection level + const void *data, // data to copy/move/link + uint size, // size of 'data' + CopyMode_t mode // copy mode on creation +); + +//----------------------------------------------------------------------------- + +void ResetContainer +( + Container_t *c // container to reset => no data +); + +//----------------------------------------------------------------------------- + +void DeleteContainer +( + Container_t *c // container to reset and to free => no data +); + +//----------------------------------------------------------------------------- + +void UnlinkContainerData +( + Container_t *c // container to reset => no data +); + +/////////////////////////////////////////////////////////////////////////////// + +ContainerData_t * LinkContainerData +( + // increment 'ref_count' and return NULL or current ContainerData + // => use CatchContainerData() to complete operation + + const Container_t *c // NULL or valid container +); + +//----------------------------------------------------------------------------- + +ContainerData_t * MoveContainerData +( + // return NULL or unlinked current ContainerData + // => use CatchContainerData() to complete operation + Container_t *c // NULL or valid container +); + +//----------------------------------------------------------------------------- + +Container_t * CatchContainerData +( + // returns 'c' or the alloced container + // 'c' is always initialized + + Container_t *c, // valid container, alloc one if NULL + int protect, // initial value for protection + ContainerData_t *cdata // if not NULL: catch this +); + +//----------------------------------------------------------------------------- + +static inline Container_t * UseContainerData +( + // returns 'c' or the alloced container + + Container_t *c, // valid container, alloc one if NULL + int protect, // initial value for protection + const Container_t *src // if not NULL: catch this +) +{ + return CatchContainerData(c,protect,LinkContainerData(src)); +} + +/////////////////////////////////////////////////////////////////////////////// + +ContainerData_t * DisjoinContainerData +( + // Disjoin data container date without freeing it. Call either + // JoinContainerData() or FreeContainerData() to finish operation. + // Reference counters are not modified. + // Return the data container or NULL + + Container_t *c // NULL or valid container +); + +//----------------------------------------------------------------------------- + +void JoinContainerData +( + // Join a data container, that was diojoined by DisjoinContainerData() + // Reference counters are not modified. + + Container_t *c, // if NULL: FreeContainerData() + ContainerData_t *cdata // NULL or container-data to join +); + +//----------------------------------------------------------------------------- + +void FreeContainerData +( + // Decrement the reference counter of an already disjoined data container + // and free it if unused. + + ContainerData_t *cdata // NULL or container-data to free +); + +/////////////////////////////////////////////////////////////////////////////// + +static inline bool ModificationAllowed ( const Container_t *c ) + { return c && c->cdata + && ( c->cdata->ref_count <= 1 + || c->cdata->protect_count <= ( c->protect_level > 0 ) ); + } + +//----------------------------------------------------------------------------- + +bool ModifyAllContainer +( + // prepare modification of container-data, create a copy if necessary + // return true, if a new container-data is used + + Container_t *c // NULL or valid container +); + +//----------------------------------------------------------------------------- + +bool ModifyContainer +( + // prepare modification of container-data, create an extract if necessary + // return true, if a new container-data is used + + Container_t *c, // NULL or valid container + const void *data, // data to copy/move/link + uint size, // size of 'data' + CopyMode_t mode // copy mode on creation +); + +//----------------------------------------------------------------------------- + +int SetProtectContainer +( + // returns 'c' new protection level + Container_t *c, // valid container, alloc one if NULL + int new_protect // new protection value +); + +//----------------------------------------------------------------------------- + +static inline int AddProtectContainer +( + // returns 'c' new protection level + Container_t *c, // valid container, alloc one if NULL + int add_protect // new protection value +) +{ + DASSERT(c); + return SetProtectContainer(c,c->protect_level+add_protect); +} + +/////////////////////////////////////////////////////////////////////////////// + +static inline bool IsValidContainer ( const Container_t * c ) + { return c && c->cdata && c->cdata->data; } + +//----------------------------------------------------------------------------- + +static inline bool InContainerP ( const Container_t * c, cvp ptr ) + { return c && c->cdata && ptr + && (u8*)ptr >= c->cdata->data + && (u8*)ptr <= c->cdata->data + c->cdata->size; } + +//----------------------------------------------------------------------------- + +static inline bool InContainerS ( const Container_t * c, cvp ptr, uint size ) + { return c && c->cdata && ptr + && (u8*)ptr >= c->cdata->data + && (u8*)ptr + size <= c->cdata->data + c->cdata->size; } + +//----------------------------------------------------------------------------- + +static inline bool InContainerE ( const Container_t * c, cvp ptr, cvp end ) + { return c && c->cdata + && ptr && (u8*)ptr >= c->cdata->data + && end && (u8*)end <= c->cdata->data + c->cdata->size; } + +/////////////////////////////////////////////////////////////////////////////// + +struct ColorSet_t; +uint DumpInfoContainer +( + // return the number of printed lines + + FILE *f, // valid output file + const ColorSet_t *colset, // NULL or color set + int indent, // indent the output + ccp prefix, // not NULL: use it as prefix behind indention + const Container_t *c, // dump infos for this container, NULL allowed + uint hexdump_len // max number of bytes used for a hexdump +); + +//----------------------------------------------------------------------------- + +uint DumpInfoContainerData +( + // return the number of printed lines + + FILE *f, // valid output file + const ColorSet_t *colset, // NULL or color set + int indent, // indent of output + ccp prefix, // not NULL: use it as prefix behind indention + const + ContainerData_t *cdata, // dump infos for this container-data, NULL allowed + uint hexdump_len, // max number of bytes used for a hexdump + int hexdump_indent // indent of hexdump +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// print lines with autobreak /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void PutLines +( + FILE * f, // valid output stream + int indent, // indent of output + int fw, // field width of output + int first_line, // length without prefix of already printed first line + ccp prefix, // NULL or prefix for each line + ccp text, // text to print + ccp eol // End Of Line test. If NULL -> LF +); + +void PrintArgLines +( + FILE * f, // valid output stream + int indent, // indent of output + int fw, // field width of output + int first_line, // length without prefix of already printed first line + ccp prefix, // NULL or prefix for each line + ccp format, // format string for vsnprintf() + va_list arg // parameters for 'format' +); + +void PrintLines +( + FILE * f, // valid output stream + int indent, // indent of output + int fw, // field width of output + int first_line, // length without prefix of already printed first line + ccp prefix, // NULL or prefix for each line + ccp format, // format string for vsnprintf() + ... // arguments for 'vsnprintf(format,...)' +) +__attribute__ ((__format__(__printf__,6,7))); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// +// Rules for P*ColoredLines(): +// +// |+ : Define a TAB pos (not is defined at start) +// |- : Remove a TAB pos +// |[pos,...] : Comma separated list: Clear all tabs and define new TABs +// POS : Define TAB add POS +// POS*DELTA : Define TAB add POS and then at every DELTA +// \t : Jump to TAB stop +// +// | or |> : Define an indention for continuation lines. +// Use the single char only, if a letter, digit, underline, SPACE, +// CTRL or '{' follows. All ather chars are reserved for extensions. +// \r : Force a new continuation line. +// \n : Terminate current line. +// \r\n : Same as '\n'. +// +// {name} : Change active color to NAME +// {name|text} : Use color NAME only for TEXT, then restore active color. +// {} : Reset and deactivate all colors. +// +// || : Print Single '|' +// {{ : Print Single '{' +// +/////////////////////////////////////////////////////////////////////////////// + +uint PutColoredLines +( + // returns the number of written lines + + FILE * f, // valid output stream + const ColorSet_t *colset, // NULL or color set + int indent, // indent of output + int fw, // field width; indent+prefix+eol don't count + ccp prefix, // NULL or prefix for each line + ccp eol, // End Of Line test. If NULL -> LF + ccp text // text to print +); + +uint PrintArgColoredLines +( + // returns the number of written lines + + FILE * f, // valid output stream + const ColorSet_t *colset, // NULL or color set + int indent, // indent of output + int fw, // field width; indent+prefix+eol don't count + ccp prefix, // NULL or prefix for each line + ccp eol, // End Of Line test. If NULL -> LF + ccp format, // format string for vsnprintf() + va_list arg // parameters for 'format' +); + +uint PrintColoredLines +( + // returns the number of written lines + + FILE * f, // valid output stream + const ColorSet_t *colset, // NULL or color set + int indent, // indent of output + int fw, // field width; indent+prefix+eol don't count + ccp prefix, // NULL or prefix for each line + ccp eol, // End Of Line test. If NULL -> LF + ccp format, // format string for vsnprintf() + ... // arguments for 'vsnprintf(format,...)' +) +__attribute__ ((__format__(__printf__,7,8))); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// encoding/decoding /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern const u32 TableCRC32[0x100]; +u32 CalcCRC32 ( u32 crc, cvp buf, uint size ); + +/////////////////////////////////////////////////////////////////////////////// + +extern const u16 TableCP1252_80[0x20]; + +/////////////////////////////////////////////////////////////////////////////// +// [[CharMode_t]] + +typedef enum CharMode_t // select encodig/decoding method +{ + CHMD_UTF8 = 0x01, // UTF8 support enabled (compatible with legacy bool) + CHMD_ESC = 0x02, // escape ESC by \e + + CHMD__ALL = CHMD_UTF8 | CHMD_ESC, +} +__attribute__ ((packed)) CharMode_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[EncodeMode_t]] + +typedef enum EncodeMode_t // select encodig/decoding method +{ + ENCODE_OFF, // no encoding (always 0) + ENCODE_STRING, // ScanEscapedString(ANSI), byte mode + ENCODE_UTF8, // ScanEscapedString(UTF8), force UTF8 on decoding + ENCODE_BASE64, // Base64 + ENCODE_BASE64URL, // Base64.URL (=) / decoder detects Standard + URL + STAR + ENCODE_BASE64STAR, // Base64.URL (*) / decoder detects Standard + URL + STAR + ENCODE_BASE64XML, // Base64 with XML name tokens / decoder detects Standard + XML (name+id) + ENCODE_JSON, // JSON string encoding + + ENCODE__N // number of encoding modes +} +EncodeMode_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[DecodeType_t]] + +enum DecodeType_t // for decoding tables +{ + DECODE_NULL = -1, + DECODE_CONTROL = -2, + DECODE_LINE = -3, + DECODE_SPACE = -4, + DECODE_SEPARATE = -5, + DECODE_FILLER = -6, + DECODE_OTHER = -7 +}; + +extern const char TableNumbers[256]; + +extern char TableDecode64[256]; // Standard coding +extern char TableDecode64url[256]; // Standard + URL + STAR coding +extern char TableDecode64xml[256]; // Standard + XML (name tokens + identifiers) + +extern const char TableEncode64[64+1]; // last char is filler +extern const char TableEncode64url[64+1]; // URL coding, used by Nintendo +extern const char TableEncode64star[64+1]; // Like URL, with '*' instead of '=' as filler +extern const char TableEncode64xml[64+1]; // XML name tokens + +// for tests: encode the 48 bytes to get the full BASE64 alphabet +extern const u8 TableAlphabet64[48]; + +// Default tables for DecodeBase64() and EncodeBase64(), if no table is defined. +// They are initialized with TableDecode64[] and TableEncode64[]. +extern ccp TableDecode64default, TableEncode64default; + +/////////////////////////////////////////////////////////////////////////////// + +char * PrintEscapedString +( + // returns 'buf' + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 10 + ccp source, // NULL string to print + int len, // length of string. if -1, str is null terminated + CharMode_t char_mode, // modes, bit field (CHMD_*) + char quote, // NULL or quotation char, that must be quoted + uint *dest_len // not NULL: Store length of result here +); + +/////////////////////////////////////////////////////////////////////////////// + +uint ScanEscapedString +( + // returns the number of valid bytes in 'buf' (NULL term not counted) + + char *buf, // valid destination buffer, maybe source + uint buf_size, // size of 'buf' + ccp source, // string to scan + int len, // length of string. if -1, str is null terminated + bool utf8, // true: source and output is UTF-8 + int quote, // 0:none, -1:auto, >0: quotation char + uint *scanned_len // not NULL: Store number of scanned 'source' bytes here +); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +u64 DecodeU64 +( + ccp source, // string to decode + int len, // length of string. if -1, str is null terminated + uint base, // number of possible digits (2..36): + uint *scanned_len // not NULL: Store number of scanned 'str' bytes here +); + +/////////////////////////////////////////////////////////////////////////////// + +ccp EncodeU64 +( + char * buf, // result buffer (size depends on base) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 num, // number to encode + uint base // number of possible digits (2..64): +); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +uint DecodeBase64 +( + // returns the number of valid bytes in 'buf' + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 3 + ccp source, // NULL or string to decode + int len, // length of string. if -1, str is null terminated + const char decode64[256], // decoding table; if NULL: use TableDecode64default + bool allow_white_spaces, // true: skip white spaces + uint *scanned_len // not NULL: Store number of scanned 'str' bytes here +); + +//----------------------------------------------------------------------------- + +mem_t DecodeBase64Circ +( + // Returns a buffer alloced by GetCircBuf() + // with valid pointer and null terminated. + // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned. + + ccp source, // NULL or string to decode + int len, // length of string. if -1, str is null terminated + const char decode64[256] // decoding table; if NULL: use TableDecode64default +); + +/////////////////////////////////////////////////////////////////////////////// + +uint EncodeBase64 +( + // returns the number of scanned bytes of 'source' + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 4 + const void *source, // NULL or data to encode + int source_len, // length of 'source'; if <0: use strlen(source) + const char encode64[64+1], // encoding table; if NULL: use TableEncode64default + bool use_filler, // use filler for aligned output + ccp next_line, // not NULL: use this string as new line sep + uint next_line_trigger // >0: use 'next_line' every # input bytes +); + +//----------------------------------------------------------------------------- + +mem_t EncodeBase64Circ +( + // Returns a buffer alloced by GetCircBuf() + // with valid pointer and null terminated. + // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned. + + const void *source, // NULL or data to encode + int source_len, // length of 'source'; if <0: use strlen(source) + const char encode64[64+1] // encoding table; if NULL: use TableEncode64default +); + +/////////////////////////////////////////////////////////////////////////////// + +static inline uint EncodeBase64Len ( uint src_len ) + { return 4 * (src_len+2) / 3; } + +static inline uint EncodeBase64FillLen ( uint src_len ) + { return (src_len+2) / 3 * 4; } + +static inline uint DecodeBase64Len ( uint src_len ) + { return 3 * src_len / 4; } + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static inline uint DecodeJSON +( + // returns the number of valid bytes in 'buf' + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 3 + ccp source, // NULL or string to decode + int source_len, // length of 'source'. If -1, str is NULL terminated + uint *scanned_len // not NULL: Store number of scanned 'str' bytes here +) +{ + return ScanEscapedString(buf,buf_size,source,source_len,true,0,scanned_len); +} + +//----------------------------------------------------------------------------- + +mem_t DecodeJSONCirc +( + // Returns a buffer alloced by GetCircBuf() + // with valid pointer and null terminated. + // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned. + + ccp source, // NULL or string to decode + int source_len // length of 'source'. If -1, str is NULL terminated +); + +/////////////////////////////////////////////////////////////////////////////// + +uint EncodeJSON +( + // returns the number of valid bytes in 'buf'. Result is NULL-terminated. + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >2 and 2 bytes longer than needed + const void *source, // NULL or data to encode + int source_len // length of 'source'; if <0: use strlen(source) +); + +//----------------------------------------------------------------------------- + +mem_t EncodeJSONCirc +( + // Returns a buffer alloced by GetCircBuf() + // with valid pointer and null terminated. + // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned. + + const void *source, // NULL or data to encode + int source_len // length of 'source'; if <0: use strlen(source) +); + +//----------------------------------------------------------------------------- + +mem_t QuoteJSONCirc +( + // Returns a buffer alloced by GetCircBuf() + // with valid pointer and null terminated. + // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned. + + const void *source, // NULL or data to encode + int source_len, // length of 'source'; if <0: use strlen(source) + int null_if // return 'null' without quotes ... + // <=0: never + // >=1: if source == NULL + // >=2: if source_len == 0 +); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +uint DecodeByMode +( + // returns the number of valid bytes in 'buf'. Result is NULL-terminated. + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 3 + ccp source, // string to decode + int slen, // length of string. if -1, str is null terminated + EncodeMode_t emode // encoding mode +); + +/////////////////////////////////////////////////////////////////////////////// + +uint EncodeByMode +( + // returns the number of valid bytes in 'buf'. Result is NULL-terminated. + + char *buf, // valid destination buffer + uint buf_size, // size of 'buf', >= 4 + ccp source, // string to encode + int slen, // length of string. if -1, str is null terminated + EncodeMode_t emode // encoding mode +); + +/////////////////////////////////////////////////////////////////////////////// + +mem_t DecodeByModeMem +( + // Returns the decoded 'source'. Result is NULL-terminated. + // It points either to 'buf' or is alloced (on buf==NULL or to less space) + // If alloced (mem.ptr!=buf) => call FreeMem(&mem) + + char *buf, // NULL or destination buffer + uint buf_size, // size of 'buf' + ccp source, // string to decode + int slen, // length of string. if -1, str is null terminated + EncodeMode_t emode // encoding mode +); + +/////////////////////////////////////////////////////////////////////////////// + +mem_t EncodeByModeMem +( + // Returns the encoded 'source'. Result is NULL-terminated. + // It points either to 'buf' or is alloced (on buf==NULL or to less space) + // If alloced (mem.ptr!=buf) => call FreeMem(&mem) + + char *buf, // NULL or destination buffer + uint buf_size, // size of 'buf' + ccp source, // string to encode + int slen, // length of string. if -1, str is null terminated + EncodeMode_t emode // encoding mode +); + +/////////////////////////////////////////////////////////////////////////////// + +#define SJIS_TAB_MAPPING_BEG 0xeea0 // first code used for table mapping +#define SJIS_TAB_MAPPING_END 0xeecf // last code used for table mapping +#define SJIS_INVALID_CODE 0xffff // invalid code +#define SJIS_CACHE_SIZE 0xffff // number of elements in cache + +static inline bool IsValidShiftJIS ( uint code ) + { return code < SJIS_TAB_MAPPING_BEG + || code > SJIS_TAB_MAPPING_END && code < SJIS_INVALID_CODE; } + +int ScanShiftJISChar ( cucp * str ); +int ScanShiftJISCharE ( cucp * str, cvp end ); + +void SetupGetShiftJISCache(void); +int GetShiftJISChar ( u32 code ); + +ccp GetShiftJISStatistics(void); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// scan keywords /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define KEYWORD_NAME_MAX 100 + +typedef s64 (*KeywordCallbackFunc) +( + void *param, // NULL or user defined parameter + ccp name, // normalized name of option + const KeywordTab_t *key_tab, // valid pointer to command table + const KeywordTab_t *key, // valid pointer to found command + char prefix, // 0 | '-' | '+' | '=' + s64 result // current value of result +); + +/////////////////////////////////////////////////////////////////////////////// + +const KeywordTab_t *GetKewordById +( + const KeywordTab_t *key_tab, // NULL or pointer to command table + s64 id // id to search +); + +//----------------------------------------------------------------------------- + +const KeywordTab_t *GetKewordByIdAndOpt +( + const KeywordTab_t *key_tab, // NULL or pointer to command table + s64 id, // id to search + s64 opt // opt to search +); + +//----------------------------------------------------------------------------- + +static inline ccp GetKewordNameById +( + const KeywordTab_t *key_tab, // NULL or pointer to command table + s64 id, // id to search + ccp res_not_found // return this if not found +) +{ + const KeywordTab_t *key = GetKewordById(key_tab,id); + return key ? key->name1 : res_not_found; +} + +//----------------------------------------------------------------------------- + +static inline ccp GetKewordNameByIdAndOpt +( + const KeywordTab_t *key_tab, // NULL or pointer to command table + s64 id, // id to search + s64 opt, // opt to search + ccp res_not_found // return this if not found +) +{ + const KeywordTab_t *key = GetKewordByIdAndOpt(key_tab,id,opt); + return key ? key->name1 : res_not_found; +} + +/////////////////////////////////////////////////////////////////////////////// + +const KeywordTab_t * ScanKeyword +( + int *res_abbrev, // NULL or pointer to result 'abbrev_count' + ccp arg, // argument to scan + const KeywordTab_t *key_tab // valid pointer to command table +); + +//----------------------------------------------------------------------------- + +s64 ScanKeywordListEx +( + ccp arg, // argument to scan + const KeywordTab_t * key_tab, // valid pointer to command table + KeywordCallbackFunc func, // NULL or calculation function + bool allow_prefix, // allow '-' | '+' | '=' as prefix + u32 max_number, // allow numbers < 'max_number' (0=disabled) + s64 result, // start value for result + + uint err_mode, // bit field: + // 1: continue on error + ccp err_msg, // not NULL: print a warning message: + // "<ERR_MSG>: Unknown keyword: <KEY>" + enumError err_code, // use 'err_code' for the 'err_msg' + uint *err_count // not NULL: store errors here +); + +static inline s64 ScanKeywordList +( + ccp arg, // argument to scan + const KeywordTab_t * key_tab, // valid pointer to command table + KeywordCallbackFunc func, // NULL or calculation function + bool allow_prefix, // allow '-' | '+' | '=' as prefix + u32 max_number, // allow numbers < 'max_number' (0=disabled) + s64 result, // start value for result + + ccp err_msg, // not NULL: print a warning message: + // "<ERR_MSG>: Unknown keyword: <KEY>" + enumError err_code // use 'err_code' for the 'err_msg' +) +{ + return ScanKeywordListEx( arg, key_tab, func, allow_prefix, + max_number, result, 0, err_msg, err_code, 0 ); +} + +//----------------------------------------------------------------------------- + +enumError ScanKeywordListFunc +( + ccp arg, // argument to scan + const KeywordTab_t *key_tab, // valid pointer to command table + KeywordCallbackFunc func, // calculation function + void *param, // used define parameter for 'func' + bool allow_prefix // allow '-' | '+' | '=' as prefix +); + +//----------------------------------------------------------------------------- + +s64 ScanKeywordListMask +( + ccp arg, // argument to scan + const KeywordTab_t * key_tab // valid pointer to command table +); + +//----------------------------------------------------------------------------- + +enumError PrintKeywordError +( + const KeywordTab_t * key_tab, // NULL or pointer to command table + ccp key_arg, // analyzed command + int key_stat, // status of ScanKeyword() + ccp prefix, // NULL or prefix for messages + ccp object // NULL or object for error messages + // default= 'command' +); + +uint CollectAmbiguousKeywords +( + char *buf, // destination buffer, 200 bytes are good + uint buf_size, // size of buffer + const KeywordTab_t * key_tab, // NULL or pointer to command table + ccp key_arg // analyzed command +); + +//----------------------------------------------------------------------------- + +char * PrintKeywordList +( + // returns a pointer to the result buffer + + char *buf, // result buffer + // If NULL, a local circulary static buffer + // with max CIRC_BUF_MAX_ALLOC bytes is used + uint buf_size, // size of 'buf', at least 10 bytes if buf is set + uint *ret_length, // not NULL: store result length here + + const KeywordTab_t *tab, // related keyword table + u64 mode, // mode to print + u64 default_mode, // NULL or default mode + u64 hide_mode // bit field to hide parameters +); + +//----------------------------------------------------------------------------- + +int ScanKeywordOffOn +( + // returns 0 for '0|OFF'; 1 for '1|ON; -1 for empty; -2 on error + + ccp arg, // argument to scan + uint max_num, // >0: additionally accept+return number <= max_num + ccp object // NULL (silent) or object for error messages +); + +//----------------------------------------------------------------------------- + +enumError Command_ARGTEST ( int argc, char ** argv ); +enumError Command_TESTCOLORS ( int argc, char ** argv ); + +enumError Command_COLORS +( + int level, // only used, if mode==NULL + // < 0: status message (ignore mode) + // >= 1: include names + // >= 2: include alt names + // >= 3: include color names incl bold + // >= 4: include background color names + uint mode, // output mode => see PrintColorSetHelper() + uint format // output format => see PrintColorSetEx() +); + + +/////////////////////////////////////////////////////////////////////////////// +/////////////// OFF/AUTO/ON/FORCE /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[OffOn_t]] + +typedef enum OffOn_t +{ + OFFON_ERROR = -99, + OFFON_OFF = -1, + OFFON_AUTO = 0, + OFFON_ON = 1, + OFFON_FORCE = 2, +} +OffOn_t; + +extern const KeywordTab_t KeyTab_OFF_AUTO_ON[]; + +int ScanKeywordOffAutoOn +( + // returns one of OFFON_* + + ccp arg, // argument to scan + int on_empty, // return this value on empty + uint max_num, // >0: additionally accept+return number <= max_num + ccp object // NULL (silent) or object for error messages +); + +ccp GetKeywordOffAutoOn ( OffOn_t value ); + +// // +/////////////////////////////////////////////////////////////////////////////// +/////////////// scan command lists /////////////// +/////////////////////////////////////////////////////////////////////////////// +// +// Scan a semicolon separated command list with binary support of format: +// COMMAND := NAME [BINLIST] CONTROL* ['='] CONTROL* [PARAM] CONTROL* ';' +// BLANK := TAB(9) or SPACE(32) +// CONTROL := NUL..SPACE (0..32) +// NAME := 1..99 alphanumeric chars incl. minus and underline +// BINLIST := BINARY [BINLIST] +// BINARY := BLANK* '\1' be16:SIZE DATA +// PARAM := all except ';' +// +// CONTROLS are possible before and behind the '=' and at the end of param. +// Only BLANK* are allowed between command NAME and BINARY block. +// BINARY data starts with \1 and is stored as '->bin' and '->bin_len' and +// inludes SIZE and DATA. The BINARY.SIZE includes itself and is a 16-bit +// big-endian number. In '->bin[]', member 'be16:SIZE' is excluded, +// but '->bin[].ptr - 2' points to be16:SIZE. +// +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[CommandList_t]] docu -> see above + +struct TCPStream_t; +#define COMMAND_LIST_N_BIN 5 + +typedef struct CommandList_t +{ + //--- input params + + ccp command; // command text + uint command_len; // total length of 'command' + char command_sep; // not NULL: alternative command separator + u8 change_case; // >0: convert command to lower(1) or upper(2) case + bool term_param; // 1: write a NULL at end-of-param => modify 'command' + // 2: write a ';' at end-of-param => modify 'command' + // in this case, ';' is counted to 'record_len' + bool is_terminated; // true: last command is terminated + // even without ';' + + //--- user parameters, pass-through + + struct TCPStream_t + *user_ts; // NULL or a stream for replies + void *user_ptr; // any pointer + int user_int; // any number or id + + ccp log_fname; // not NULL: open log file + uint log_level; // 0:off, 1:stat+err, 2:+cmd, 3:+bin+param, 4:+func + + //--- analysed data, only valid at callback + + char cmd[100]; // scanned command name + uint cmd_len; // length of scanned command name + + uint n_bin; // number of binary blocks + mem_t bin[COMMAND_LIST_N_BIN]; + // binary data detected, if bin[].ptr not null + + ccp param; // pointer to text parameter, not NULL terminated + uint param_len; // length of text parameter + const u8 *record; // complete record from NAME to END_RECORD_CHAR + uint record_len; // length of trimmed record + uint input_len; // length of complete record at input time + + //--- statistics + + uint read_cmd_len; // number of used bytes of 'command' + uint fail_count; // number of failed commands + uint cmd_count; // number of commands +} +CommandList_t; + +// return -1 to abort scanning +typedef int (*CommandListFunc) ( CommandList_t *cli ); + +//----------------------------------------------------------------------------- + +static inline void InitializeCommandList ( CommandList_t *cli ) + { DASSERT(cli); memset(cli,0,sizeof(*cli)); } + +static inline void ClearCommandList ( CommandList_t *cli ) + { DASSERT(cli); } + +static inline void ResetCommandList ( CommandList_t *cli ) + { DASSERT(cli); memset(cli,0,sizeof(*cli)); } + +// a test function for ScanCommandList() +int ExecCommandOfList ( CommandList_t *cli ); + +int ScanCommandList +( + // scan a semicolon separated command list. See above for format + // returns -1 on 'cli->fail_count'; otherwise 'cli->cmd_count' + + CommandList_t *cli, // valid command list + CommandListFunc func // NULL or function for each command +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// numeric functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern int urandom_available; // <0:not, =0:not tested, >0:ok +extern bool use_urandom_for_myrandom; + +uint ReadFromUrandom ( void *dest, uint size ); + +/////////////////////////////////////////////////////////////////////////////// + +u32 MyRandom ( u32 max ); +u64 MySeed ( u64 base ); +u64 MySeedByTime(void); + +void MyRandomFill ( void * buf, size_t size ); + +/////////////////////////////////////////////////////////////////////////////// + +void CreateUUID ( uuid_buf_t dest ); +uint CreateTextUUID ( char *buf, uint bufsize ); +uint PrintUUID ( char *buf, uint bufsize, uuid_buf_t uuid ); +char * ScanUUID ( uuid_buf_t uuid, ccp source ); + +/////////////////////////////////////////////////////////////////////////////// + +uint gcd ( uint n1, uint n2 ); // greatest common divisor, german: ggt +u32 gcd32 ( u32 n1, u32 n2 ); +u64 gcd64 ( u64 n1, u64 n2 ); + +uint lcm ( uint n1, uint n2 ); // lowest common multiple, german: kgv +u32 lcm32 ( u32 n1, u32 n2 ); +u64 lcm64 ( u64 n1, u64 n2 ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// scan number /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enum DigitTable_t +{ + NUMBER_NULL = -1, // NULL + NUMBER_CONTROL = -2, // < 0x20, but not SPACE or LINE + NUMBER_LINE = -3, // LF, CR + NUMBER_SPACE = -4, // SPACE, TAB, VT + NUMBER_TIE = -5, // ':' '-' '.' + NUMBER_SEPARATE = -6, // ',' ';' + NUMBER_OTHER = -7 // all other +}; + +extern const char DigitTable[256]; + +//----------------------------------------------------------------------------- + +u64 ScanDigits +( + // same as ScanNumber(), but other interface + // returns the scanned number + + ccp *source, // pointer to source string, modified + ccp end_source, // NULL or end of 'source' + uint intbase, // integer base, 2..36 + int maxchar, // max number of digits to read + uint *count // not NULL: store number of scanned digits here +); + +//----------------------------------------------------------------------------- + +char * ScanNumber +( + // same as ScanDigits(), but other interface + // returns a pointer to the first not used character + + uint *dest_num, // store result here, never NULL + ccp src, // pointer to source string, modified + ccp src_end, // NULL or end of 'src' + uint intbase, // integer base, 2..36 + int maxchar // max number of digits to read +); + +//----------------------------------------------------------------------------- + +char * ScanEscape +( + // returns a pointer to the first not used character + + uint *dest_code, // store result here, never NULL + ccp src, // pointer to source string (behind escape char) + ccp src_end // NULL or end of 'src' +); + +//----------------------------------------------------------------------------- + +uint ScanHexString +( + // return the number of written bytes + + void *buf, // write scanned data here + uint buf_size, // size of buf + ccp *source, // pointer to source string, modified + ccp end_source, // NULL or end of 'source' + bool allow_tie // allow chars ' .:-' and TAB,VT as byte separator +); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +char * ScanS32 +( + // return 'source' on error + + s32 *res_num, // not NULL: store result (only on success) + ccp source, // NULL or source text + uint default_base // base for numbers without '0x' prefix + // 0: C like with octal support + // 10: standard value for decimal numbers + // 16: standard value for hex numbers +); + +static inline char * ScanU32 ( u32 *res_num, ccp source, uint default_base ) + { return ScanS32((s32*)res_num,source,default_base); } + +//----------------------------------------------------------------------------- + +char * ScanS64 +( + // return 'source' on error + + s64 *res_num, // not NULL: store result (only on success) + ccp source, // NULL or source text + uint default_base // base for numbers without '0x' prefix + // 0: C like with octal support + // 10: standard value for decimal numbers + // 16: standard value for hex numbers +); + +static inline char * ScanU64 ( u64 *res_num, ccp source, uint default_base ) + { return ScanS64((s64*)res_num,source,default_base); } + +//----------------------------------------------------------------------------- + +#if __WORDSIZE >= 64 + + static inline char * ScanINT ( int *res_num, ccp source, uint default_base ) + { return ScanS32((s32*)res_num,source,default_base); } + static inline char * ScanUINT ( uint *res_num, ccp source, uint default_base ) + { return ScanS32((s32*)res_num,source,default_base); } + +#else + + static inline char * ScanINT ( int *res_num, ccp source, uint default_base ) + { return ScanS64((s64*)res_num,source,default_base); } + static inline char * ScanUINT ( uint *res_num, ccp source, uint default_base ) + { return ScanS64((s64*)res_num,source,default_base); } + +#endif + +//----------------------------------------------------------------------------- +// strto*() replacements: Use Scan*() with better base support, NULL allowed as source + +long int str2l ( const char *nptr, char **endptr, int base ); +long long int str2ll ( const char *nptr, char **endptr, int base ); +unsigned long int str2ul ( const char *nptr, char **endptr, int base ); +unsigned long long int str2ull ( const char *nptr, char **endptr, int base ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// print numbers and size /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sizeform_mode_t]] + +typedef enum sizeform_mode_t +{ + DC_SFORM_ALIGN = 0x01, // aligned output + DC_SFORM_NARROW = 0x02, // suppress space between number and unit + DC_SFORM_UNIT1 = 0x04, // limit unit to 1 character (space for bytes) + DC_SFORM_INC = 0x08, // increment to next factor if no fraction is lost + DC_SFORM_PLUS = 0x10, // on signed output: print PLUS sign for values >0 + DC_SFORM_DASH = 0x20, // on NULL: print only a dash (minus sign) + + DC_SFORM__MASK = 0x3f, // mask of above + DC_SFORM__AUTO = 0x40, // hint for some functions to decide by themself + + DC_SFORM_TINY = DC_SFORM_NARROW | DC_SFORM_UNIT1, +} +sizeform_mode_t; + +/////////////////////////////////////////////////////////////////////////////// + +float RoundF2bytes ( float f ); +float RoundF3bytes ( float f ); +double RoundD6bytes ( double d ); +double RoundD7bytes ( double d ); + +/////////////////////////////////////////////////////////////////////////////// + +char * PrintNumberU4 ( char *buf, size_t buf_size, u64 num, sizeform_mode_t mode ); +char * PrintNumberU5 ( char *buf, size_t buf_size, u64 num, sizeform_mode_t mode ); +char * PrintNumberU6 ( char *buf, size_t buf_size, u64 num, sizeform_mode_t mode ); +char * PrintNumberU7 ( char *buf, size_t buf_size, u64 num, sizeform_mode_t mode ); + +char * PrintNumberS5 ( char *buf, size_t buf_size, s64 num, sizeform_mode_t mode ); +char * PrintNumberS6 ( char *buf, size_t buf_size, s64 num, sizeform_mode_t mode ); +char * PrintNumberS7 ( char *buf, size_t buf_size, s64 num, sizeform_mode_t mode ); + +char * PrintNumberD5 ( char *buf, size_t buf_size, double num, sizeform_mode_t mode ); +char * PrintNumberD6 ( char *buf, size_t buf_size, double num, sizeform_mode_t mode ); +char * PrintNumberD7 ( char *buf, size_t buf_size, double num, sizeform_mode_t mode ); + +// Parameters: +// char *buf, // result buffer +// // NULL: use a local circulary static buffer +// size_t buf_size, // size of 'buf', ignored if buf==NULL +// * num, // number to print +// sizeform_mode_t mode // any of DC_SFORM_ALIGN, DC_SFORM_DASH[not *D*()] + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[size_mode_t]] + +typedef enum size_mode_t +{ + //----- modes => used as index for dc_size_tab_1000[] & dc_size_tab_1024[] + + DC_SIZE_DEFAULT = 0, // special default value, fall back to AUTO + DC_SIZE_AUTO, // select unit automatically + + DC_SIZE_BYTES, // force output in bytes + DC_SIZE_K, // force output in KB or KiB (kilo,kibi) + DC_SIZE_M, // force output in MB or MiB (mega,mebi) + DC_SIZE_G, // force output in GB or GiB (giga,gibi) + DC_SIZE_T, // force output in TB or TiB (tera,tebi) + DC_SIZE_P, // force output in PB or PiB (peta,pebi) + DC_SIZE_E, // force output in EB or EiB (exa, exbi) + // zetta/zebi & yotta/yobi not supported because >2^64 + + DC_SIZE_N_MODES, // number of modes + + //----- flags + + DC_SIZE_F_1000 = 0x010, // force output in SI units (kB=1000, MB=1000000,...) + DC_SIZE_F_1024 = 0x020, // force output in IEC units (KiB=1024, MiB=1024*1024,...) + DC_SIZE_F_AUTO_UNIT = 0x040, // suppress output of unit for non AUTO mode + DC_SIZE_F_NO_UNIT = 0x080, // suppress allways output of unit + + //----- masks + + DC_SIZE_M_MODE = 0x00f, // mask for modes + DC_SIZE_M_BASE = 0x030, // mask for base + DC_SIZE_M_ALL = 0x0ff, // all relevant bits +} +size_mode_t; + +//----------------------------------------------------------------------------- + +extern ccp dc_size_tab_1000[DC_SIZE_N_MODES+1]; +extern ccp dc_size_tab_1024[DC_SIZE_N_MODES+1]; + +//----------------------------------------------------------------------------- + +ccp GetSizeUnit // get a unit for column headers +( + size_mode_t mode, // print mode + ccp if_invalid // output for invalid modes +); + +//----------------------------------------------------------------------------- + +int GetSizeFW // get a good value field width +( + size_mode_t mode, // print mode + int min_fw // minimum fw => return max(calc_fw,min_fw); + // this value is also returned for invalid modes +); + +//----------------------------------------------------------------------------- + +char * PrintSize +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 size, // size to print + sizeform_mode_t sform_mode, // output format, bit field + size_mode_t mode // print mode +); + +//----------------------------------------------------------------------------- + +char * PrintSize1000 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 size, // size to print + sizeform_mode_t sform_mode // output format, bit field +); + +//----------------------------------------------------------------------------- + +char * PrintSize1024 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 size, // size to print + sizeform_mode_t sform_mode // output format, bit field +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// scan size /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern u64 (*ScanSizeFactorHook) +( + char ch_factor, // char to analyze + int force_base // if 1000|1024: force multiple of this +); + +u64 ScanSizeFactor +( + char ch_factor, // char to analyze + int force_base // if 1000|1024: force multiple of this +); + +char * ScanSizeTerm +( + double *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + int force_base // if 1000|1024: force multiple of this +); + +char * ScanSize +( + double *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base // if 1000|1024: force multiple of this +); + +char * ScanSizeU32 +( + u32 *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base // if 1000|1024: force multiple of this +); + +char * ScanSizeU64 +( + u64 *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base // if 1000|1024: force multiple of this +); + +//----------------------------------------------------------------------------- +// strto*() like wrappers + +u32 GetSizeU32 ( ccp src, char **end, int force_base ); +u64 GetSizeU64 ( ccp src, char **end, int force_base ); +double GetSizeD ( ccp src, char **end, int force_base ); + +//----------------------------------------------------------------------------- + +char * ScanSizeRange +( + int *stat, // if not NULL: store result + // 0:none, 1:single, 2:range + double *num1, // not NULL: store 'from' result + double *num2, // not NULL: store 'to' result + + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + double max_value // >0: max value for open ranges +); + +char * ScanSizeRangeU32 +( + int *stat, // if not NULL: store result + // 0:none, 1:single, 2:range + u32 *num1, // not NULL: store 'from' result + u32 *num2, // not NULL: store 'to' result + + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + u32 max_value // >0: max value for open ranges +); + +char * ScanSizeRangeU64 +( + int *stat, // if not NULL: store result + // 0:none, 1:single, 2:range + u64 *num1, // not NULL: store 'from' result + u64 *num2, // not NULL: store 'to' result + + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + u64 max_value // >0: max value for open ranges +); + +//----------------------------------------------------------------------------- + +char * ScanSizeRangeList +( + uint *n_range, // not NULL: store number of scanned ranges + double *num, // array with '2*max_range' elements + // unused elements are filled with 0.0 + uint max_range, // max number of allowed ranges + + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + double max_value // >0: max value for open ranges +); + +char * ScanSizeRangeListU32 +( + uint *n_range, // not NULL: store number of scanned ranges + u32 *num, // array with '2*max_range' elements + // unused elements are filled with 0 + uint max_range, // max number of allowed ranges + + ccp source, // source text + u32 default_factor, // use this factor if number hasn't one + u32 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + u32 max_value // >0: max value for open ranges +); + +char * ScanSizeRangeListU64 +( + uint *n_range, // not NULL: store number of scanned ranges + u64 *num, // array with '2*max_range' elements + // unused elements are filled with 0 + uint max_range, // max number of allowed ranges + + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + u64 max_value // >0: max value for open ranges +); + +//----------------------------------------------------------------------------- + +enumError ScanSizeOpt +( + double *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + u64 default_factor_add, // use this factor for summands + int force_base, // if 1000|1024: force multiple of this + + ccp opt_name, // NULL or name of option for error messages + u64 min, // >0: minimum allowed value + u64 max, // >0: maximum allowed value + bool print_err // true: print error messages +); + +enumError ScanSizeOptU64 +( + u64 *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + int force_base, // if 1000|1024: force multiple of this + + ccp opt_name, // NULL or name of option for error messages + u64 min, // >0: minimum allowed value + u64 max, // >0: maximum allowed value + u32 multiple, // >0: result must be multiple + u32 pow2, // >0: result must power of '1<<pow2' + bool print_err // true: print error messages +); + +enumError ScanSizeOptU32 +( + u32 *num, // not NULL: store result + ccp source, // source text + u64 default_factor, // use this factor if number hasn't one + int force_base, // if 1000|1024: force multiple of this + + ccp opt_name, // NULL or name of option for error messages + u64 min, // >0: minimum allowed value + u64 max, // >0: maximum allowed value + u32 multiple, // >0: result must be multiple + u32 pow2, // >0: result must power of '1<<pow2' + bool print_err // true: print error messages +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Scan Duration /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[ScanDuration_t]] + +typedef enum ScanDuration_t +{ + SDUMD_SKIP_BLANKS = 0x01, // skip leading blanks + SDUMD_ALLOW_COLON = 0x02, // allow 'H:M' and 'H:M:S' + SDUMD_ALLOW_DIV = 0x04, // allow fraction 'n/d' as number + + SDUMD_ALLOW_LIST = 0x10, // allow lists like '9h12m' + SDUMD_ALLOW_SPACE_SEP = 0x20, // lists: allow spaces as list separator + SDUMD_ALLOW_PLUS_SEP = 0x40, // lists: allow '+' as list separator + SDUMD_ALLOW_MINUS_SEP = 0x80, // lists: allow '-' as list separator + + SDUMD_M_ALL = 0xf7, +} +ScanDuration_t; + +//----------------------------------------------------------------------------- + +char * ScanDuration +( + double *num, // not NULL: store result + ccp source, // source text + double default_factor, // default factor if no SI unit found + ScanDuration_t mode +); + +double GetDurationFactor ( char ch ); + +char * ScanSIFactor +( + // returns end of scanned string + + double *num, // not NULL: store result + ccp source, // source text + double default_factor // return this if no factor found +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// time & timer /////////////// +/////////////////////////////////////////////////////////////////////////////// + +//--- conversion factors + +#define SEC_PER_MIN 60 +#define SEC_PER_HOUR 3600 +#define SEC_PER_DAY 86400 +#define SEC_PER_WEEK 604800 + +#define MSEC_PER_SEC 1000ull +#define MSEC_PER_MIN (60*MSEC_PER_SEC) +#define MSEC_PER_HOUR (3600*MSEC_PER_SEC) +#define MSEC_PER_DAY (SEC_PER_DAY*MSEC_PER_SEC) +#define MSEC_PER_WEEK (SEC_PER_WEEK*MSEC_PER_SEC) + +#define USEC_PER_MSEC 1000ull +#define USEC_PER_SEC 1000000ull +#define USEC_PER_MIN (60*USEC_PER_SEC) +#define USEC_PER_HOUR (3600*USEC_PER_SEC) +#define USEC_PER_DAY (SEC_PER_DAY*USEC_PER_SEC) +#define USEC_PER_WEEK (SEC_PER_WEEK*USEC_PER_SEC) + +//--- time types + +typedef uint u_sec_t; // unsigned type to store time as seconds +typedef int s_sec_t; // signed type to store time as seconds +typedef u64 u_msec_t; // unsigned type to store time as milliseconds +typedef s64 s_msec_t; // signed type to store time as milliseconds +typedef u64 u_usec_t; // unsigned type to store time as microseconds +typedef s64 s_usec_t; // signed type to store time as microseconds + +// [[DayTime_t]] +typedef struct DayTime_t +{ + time_t time; // seconds since epoch, like time() + int day; // days since epoch + int hour; // hour of day + int min; // minute of hour + int sec; // second of minute + int usec; // microsecond of second +} +DayTime_t; + +//--- only valid after call to SetupTimezone() + +extern s64 timezone_adjust_sec; +extern s64 timezone_adjust_usec; +extern int timezone_adjust_isdst; + +/////////////////////////////////////////////////////////////////////////////// + +void SetupTimezone ( bool force ); + +struct timeval GetTimeOfDay ( bool localtime ); +DayTime_t GetDayTime ( bool localtime ); +u_sec_t GetTimeSec ( bool localtime ); +u_msec_t GetTimeMSec ( bool localtime ); +u_usec_t GetTimeUSec ( bool localtime ); + +u_msec_t GetTimerMSec(void); +u_usec_t GetTimerUSec(void); + +static inline u64 double2msec ( double d ) { return d>0.0 ? (u64)trunc( 1e3*d+0.5 ) : 0; } +static inline u64 double2usec ( double d ) { return d>0.0 ? (u64)trunc( 1e6*d+0.5 ) : 0; } + +static inline double msec2double ( u64 num ) { return num * 1e-3; } +static inline double usec2double ( u64 num ) { return num * 1e-6; } + +//--- another epoch: Monday, 2001-01-01 + +#define EPOCH_2001_SEC 0x3a4fc880 +#define EPOCH_2001_MSEC (EPOCH_2001_SEC*MSEC_PER_SEC) +#define EPOCH_2001_USEC (EPOCH_2001_SEC*USEC_PER_SEC) + +/////////////////////////////////////////////////////////////////////////////// + +ccp PrintTimeByFormat +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + time_t time // seconds since epoch -> time() +); + +ccp PrintTimeByFormatUTC +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + time_t time // seconds since epoch -> time() +); + +//----------------------------------------------------------------------------- + +ccp PrintUsecByFormat +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + time_t time, // seconds since epoch -> time() + uint usec // micro second of second +); + +ccp PrintUsecByFormatUTC +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + time_t time, // seconds since epoch -> time() + uint usec // micro second of second +); + +//----------------------------------------------------------------------------- + + +ccp PrintTimevalByFormat +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + const struct timeval *tv // time to print, if NULL use gettimeofday() +); + + +ccp PrintTimevalByFormatUTC +( + // returns temporary buffer by GetCircBuf(); + + ccp format, // format string for strftime() + const struct timeval *tv // time to print, if NULL use gettimeofday() +); + +/////////////////////////////////////////////////////////////////////////////// + +ccp PrintTimeSec +( + char * buf, // result buffer (>19 bytes are good) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_sec_t sec // seconds (=time) to print +); + +//----------------------------------------------------------------------------- + +ccp PrintTimeMSec +( + char * buf, // result buffer (>23 bytes are good) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_msec_t msec, // milliseconds to print + uint fraction // number of digits (0-3) to print as fraction +); + +//----------------------------------------------------------------------------- + +ccp PrintTimeUSec +( + char * buf, // result buffer (>26 bytes are good) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_usec_t usec, // microseconds to print + uint fraction // number of digits (0-6) to print as fraction +); + +//----------------------------------------------------------------------------- + +ccp PrintTimerMSec +( + char * buf, // result buffer (>12 bytes are good) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 msec, // milliseconds to print + uint fraction // number of digits (0-3) to print as fraction +); + +ccp PrintTimerUSec +( + char * buf, // result buffer (>16 bytes are good) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + s_usec_t usec, // microseconds to print + uint fraction // number of digits (0-3) to print as fraction +); + +//----------------------------------------------------------------------------- + +ccp PrintTimer3 // helper function +( + char * buf, // result buffer (>3 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 sec, // seconds to print + int usec, // 0...999999: usec fraction, otherwise suppress ms/us output + bool aligned // true: print aligned 3 character output +); + +static inline ccp PrintTimerSec3 +( + char * buf, // result buffer (>3 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_sec_t sec, // seconds to print + bool aligned // true: print aligned 3 character output +) +{ + return PrintTimer3(buf,buf_size,sec,-1,aligned); +} + +static inline ccp PrintTimerMSec3 +( + char * buf, // result buffer (>3 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_msec_t msec, // microseconds to print + bool aligned // true: print aligned 3 character output +) +{ + return PrintTimer3(buf,buf_size,msec/1000,msec%1000*1000,aligned); +} + +static inline ccp PrintTimerUSec3 +( + char * buf, // result buffer (>3 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_usec_t usec, // microseconds to print + bool aligned // true: print aligned 3 character output +) +{ + return PrintTimer3(buf,buf_size,usec/1000000,usec%1000000,aligned); +} + +//----------------------------------------------------------------------------- + +ccp PrintTimer4 // helper function +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 sec, // seconds to print + int usec, // 0...999999: usec fraction, otherwise suppress ms/us output + bool aligned // true: print aligned 4 character output +); + +static inline ccp PrintTimerSec4 +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_sec_t sec, // seconds to print + bool aligned // true: print aligned 4 character output +) +{ + return PrintTimer4(buf,buf_size,sec,-1,aligned); +} + +static inline ccp PrintTimerMSec4 +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_msec_t msec, // microseconds to print + bool aligned // true: print aligned 4 character output +) +{ + return PrintTimer4(buf,buf_size,msec/1000,msec%1000*1000,aligned); +} + +static inline ccp PrintTimerUSec4 +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_usec_t usec, // microseconds to print + bool aligned // true: print aligned 4 character output +) +{ + return PrintTimer4(buf,buf_size,usec/1000000,usec%1000000,aligned); +} + +//----------------------------------------------------------------------------- + +ccp PrintTimer6 // helper function +( + char * buf, // result buffer (>6 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u64 sec, // seconds to print + int usec, // 0...999999: usec fraction, + // otherwise suppress ms/us output + bool aligned // true: print aligned 6 character output +); + +static inline ccp PrintTimerSec6 +( + char * buf, // result buffer (>6 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_sec_t sec, // seconds to print + bool aligned // true: print aligned 6 character output +) +{ + return PrintTimer6(buf,buf_size,sec,-1,aligned); +} + +static inline ccp PrintTimerMSec6 +( + char * buf, // result buffer (>6 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_msec_t msec, // microseconds to print + bool aligned // true: print aligned 6 character output +) +{ + return PrintTimer6(buf,buf_size,msec/1000,msec%1000*1000,aligned); +} + +static inline ccp PrintTimerUSec6 +( + char * buf, // result buffer (>6 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + u_usec_t usec, // microseconds to print + bool aligned // true: print aligned 6 character output +) +{ + return PrintTimer6(buf,buf_size,usec/1000000,usec%1000000,aligned); +} + +//----------------------------------------------------------------------------- + +ccp PrintTimerUSec4s +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + s_usec_t usec, // microseconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +); + +static inline ccp PrintTimerMSec4s +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + s_msec_t msec, // milliseconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +) +{ + return PrintTimerUSec4s(buf,buf_size,1000*msec,mode); +} + +static inline ccp PrintTimerSec4s +( + char * buf, // result buffer (>4 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + int sec, // seconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +) +{ + return PrintTimerUSec4s(buf,buf_size,1000000ll*sec,mode); +} + +//----------------------------------------------------------------------------- + +ccp PrintTimerUSec7s +( + char * buf, // result buffer (>7 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + s_usec_t usec, // microseconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +); + +static inline ccp PrintTimerMSec7s +( + char * buf, // result buffer (>7 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + s_msec_t msec, // milliseconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +) +{ + return PrintTimerUSec7s(buf,buf_size,1000*msec,mode); +} + +static inline ccp PrintTimerSec7s +( + char * buf, // result buffer (>7 bytes) + // If NULL, a local circulary static buffer is used + size_t buf_size, // size of 'buf', ignored if buf==NULL + int sec, // seconds to print + sizeform_mode_t mode // support of DC_SFORM_ALIGN, DC_SFORM_PLUS +) +{ + return PrintTimerUSec7s(buf,buf_size,1000000ll*sec,mode); +} + +//----------------------------------------------------------------------------- + +typedef struct xtime_t +{ + time_t time; + suseconds_t usec; + u64 total_usec; + u64 rel_usec; + +} xtime_t; + +u64 GetXTime ( xtime_t * xtime ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// scan date & time /////////////// +/////////////////////////////////////////////////////////////////////////////// + +// ScanInterval*() is old ==> try ScanDuration() + +char * ScanInterval +( + time_t *res_time, // not NULL: store seconds + u32 *res_usec, // not NULL: store micro seconds of second + ccp source // source text +); + +/////////////////////////////////////////////////////////////////////////////// + +char * ScanInterval64 +( + u64 *res_usec, // not NULL: store total micro seconds + ccp source // source text +); + +/////////////////////////////////////////////////////////////////////////////// + +char * ScanDateTime +( + time_t *res_time, // not NULL: store seconds + u32 *res_usec, // not NULL: store micro seconds of second + ccp source, // source text + bool allow_delta // true: allow +|- interval +); + +/////////////////////////////////////////////////////////////////////////////// + +char * ScanDateTime64 +( + u64 *res_usec, // not NULL: store total micro seconds + ccp source, // source text + bool allow_delta // true: allow +|- interval +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Since 2001 /////////////// +/////////////////////////////////////////////////////////////////////////////// + +// Values for day and week are exact. +// Values for month, quarter and year are based on 365.2425 days/year. + +//----------------------------------------------------------------------- +// name full/13 short/11 alt/10 tiny/8 +//----------------------------------------------------------------------- +// hour YYYY-MM-DD HH YY-MM-DD HH DD. HH:xx MM-DD HH +// day YYYY-MM-DD << << YY-MM-DD +// week YYYYwWW << << << +// month YYYY-MM << << << +// quarter YYYYqQ << << << +// year YYYY << << << +//----------------------------------------------------------------------- + +enum +{ + S2001_FW_FULL = 13, ///< Standard-Text mit vollem Jahr (maximal 13 Zeichen). + S2001_FW_SHORT = 11, ///< Verkürzte Stundenangabe (maximal 11 Zeichen). + S2001_FW_ALT = 10, ///< Alternative Stundenangabe mit »:xx« (maximal 10 Zeichen). + S2001_FW_TINY = 8, ///< Verkürzte Stunden- und Wochenangabe (maximal 8 Zeichen). + + S2001_DUR_HOUR = 3600, ///< Dauer einer Stunde in Sekunden. + S2001_DUR_DAY = 86400, ///< Dauer eines Tages in Sekunden. + S2001_DUR_WEEK = 604800, ///< Dauer einer Woche in Sekunden. + S2001_DUR_MONTH = 2629746, ///< Dauer eines Monats in Sekunden (365.2425/12 Tage). + S2001_DUR_QUARTER = 7889238, ///< Dauer eines Quartals in Sekunden (365.2425/4 Tage). + S2001_DUR_YEAR = 31556952, ///< Dauer eines Jahres in Sekunden (365.2425 Tage). +}; + +/////////////////////////////////////////////////////////////////////////// +// hour support + +static inline int time2hour ( s64 time ) + { return time / 3600 - 271752; } + +static inline double time2hourF ( s64 time ) + { return time / 3600.0 - 271752; } + +static inline s64 hour2time ( int hour ) + { return ( hour + 271752 ) * 3600; } + +static inline int hour2duration ( int hour ) + { return S2001_DUR_HOUR; } + +ccp hour2text +( + int hour, // hour to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // NULL or separator within date + // if NULL: use '-' + ccp sep_dt // NULL or separator of between date and time + // if NULL: use ' ' +); + +/////////////////////////////////////////////////////////////////////////// +// day support + +static inline int time2day ( s64 time ) + { return time / 86400 - 11323; } + +static inline double time2dayF ( s64 time ) + { return time / 86400.0 - 11323; } + +static inline s64 day2time ( int day ) + { return ( day + 11323 ) * 86400; } + +static inline int day2duration ( int day ) + { return S2001_DUR_DAY; } + +ccp day2text +( + int day, // day to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // NULL or separator within date + // if NULL: use '-' + ccp sep_dt // ignored +); + +/////////////////////////////////////////////////////////////////////////// +// week support + +static inline int time2week ( s64 time ) + { return ( time - 978307200 ) / 604800; } + +static inline double time2weekF ( s64 time ) + { return ( time - 978307200 ) / 604800.0; } + +static inline s64 week2time ( int week ) + { return week * 604800 + 978307200; } + +static inline int week2duration ( int week ) + { return S2001_DUR_WEEK; } + +ccp week2text +( + int week, // week to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // NULL or separator within date + // if NULL: use 'w' + ccp sep_dt // ignored +); + +/////////////////////////////////////////////////////////////////////////// +// month support + +int time2month ( time_t tim ); +time_t month2time ( int month ); + +static inline int month2duration ( int month ) + { return month2time(month+1) - month2time(month); } + +ccp month2text +( + int month, // month to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // NULL or separator within date + // if NULL: use '-' + ccp sep_dt // ignored +); + +/////////////////////////////////////////////////////////////////////////// +// quarter support + +int time2quarter ( time_t tim ); +time_t quarter2time ( int quarter ); + +static inline int quarter2duration ( int quarter ) + { return quarter2time(quarter+1) - quarter2time(quarter); } + +ccp quarter2text +( + int quarter, // quarter to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // NULL or separator within date + // if NULL: use 'q' + ccp sep_dt // ignored +); + +/////////////////////////////////////////////////////////////////////////// +// year support + +int time2year ( time_t tim ); +time_t year2time ( int year ); + +static inline int year2duration ( int year ) + { return year2time(year+1) - year2time(year); } + +static inline ccp year2text +( + int year, // year to print + int fw, // wanted field width assuming separators are 1 char + ccp sep_date, // ignored + ccp sep_dt // ignored +) +{ + return PrintCircBuf("%04d",year); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// sockaddr support /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[sockaddr_t]] [[sockaddr_in_t]] [[sockaddr_un_t]] [[sockaddr_info_t]] + +typedef struct sockaddr sockaddr_t; +typedef struct sockaddr_in sockaddr_in_t; +typedef struct sockaddr_un sockaddr_un_t; + +typedef struct sockaddr_info_t +{ + sockaddr_t *sa; // pointer to sockaddr or sockaddr_* + uint size; // size of '*sa' +} +sockaddr_info_t; + +//----------------------------------------------------------------------------- + +// [[doxygen]] +static inline sockaddr_info_t CreateSockaddrInfo ( cvp sa, uint size ) +{ + sockaddr_info_t i = + { + .sa = (sockaddr_t*)sa, + .size = size + }; + return i; +} + +//----------------------------------------------------------------------------- + +// [[doxygen]] +static inline void SetupSockaddrInfo ( sockaddr_info_t *sai, cvp sa, uint size ) +{ + DASSERT(sai); + sai->sa = (sockaddr_t*)sa; + sai->size = size ? size : sizeof(sockaddr_in_t); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// PrintIP4*() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define FW_IPV4_A 12 // 255.16777215 +#define FW_IPV4_B 13 // 255.255.65535 +#define FW_IPV4_C 15 // 255.255.255.255 + +#define FW_IPV4_PORT 5 // 65535 + +#define FW_IPV4_A_PORT (FW_IPV4_A+1+FW_IPV4_PORT) +#define FW_IPV4_B_PORT (FW_IPV4_B+1+FW_IPV4_PORT) +#define FW_IPV4_C_PORT (FW_IPV4_C+1+FW_IPV4_PORT) + +//----------------------------------------------------------------------------- + +char * PrintIP4A +( + // print in A-notation + + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port // 0..0xffff: add ':port' +); + +char * PrintIP4B +( + // print in A-notation + + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port // 0..0xffff: add ':port' +); + +//----------------------------------------------------------------------------- +// print in C-notation (usual notation) + +char * PrintIP4 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port // 0..0xffff: add ':port' +); + +char * PrintLeftIP4 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port // 0..0xffff: add ':port' +); + +char * PrintRightIP4 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port, // 0..0xffff: add ':port' + uint port_mode // 0: 'ip:port', 1: 'ip :port', 2: 'ip : port' +); + +char * PrintAlignedIP4 +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + u32 ip4, // IP4 to print + s32 port // 0..0xffff: add ':port' +); + +//----------------------------------------------------------------------------- +struct sockaddr_in; + +static inline char * PrintIP4sa +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + + const struct sockaddr_in *sa // socket address +) +{ + DASSERT(sa); + return PrintIP4(buf,buf_size, + ntohl(sa->sin_addr.s_addr), ntohs(sa->sin_port) ); +} + +static inline char * PrintRightIP4sa +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + + struct sockaddr_in *sa // socket address +) +{ + DASSERT(sa); + return PrintRightIP4(buf,buf_size, + ntohl(sa->sin_addr.s_addr), ntohs(sa->sin_port), 0 ); +} + +static inline char * PrintAlignedIP4sa +( + char *buf, // result buffer + // NULL: use a local circulary static buffer + size_t buf_size, // size of 'buf', ignored if buf==NULL + + struct sockaddr_in *sa // socket address +) +{ + DASSERT(sa); + return PrintAlignedIP4(buf,buf_size, + ntohl(sa->sin_addr.s_addr), ntohs(sa->sin_port) ); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// dynamic data support /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[DynData_t]] + +typedef struct DynData_t +{ + u8 *data; // pointer to data, alloced + uint len; // length of used data + uint size; // size of allocated data +} +DynData_t; + +//----------------------------------------------------------------------------- + +void ResetDD ( DynData_t *dd ); +void InsertDD ( DynData_t *dd, const void *data, uint data_size ); + +/////////////////////////////////////////////////////////////////////////////// +// [[DynDataList_t]] + +typedef struct DynDataList_t +{ + DynData_t *list; // pointer to the data list + uint used; // number of used data elements + uint size; // number of allocated pointer in 'list' +} +DynDataList_t; + +//----------------------------------------------------------------------------- + +void ResetDDL ( DynDataList_t *ddl ); + +DynData_t *InsertDDL +( + DynDataList_t *ddl, // valid dynamic data list + uint index, // element index to change + const void *data, // NULL or data to assign + uint data_size // size of data +); + +DynData_t *GetDDL +( + DynDataList_t *ddl, // valid dynamic data list + uint index, // element index to get + uint create // >0: create an empty element if not exist + // >index: create at least # elements +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct StringField_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[StringField_t]] + +typedef struct StringField_t +{ + ccp * field; // pointer to the string field + uint used; // number of used titles in the title field + uint size; // number of allocated pointer in 'field' + int (*func_cmp)( ccp s1, ccp s2 ); // compare function, default is strcmp() + +} StringField_t; + +//----------------------------------------------------------------------------- + +static inline void InitializeStringField ( StringField_t * sf ) + { DASSERT(sf); memset(sf,0,sizeof(*sf)); } + +void ResetStringField ( StringField_t * sf ); +void MoveStringField ( StringField_t * dest, StringField_t * src ); + +int FindStringFieldIndex ( const StringField_t * sf, ccp key, int not_found_value ); +ccp FindStringField ( const StringField_t * sf, ccp key ); + +// return: true if item inserted/deleted +bool InsertStringField ( StringField_t * sf, ccp key, bool move_key ); +bool RemoveStringField ( StringField_t * sf, ccp key ); +uint RemoveStringFieldByIndex ( StringField_t * sf, int index, int n ); + +// helper function +ccp * InsertStringFieldHelper ( StringField_t * sf, int idx ); + +// append at the end an do not sort +void AppendStringField ( StringField_t * sf, ccp key, bool move_key ); + +// re-sort field using sf->func_cmp() +void SortStringField ( StringField_t * sf ); + +// return the index of the (next) item +uint FindStringFieldHelper ( const StringField_t * sf, bool * found, ccp key ); + +// find first pattern that matches +ccp MatchStringField ( const StringField_t * sf, ccp key ); + +//----------------------------------------------------------------------------- +// file support + +enumError LoadStringField +( + StringField_t * sf, // string field + bool init_sf, // true: initialize 'sf' first + bool sort, // true: sort 'sf' + ccp filename, // filename of source file + bool silent // true: don't print open/read errors +); + +enumError SaveStringField +( + StringField_t * sf, // valid string field + ccp filename, // filename of dest file + bool rm_if_empty // true: rm dest file if 'sf' is empty +); + +enumError WriteStringField +( + FILE * f, // open destination file + ccp filename, // NULL or filename (needed on write error) + StringField_t * sf, // valid string field + ccp prefix, // not NULL: insert prefix before each line + ccp eol // end of line text (if NULL: use LF) +); + +//----------------------------------------------------------------------------- +// save-state support + +void SaveCurrentStateStringField +( + FILE *f, // output file + ccp name_prefix, // NULL or prefix of name, up to 40 chars + uint tab_pos, // tab pos of '=' + const StringField_t *sf, // valid string field + EncodeMode_t emode // encoding mode +); + +struct RestoreState_t; +void RestoreStateStringField +( + struct RestoreState_t *rs, // info data, may be modified + ccp name_prefix, // NULL or prefix of name, up to 40 chars + StringField_t *sf, // string field + bool init_sf, // true: initialize 'sf', otherwise reset + EncodeMode_t emode // encoding mode +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct ParamField_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[ParamFieldItem_t]] + +typedef struct ParamFieldItem_t +{ + ccp key; // string as main key + uint num; // user defined numeric parameter + void *data; // user defined pointer + +} ParamFieldItem_t; + +//----------------------------------------------------------------------------- +// [[ParamField_t]] + +typedef struct ParamField_t +{ + ParamFieldItem_t * field; // pointer to the string field + uint used; // number of used titles in the title field + uint size; // number of allocated pointer in 'field' + bool free_data; // true: unused data will be free'd + // initialized with 'false' + int (*func_cmp)( ccp s1, ccp s2 ); // compare function, default is strcmp() +} ParamField_t; + +//----------------------------------------------------------------------------- + +void InitializeParamField ( ParamField_t * pf ); +void ResetParamField ( ParamField_t * pf ); +void MoveParamField ( ParamField_t * dest, ParamField_t * src ); + +int FindParamFieldIndex ( const ParamField_t * pf, ccp key, int not_found_value ); +ParamFieldItem_t * FindParamField ( const ParamField_t * pf, ccp key ); +ParamFieldItem_t * FindParamFieldByNum ( const ParamField_t * pf, uint num ); +ParamFieldItem_t * FindInsertParamField + ( ParamField_t * pf, ccp key, bool move_key, bool *old_found ); +ParamFieldItem_t * CountParamField ( ParamField_t * pf, ccp key, bool move_key ); + +// return: true if item inserted/deleted +bool InsertParamField ( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data ); +bool ReplaceParamField( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data ); +bool RemoveParamField ( ParamField_t * pf, ccp key ); + +ParamFieldItem_t * InsertParamFieldEx + ( ParamField_t * pf, ccp key, bool move_key, uint num, bool *found ); + +// append at the end an do not sort +ParamFieldItem_t * AppendParamField + ( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data ); + +// return the index of the (next) item +uint FindParamFieldHelper ( const ParamField_t * pf, bool * found, ccp key ); + +// find first pattern that matches +ParamFieldItem_t * MatchParamField ( const ParamField_t * pf, ccp key ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Memory Map /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[MemMapItem_t]] + +typedef struct MemMapItem_t +{ + u64 off; // offset + u64 size; // size + u8 overlap; // system info: item overlaps other items + u8 index; // user defined index + char info[62]; // user defined info text + +} MemMapItem_t; + +//----------------------------------------------------------------------------- +// [[MemMap_t]] + +typedef struct MemMap_t +{ + MemMapItem_t ** field; // pointer to the item field + uint used; // number of used titles in the item field + uint size; // number of allocated pointer in 'field' + u64 begin; // first address + +} MemMap_t; + +//----------------------------------------------------------------------------- +// Memory maps allow duplicate entries. +// The off+size pair is used as key. +// The entries are sorted by off and size (small values first). +//----------------------------------------------------------------------------- + +void InitializeMemMap ( MemMap_t * mm ); +void ResetMemMap ( MemMap_t * mm ); + +void CopyMemMap +( + MemMap_t * mm1, // merged mem map, not NULL, cleared + const MemMap_t * mm2, // NULL or second mem map + bool use_tie // TRUE: use InsertMemMapTie() +); + +void MergeMemMap +( + MemMap_t * mm1, // merged mem map, not NULL, not cleared + const MemMap_t * mm2, // NULL or second mem map + bool use_tie // TRUE: use InsertMemMapTie() +); + +MemMapItem_t * FindMemMap +( + // returns NULL or the pointer to the one! matched key (={off,size}) + + MemMap_t * mm, + off_t off, + off_t size +); + +uint InsertMemMapIndex +( + // returns the index of the new item + + MemMap_t * mm, // mem map pointer + off_t off, // offset of area + off_t size // size of area +); + +MemMapItem_t * InsertMemMap +( + // returns a pointer to a new item (never NULL) + + MemMap_t * mm, // mem map pointer + off_t off, // offset of area + off_t size // size of area +); + +MemMapItem_t * InsertMemMapTie +( + // returns a pointer to a new or existing item (never NULL) + + MemMap_t * mm, // mem map pointer + off_t off, // offset of area + off_t size // size of area +); + +void InsertMemMapWrapper +( + void * param, // user defined parameter + u64 offset, // offset of object + u64 size, // size of object + ccp info // info about object +); + +// Remove all entires with key. Return number of delete entries +//uint RemoveMemMap ( MemMap_t * mm, off_t off, off_t size ); + +// Return the index of the found or next item +uint FindMemMapHelper ( MemMap_t * mm, off_t off, off_t size ); + +// Calculate overlaps. Return number of items with overlap. +uint CalcOverlapMemMap ( MemMap_t * mm ); + +u64 FindFreeSpaceMemMap +( + // return address or NULL on not-found + + const MemMap_t * mm, + u64 addr_beg, // first possible address + u64 addr_end, // last possible address + u64 size, // minimal size + u64 align, // aligning + u64 *space // not NULL: store available space here +); + +// Print out memory map +void PrintMemMap ( MemMap_t * mm, FILE * f, int indent, ccp info_head ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Memory Map: Scan addresses /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[ScanAddr_t]] + +typedef struct ScanAddr_t +{ + uint stat; // 0:invalid, 1:single address, 2:range + uint addr; // address + uint size; // size inf bytes + +} ScanAddr_t; + +//----------------------------------------------------------------------------- + +char * ScanAddress +( + // returns first not scanned char of 'arg' + + ScanAddr_t * result, // result, initialized by ScanAddress() + ccp arg, // format: ADDR | ADDR:END | ADDR#SIZE + uint default_base // base for numbers without '0x' prefix + // 0: C like with octal support + // 10: standard value for decimal numbers + // 16: standard value for hex numbers +); + +//----------------------------------------------------------------------------- + +uint InsertAddressMemMap +( + // returns the number of added addresses + + MemMap_t * mm, // mem map pointer + bool use_tie, // TRUE: use InsertMemMapTie() + ccp arg, // comma separated list of addresses + // formats: ADDR | ADDR:END | ADDR#SIZE + uint default_base // base for numbers without '0x' prefix + // 0: C like with octal support + // 10: standard value for decimal numbers + // 16: standard value for hex numbers +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// DataBuf_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +struct DataBuf_t; + +typedef enumError (*DataBufFill_t) +( + // function to fill the buffer + + struct DataBuf_t* db, // valid pointer to related DataBuf_t to fill + uint need, // number of bytes needed => wait for more data + int mode // user mode, null on auto fill +); + +//----------------------------------------------------------------------------- +// [[DataBuf_t]] + +typedef struct DataBuf_t +{ + uint size; // size of buffer + uint used; // number of used bytes + u64 offset; // current file offset, related to 'data' + + u8 *buf; // pointer to buffer, cyclic usage + u8 *buf_end; // pointer to buffer end := buf + size + + u8 *data; // pointer to data + u8 *data_end; // pointer to end of data + + //--- user data + + DataBufFill_t fill_func; // function to fill buffer + void *user_data; // NULL or pointer to user data for 'fill_func' +} +DataBuf_t; + +/////////////////////////////////////////////////////////////////////////////// +// management + +void InitializeDataBuf + ( DataBuf_t *db, uint buf_size, DataBufFill_t func, void *user_data ); +void ResetDataBuf ( DataBuf_t *db ); +void ResizeDataBuf ( DataBuf_t *db, uint new_buf_size ); +void ClearDataBuf ( DataBuf_t *db, uint new_buf_size_if_not_null ); +void EmptyDataBuf ( DataBuf_t *db ); +void PackDataBuf ( DataBuf_t *db ); + +/////////////////////////////////////////////////////////////////////////////// +// debugging + +bool IsValidDataBuf ( DataBuf_t *db ); +bool DumpDataBuf ( FILE *f, uint indent, DataBuf_t *db, bool if_invalid ); + +// fill the buffer with a test pattern: +// '-' for unused bytes +// ">0123456789<" in a longer or shorter form for used bytes +void FillPatternDataBuf ( DataBuf_t *db ); + +/////////////////////////////////////////////////////////////////////////////// +// insert and remove data + +static inline enumError FillDataBuf( DataBuf_t *db, uint need, int mode ) +{ + return db && db->fill_func ? db->fill_func(db,need,mode) : ERR_WARNING; +} + +uint InsertDataBuf +( + // Insert at top of buffer. + // Return the number of inserted bytes + + DataBuf_t *db, // valid pointer to data buffer + const void *data, // data to insert + uint data_size, // size of 'data' + bool all_or_none // true: insert complete data or nothing +); + +uint AppendDataBuf +( + // Append data at end of buffer + // Return the number of inserted bytes + + DataBuf_t *db, // valid pointer to data buffer + const void *data, // data to insert + uint data_size, // size of 'data' + bool all_or_none // true: insert complete data or nothing +); + +/////////////////////////////////////////////////////////////////////////////// + +void * GetPtrDataBuf +( + // Return a pointer to the data and make sure, + // that the data is not wrapped. Return NULL if failed. + + DataBuf_t *db, // valid pointer to data buffer + uint data_size, // number of needed bytes + uint align, // >1: Data alignment is also needed. + // Only 2,4,8,16,... are allowed, but not verified. + // Begin of buffer is always well aligned. + bool drop // true: On success, drop data from buffer + // In real, the data is available and only + // the pointers and counters are updated. +); + +uint CopyDataBuf +( + // Copy data from buffer, but don't remove it + // Return the number of copied bytes + + DataBuf_t *db, // valid pointer to data buffer + void *dest, // destination buffer wit at least 'max_size' space + uint min_read, // return with 0 read bytes if less bytes available + // if 'min_read' > 'size', NULL is returned + uint max_read // try to read upto 'max_read' bytes +); + +uint GetDataBuf +( + // Copy data from buffer and remove it + // Return the number of copied bytes + + DataBuf_t *db, // valid pointer to data buffer + void *dest, // destination buffer wit at least 'max_size' space + uint min_read, // return with 0 read bytes if less bytes available + uint max_read // try to read upto 'max_read' bytes +); + +uint SkipDataBuf +( + // Skip 'skip_size' from input stream. Read more data if needed. + // Return the number of really skiped bytes + // If <skip_size is returned, no more data is available. + + DataBuf_t *db, // valid pointer to data buffer + uint skip_size // number of bytes to drop +); + +uint DropDataBuf +( + // Remove upto 'drop_size' bytes from buffer. + // Return the number of dropped bytes. + + DataBuf_t *db, // valid pointer to data buffer + uint drop_size // number of bytes to drop +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ResizeElement_t, ResizeHelper_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct ResizeElement_t +{ + uint n_elem; + uint factor; +} +ResizeElement_t; + +//----------------------------------------------------------------------------- + +typedef struct ResizeHelper_t +{ + //--- basic data + + uint src_size; // size of source + uint dest_size; // size of dest + + + //--- calculated data + + uint sum_factor; // sum of all factors + uint half_factor; // half of 'sum_factor2' + + uint idx_inc; // increment of 'src_idx' + uint frac_inc; // increment of 'src_frac' + uint frac_next; // if 'frac>=frac_next': increment 'src_idx' + + + //--- iteration data + + uint dest_idx; // dest index: (0..dest_size( + uint src_idx; // src index: (0..src_size( + uint src_frac; // (0..frac_next( + + ResizeElement_t // list terminates with n_elem=0 + elem[4]; // ==> max 3 elements are used + +} +ResizeHelper_t; + +//----------------------------------------------------------------------------- + +void InitializeResize +( + ResizeHelper_t *r, // data structure + uint s_size, // size of source + uint d_size // size of dest +); + +bool FirstResize ( ResizeHelper_t *r ); +bool NextResize ( ResizeHelper_t *r ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// restore configuration /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[RestoreStateLog_t]] + +typedef enum RestoreStateLog_t +{ + RSL_WARNINGS = 0x01, // general warnings + RSL_MISSED_NAMES = 0x02, // hints about missed names + RSL_UNUSED_NAMES = 0x04, // hints about unused names + + RSL_ALL = 0x07 // all flags +} +RestoreStateLog_t; + +//----------------------------------------------------------------------------- +// [[RestoreState_t]] + +typedef struct RestoreState_t +{ + ccp sect; // section name + ccp path; // section sub path + int index; // index or -1 + ParamField_t param; // name=value parameters + cvp user_param; // pointer provided as parameter by user + cvp user_info; // pointer to deliver insfos between stages + + RestoreStateLog_t log_mode; // log mode + FILE *log_file; // log file + +} +RestoreState_t; + +//----------------------------------------------------------------------------- + +typedef void (*RestoreStateFunc) +( + RestoreState_t *rs, // info data, can be modified (cleaned after call) + cvp user_table // pointer provided by RestoreStateTab_t[] +); + +//----------------------------------------------------------------------------- + +typedef struct RestoreStateTab_t +{ + ccp name; // name of section + RestoreStateFunc func; // function to call + cvp user_table; // any user provided pointer +} +RestoreStateTab_t; + +/////////////////////////////////////////////////////////////////////////////// + +enumError RestoreState +( + const RestoreStateTab_t + *table, // section table, terminated by name==0 + void *data, // file data, modified, terminated by NULL or LF + uint size, // size of file data + RestoreStateLog_t log_mode, // print warnings (bit field) + FILE *log_file, // error file; if NULL use stderr + cvp user_param // pointer provided by user +); + +/////////////////////////////////////////////////////////////////////////////// + +// print into cyclic buffer +ccp PrintRestoreStateSection ( const RestoreState_t *rs ); + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +ParamFieldItem_t * GetParamField +( + const RestoreState_t *rs, // valid restore-state structure + ccp name // name of member +); + +//----------------------------------------------------------------------------- + +int GetParamFieldINT +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + int not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +uint GetParamFieldUINT +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + uint not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +u64 GetParamFieldS64 +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + s64 not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +u64 GetParamFieldU64 +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + u64 not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +float GetParamFieldFLOAT +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + float not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +double GetParamFieldDBL +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + double not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +long double GetParamFieldLDBL +( + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + long double not_found // return this value if not found +); + +//----------------------------------------------------------------------------- + +int GetParamFieldBUF +( + // returns >=0: length of read data; -1:nothing done (not_found==NULL) + + char *buf, // buffer to store result + uint buf_size, // size of buffer + + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + EncodeMode_t decode, // decoding mode, fall back to OFF + // supported: STRING, UTF8, BASE64, BASE64X + ccp not_found // not NULL: store this value if not found +); + +//----------------------------------------------------------------------------- + +mem_t GetParamFieldMEM +( + // Returns the decoded 'source'. Result is NULL-terminated. + // It points either to 'buf' or is alloced (on buf==NULL or to less space) + // If alloced (mem.ptr!=buf) => call FreeMem(&mem) + + char *buf, // buffer to store result + uint buf_size, // size of buffer + + const RestoreState_t *rs, // valid restore-state structure + ccp name, // name of member + EncodeMode_t decode, // decoding mode, fall back to OFF + // supported: STRING, UTF8, BASE64, BASE64X + mem_t not_found // not NULL: return this value +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// save + restore config by table /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[SaveRestoreType_t]] + +typedef enum SaveRestoreType_t +{ + SRT__TERM, // list terminator + + SRT_BOOL, // type bool + SRT_UINT, // unsigned int of any size (%llu) + SRT_HEX, // unsigned int of any size as hex (%#llx) + SRT_INT, // signed int of any size (%lld) + SRT_FLOAT, // float (%.8g) or double (%.16g) or long double (%.20g) + SRT_XFLOAT, // float or double or long double as hex-float (%a/%La) + + SRT_STRING_SIZE, // string with max size, var is char[] + SRT_STRING_ALLOC, // alloced string, var is ccp or char* + SRT_MEM, // alloced string, var is mem_t + + SRT__IS_LIST, //----- from here: print lists; also used as separator + + SRT_STRING_FIELD, // var is StringField_t + SRT_PARAM_FIELD, // var is ParamField_t +} +SaveRestoreType_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[SaveRestoreTab_t]] + +typedef struct SaveRestoreTab_t +{ + uint offset; // offset of variable + uint size; // sizeof( var or string ) + ccp name; // name in configuration file + u16 n_elem; // >0: is array with N elements + u8 type; // SaveRestoreType_t + u8 emode; // EncodeMode_t +} +__attribute__ ((packed)) SaveRestoreTab_t; + +//----------------------------------------------------------------------------- + +// At the very beginning of the table, define 'SRT_NAME' by 2 lines: +// #undef SRT_NAME +// #define SRT_NAME name_of_the_struct + +#define DEF_SRT_VAR(v,ne,n,t,e) {offsetof(SRT_NAME,v),sizeof(((SRT_NAME*)0)->v),n,ne,t,e} + +#define DEF_SRT_BOOL(v,n) DEF_SRT_VAR(v,1,n,SRT_BOOL,0) +#define DEF_SRT_UINT(v,n) DEF_SRT_VAR(v,1,n,SRT_UINT,0) +#define DEF_SRT_HEX(v,n) DEF_SRT_VAR(v,1,n,SRT_HEX,0) +#define DEF_SRT_INT(v,n) DEF_SRT_VAR(v,1,n,SRT_INT,0) +#define DEF_SRT_FLOAT(v,n) DEF_SRT_VAR(v,1,n,SRT_FLOAT,0) +#define DEF_SRT_XFLOAT(v,n) DEF_SRT_VAR(v,1,n,SRT_XFLOAT,0) + +#define DEF_SRT_STR_SIZE(v,n,e) DEF_SRT_VAR(v,1,n,SRT_STRING_SIZE,e) +#define DEF_SRT_STR_ALLOC(v,n,e) DEF_SRT_VAR(v,1,n,SRT_STRING_ALLOC,e) +#define DEF_SRT_MEM(v,n,e) DEF_SRT_VAR(v,1,n,SRT_MEM,e) +#define DEF_SRT_STRING_FIELD(v,n,e) DEF_SRT_VAR(v,1,n,SRT_STRING_FIELD,e) +#define DEF_SRT_PARAM_FIELD(v,n,e) DEF_SRT_VAR(v,1,n,SRT_PARAM_FIELD,e) + +#define DEF_SRT_BOOL_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_BOOL,0) +#define DEF_SRT_UINT_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_UINT,0) +#define DEF_SRT_HEX_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_HEX,0) +#define DEF_SRT_INT_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_INT,0) +#define DEF_SRT_FLOAT_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_FLOAT,0) +#define DEF_SRT_XFLOAT_N(v,ne,n) DEF_SRT_VAR(v,ne,n,SRT_XFLOAT,0) + +#define DEF_SRT_ARRAY(v,n,t,e) \ + {offsetof(SRT_NAME,v), sizeof(((SRT_NAME*)0)->v[0]), n, \ + sizeof(((SRT_NAME*)0)->v)/sizeof(*((SRT_NAME*)0)->v), t, e } + +#define DEF_SRT_BOOL_A(v,n) DEF_SRT_ARRAY(v,n,SRT_BOOL,0) +#define DEF_SRT_UINT_A(v,n) DEF_SRT_ARRAY(v,n,SRT_UINT,0) +#define DEF_SRT_HEX_A(v,n) DEF_SRT_ARRAY(v,n,SRT_HEX,0) +#define DEF_SRT_INT_A(v,n) DEF_SRT_ARRAY(v,n,SRT_INT,0) +#define DEF_SRT_FLOAT_A(v,n) DEF_SRT_ARRAY(v,n,SRT_FLOAT,0) +#define DEF_SRT_XFLOAT_A(v,n) DEF_SRT_ARRAY(v,n,SRT_XFLOAT,0) + +#define DEF_SRT_SEPARATOR() {0,0,0,0,SRT__IS_LIST,0} +#define DEF_SRT_COMMENT(c) {0,0,c,0,SRT__IS_LIST,0} +#define DEF_SRT_TERM() {0,0,0,0,SRT__TERM,0} + +/////////////////////////////////////////////////////////////////////////////// + +void DumpStateTable +( + FILE *f, // valid output file + int indent, + const SaveRestoreTab_t + *srt // list of variables +); + +void SaveCurrentStateByTable +( + FILE *f, // valid output file + cvp data0, // valid pointer to source struct + const SaveRestoreTab_t + *srt, // list of variables + ccp prefix, // NULL or prefix for names + uint fw_name // field width of name, 0=AUTO + // tabs are used for multiple of 8 and for AUTO +); + +void RestoreStateByTable +( + RestoreState_t *rs, // info data, can be modified (cleaned after call) + void *data0, // valid pointer to destination struct + const SaveRestoreTab_t + *srt, // list of variables + ccp prefix // NULL or prefix for names +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// GrowBuffer_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[GrowBuffer_t]] + +typedef struct GrowBuffer_t +{ + // allways: gb->ptr[gb->used] == 0 + + u8 *buf; // NULL or data buffer + uint size; // size of 'buf' + uint grow_size; // >0: auto grow buffer by multiple of this + uint max_size; // >0: max size for auto grow + + u8 *ptr; // pointer to first valid byte + uint used; // number of valid bytes behind 'ptr' + uint max_used; // max 'used' value + + uint disabled; // disable rading from TCP socket +} +GrowBuffer_t; + +/////////////////////////////////////////////////////////////////////////////// + +void LogGrowBuffer +( + FILE *f, // output file + int indent, // indention + const GrowBuffer_t *gb, // valid grow-buffer + ccp format, // format string for vfprintf() + ... // arguments for 'vfprintf(format,...)' +) +__attribute__ ((__format__(__printf__,4,5))); + +//----------------------------------------------------------------------------- + +void InitializeGrowBuffer ( GrowBuffer_t *gb, uint max_buf_size ); +void ResetGrowBuffer ( GrowBuffer_t *gb ); +uint ClearGrowBuffer ( GrowBuffer_t *gb ); // returns available space +uint PurgeGrowBuffer ( GrowBuffer_t *gb ); // returns available space + +//----------------------------------------------------------------------------- + +uint GetSpaceGrowBuffer +( + // returns the maximum possible space + const GrowBuffer_t *gb // valid grow-buffer object +); + +//----------------------------------------------------------------------------- + +uint PrepareGrowBuffer +( + // returns the number of available space, smaller than or equal 'size' + + GrowBuffer_t *gb, // valid grow-buffer object + uint size, // needed size + bool force // always alloc enough space and return 'size' +); + +uint InsertGrowBuffer +( + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + const void *data, // data to insert + uint size // size of 'data' +); + +static inline uint InsertCharGrowBuffer +( + // returns the number of inserted bytes (0 on fail, 1 else) + + GrowBuffer_t *gb, // valid grow-buffer object + char ch // any character including NULL +) +{ + return InsertGrowBuffer(gb,&ch,1); +} + +static inline uint InsertMemGrowBuffer +( + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + mem_t mem // any data +) +{ + return InsertGrowBuffer(gb,mem.ptr,mem.len); +} + +uint InsertCapNGrowBuffer +( + // insert 'cap_1' or 'cap_n' depending of 'n' and the existence of 'cap_*' + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + int n, // repeat number; if <1: insert nothing + mem_t cap_1, // default for N=1 + mem_t cap_n // default for N>1 +); + +uint WriteCapN +( + // print 'cap_1' or 'cap_n' depending of 'n' and the existence of 'cap_*' + // returns the number of printed bytes + + FILE *f, // valid FILE + int n, // repeat number; if <1: insert nothing + mem_t cap_1, // default for N=1 + mem_t cap_n // default for N>1 +); + +uint InsertCatchedGrowBuffer +( + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + SavedStdFiles_t *ssf // saved output and catched data +); + +/////////////////////////////////////////////////////////////////////////////// + +uint PrintArgGrowBuffer +( + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + ccp format, // format string for vfprintf() + va_list arg // arguments for 'vsnprintf(format,...)' +); + +uint PrintGrowBuffer +( + // returns the number of inserted bytes + + GrowBuffer_t *gb, // valid grow-buffer object + ccp format, // format string for vfprintf() + ... // arguments for 'vsnprintf(format,...)' +) +__attribute__ ((__format__(__printf__,2,3))); + +//----------------------------------------------------------------------------- + +uint ConvertToCrLfGrowBuffer +( + // returns the number of inserted CR bytes + + GrowBuffer_t *gb, // valid grow-buffer object + uint begin // index to begin with conversion +); + +//----------------------------------------------------------------------------- + +uint DropGrowBuffer +( + // returns the number of dropped bytes + + GrowBuffer_t *gb, // valid grow-buffer object + uint size // number of bytes to drop +); + +//----------------------------------------------------------------------------- +#ifndef __APPLE__ + +FILE * OpenFileGrowBuffer +( + // returns a FILE opened by fmemopen() => call CloseFileGrowBuffer() + + GrowBuffer_t *gb, // valid grow-buffer object + uint size // needed size +); + +int CloseFileGrowBuffer +( + // returns the number of wirtten bytes, or -1 on error + GrowBuffer_t *gb, // valid grow-buffer object + FILE *f // FILE returned by OpenFileGrowBuffer() +); + +#endif // !__APPLE__ +//----------------------------------------------------------------------------- + +void SaveCurrentStateGrowBuffer +( + FILE *f, // output file + ccp name_prefix, // NULL or prefix of name + uint tab_pos, // tab pos of '=' + const GrowBuffer_t *gb // valid grow-buffer +); + +void RestoreStateGrowBuffer +( + GrowBuffer_t *gb, // valid grow-buffer + ccp name_prefix, // NULL or prefix of name + RestoreState_t *rs // info data, can be modified (cleaned after call) +); + +//----------------------------------------------------------------------------- + +int WriteDirectGrowBuffer +( + // write() data direct without blocking and without calling any notifier. + // If output buf is not empty or send failed, append the data to 'gb'. + // Returns the number of bytes added to the grow buffer or -1 on error. + // The data is send+stored completely (returns 'size') or not at all + // (returns '0'). -1 is returned if the socket is invalid. + + GrowBuffer_t *gb, // grow buffer to cache data + int fd, // destination file + bool flush_output, // true: try to flush 'gb' before + cvp data, // data to send + uint size, // size of 'data', If NULL && flush: flush only + uint *send_count // not NULL: add num of sent bytes +); + +//----------------------------------------------------------------------------- + +int SendDirectGrowBuffer +( + // send() data direct without blocking and without calling any notifier. + // If output buf is not empty or send failed, append the data to 'gb'. + // Returns the number of bytes added to the grow buffer or -1 on error. + // The data is send+stored completely (returns 'size') or not at all + // (returns '0'). -1 is returned if the socket is invalid. + + GrowBuffer_t *gb, // grow buffer to cache data + int sock, // destination socket + bool flush_output, // true: try to flush 'gb' before + cvp data, // data to send + uint size, // size of 'data', If NULL && flush: flush only + uint *send_count // not NULL: add num of sent bytes +); + +//----------------------------------------------------------------------------- + +static inline int FlushGrowBuffer +( + // Try to flush the bufer using SendDirectGrowBuffer() withour new data. + + GrowBuffer_t *gb, // grow buffer to cache data + int sock, // destination socket + uint *send_count // not NULL: add num of sent bytes +) +{ + return SendDirectGrowBuffer(gb,sock,true,0,0,send_count); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// misc /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define CONVERT_TO_STRING1(a) #a +#define CONVERT_TO_STRING(a) CONVERT_TO_STRING1(a) + +extern int opt_new; // default 0 + +float double2float ( double d ); // reduce precision + +uint CreateUniqueId ( int range ); + +void Sha1Hex2Bin ( sha1_hash_t bin, ccp src, ccp end ); +void Sha1Bin2Hex ( sha1_hex_t hex, cvp bin ); +ccp GetSha1Hex ( cvp bin ); + +/////////////////////////////////////////////////////////////////////////////// + +static uint snprintfS ( char *buf, size_t size, ccp format, ... ) + __attribute__ ((__format__(__printf__,3,4))); + +static inline uint snprintfS ( char *buf, size_t size, ccp format, ... ) +{ + va_list arg; + va_start(arg,format); + const int res = vsnprintf(buf,size,format,arg); + va_end(arg); + + return res < 0 ? 0 : res < size ? res : size - 1; +} + +static char * snprintfE ( char *buf, char *end, ccp format, ... ) + __attribute__ ((__format__(__printf__,3,4))); + +static inline char * snprintfE ( char *buf, char *end, ccp format, ... ) +{ + const int size = end - buf; + DASSERT( size > 0 ); + + va_list arg; + va_start(arg,format); + const int res = vsnprintf(buf,size,format,arg); + va_end(arg); + + return buf + ( res < 0 ? 0 : res < size ? res : size - 1 ); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// E N D /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#endif // DCLIB_BASICS_H |