Mirror of :pserver:cvs@cvs.fefe.de:/cvs libowfat https://www.fefe.de/libowfat/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

219 lines
9.2 KiB

21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
21 years ago
6 years ago
6 years ago
14 years ago
14 years ago
21 years ago
  1. /* this header file comes from libowfat, http://www.fefe.de/libowfat/ */
  2. #ifndef FMT_H
  3. #define FMT_H
  4. /* for size_t: */
  5. #include <stddef.h>
  6. /* for uint32_t */
  7. #include <stdint.h>
  8. /* for time_t: */
  9. #include <sys/types.h>
  10. /* for byte_copy */
  11. #include "byte.h"
  12. #ifdef __cplusplus
  13. extern "C" {
  14. #endif
  15. #ifndef __pure__
  16. #define __pure__
  17. #endif
  18. #define FMT_LONG 41 /* enough space to hold -2^127 in decimal, plus \0 */
  19. #define FMT_ULONG 40 /* enough space to hold 2^128 - 1 in decimal, plus \0 */
  20. #define FMT_8LONG 44 /* enough space to hold 2^128 - 1 in octal, plus \0 */
  21. #define FMT_XLONG 33 /* enough space to hold 2^128 - 1 in hexadecimal, plus \0 */
  22. #define FMT_LEN ((char *) 0) /* convenient abbreviation */
  23. /* This file declares routines for formatting strings and numbers in
  24. * various forms or encodings, either binary or text based.
  25. *
  26. * The first argument is always the destination buffer, the second
  27. * argument is always the value to be formatted/encoded. The return
  28. * value is always the number of bytes written in the output buffer.
  29. *
  30. * If you don't know how large the output will be, call the function
  31. * first with NULL as destination buffer and use the length it returns
  32. * to allocate the destination buffer.
  33. *
  34. * Note that none of these routines append a 0 terminator. If you need
  35. * 0 termination, call the functions like this:
  36. buf[fmt_ulong(buf,number)]=0;
  37. */
  38. /* convert signed src integer -23 to ASCII '-','2','3', return number of
  39. * bytes of value in output format (3 in this example).
  40. * If dest is not NULL, write result to dest */
  41. size_t fmt_long(char *dest,signed long src) __pure__;
  42. /* convert unsigned src integer 23 to ASCII '2','3', return number of
  43. * bytes of value in output format (2 in this example).
  44. * If dest is not NULL, write result to dest */
  45. size_t fmt_ulong(char *dest,unsigned long src) __pure__;
  46. /* convert unsigned src integer 0x23 to ASCII '2','3', return number of
  47. * bytes of value in output format (2 in this example).
  48. * If dest is not NULL, write result to dest */
  49. size_t fmt_xlong(char *dest,unsigned long src) __pure__;
  50. /* convert unsigned src integer 023 to ASCII '2','3', return number of
  51. * bytes of value in output format (2 in this example).
  52. * If dest is not NULL, write result to dest */
  53. size_t fmt_8long(char *dest,unsigned long src) __pure__;
  54. /* like fmt_long but for long long */
  55. size_t fmt_longlong(char *dest,signed long long src) __pure__;
  56. /* like fmt_ulong but for unsigned long long */
  57. size_t fmt_ulonglong(char *dest,unsigned long long src) __pure__;
  58. /* like fmt_xlong but for unsigned long long */
  59. size_t fmt_xlonglong(char *dest,unsigned long long src) __pure__;
  60. #define fmt_uint(dest,src) fmt_ulong(dest,src)
  61. #define fmt_int(dest,src) fmt_long(dest,src)
  62. #define fmt_xint(dest,src) fmt_xlong(dest,src)
  63. #define fmt_8int(dest,src) fmt_8long(dest,src)
  64. /* Like fmt_ulong, but prepend '0' while length is smaller than padto.
  65. * Does not truncate! */
  66. /* fmt_ulong0(buf,23,4) -> '0','0','2','3' return 4 */
  67. /* fmt_ulong0(buf,234,2) -> '2','3','4', return 3 */
  68. size_t fmt_ulong0(char *,unsigned long src,size_t padto) __pure__;
  69. #define fmt_uint0(buf,src,padto) fmt_ulong0(buf,src,padto)
  70. /* convert src double 1.7 to ASCII '1','.','7', return length.
  71. * If dest is not NULL, write result to dest */
  72. size_t fmt_double(char *dest, double d,int max,int prec) __pure__;
  73. /* if src is negative, write '-' and return 1.
  74. * if src is positive, write '+' and return 1.
  75. * otherwise return 0 */
  76. size_t fmt_plusminus(char *dest,int src) __pure__;
  77. /* if src is negative, write '-' and return 1.
  78. * otherwise return 0. */
  79. size_t fmt_minus(char *dest,int src) __pure__;
  80. /* copy str to dest until \0 byte, return number of copied bytes. */
  81. /* fmt_str(NULL,str) == strlen(str) */
  82. /* fmt_str(buf,str) == strcpy(buf,str), return strlen(str) */
  83. /* strcat(strcpy(buf,"foo"),"bar") can be written as
  84. * i=fmt_str(buf,"foo");
  85. * i+=fmt_str(buf+i,"bar");
  86. * buf[i]=0;
  87. * This is more efficient because strcat needs to scan the string to
  88. * find the end and append.
  89. */
  90. size_t fmt_str(char *dest,const char *src) __pure__;
  91. /* copy str to dest until \0 byte or limit bytes copied.
  92. * return number of copied bytes. */
  93. size_t fmt_strn(char *dest,const char *src,size_t limit) __pure__;
  94. /* copy n bytes from src to dest, return n */
  95. static inline size_t fmt_copybytes(char* dest,const char* src,size_t n) {
  96. byte_copy(dest,n,src);
  97. return n;
  98. }
  99. /* "foo" -> " foo"
  100. * write padlen-srclen spaces, if that is >= 0. Then copy srclen
  101. * characters from src. Truncate only if total length is larger than
  102. * maxlen. Return number of characters written. */
  103. size_t fmt_pad(char* dest,const char* src,size_t srclen,size_t padlen,size_t maxlen) __pure__;
  104. /* "foo" -> "foo "
  105. * append padlen-srclen spaces after dest, if that is >= 0. Truncate
  106. * only if total length is larger than maxlen. Return number of
  107. * characters written. */
  108. size_t fmt_fill(char* dest,size_t srclen,size_t padlen,size_t maxlen) __pure__;
  109. /* 1 -> "1", 4900 -> "4.9k", 2300000 -> "2.3M" */
  110. size_t fmt_human(char* dest,unsigned long long l) __pure__;
  111. /* 1 -> "1", 4900 -> "4.8k", 2300000 -> "2.2M" */
  112. size_t fmt_humank(char* dest,unsigned long long l) __pure__;
  113. /* "Sun, 06 Nov 1994 08:49:37 GMT" */
  114. size_t fmt_httpdate(char* dest,time_t t); /* not marked pure because it calls gmtime */
  115. /* "2014-05-27T19:22:16.247Z" */
  116. size_t fmt_iso8601(char* dest,time_t t) __pure__;
  117. #define FMT_UTF8 5
  118. #define FMT_ASN1LENGTH 17 /* enough space to hold 2^128-1 */
  119. #define FMT_ASN1TAG 19 /* enough space to hold 2^128-1 */
  120. /* some variable length encodings for integers */
  121. size_t fmt_utf8(char* dest,uint32_t n) __pure__; /* can store 0-0x7fffffff */
  122. size_t fmt_asn1derlength(char* dest,unsigned long long l) __pure__; /* 0-0x7f: 1 byte, above that 1+bytes_needed bytes */
  123. size_t fmt_asn1dertag(char* dest,unsigned long long l) __pure__; /* 1 byte for each 7 bits; upper bit = more bytes coming */
  124. /* Google Protocol Buffers, https://developers.google.com/protocol-buffers/docs/encoding */
  125. size_t fmt_varint(char* dest,unsigned long long l) __pure__; /* protocol buffers encoding; like asn1dertag but little endian */
  126. size_t fmt_pb_tag(char* dest,size_t fieldno,unsigned char type) __pure__; /* protocol buffer tag */
  127. size_t fmt_pb_type0_int(char* dest,unsigned long long l) __pure__; /* protocol buffers encoding: type 0 bool/enum/int32/uint32/int64/uint64 */
  128. size_t fmt_pb_type0_sint(char* dest,signed long long l) __pure__;/* protocol buffers encoding: type 0 sint32/sint64 */
  129. size_t fmt_pb_type1_double(char* dest,double d) __pure__; /* protocol buffers encoding: double (64-bit little endian blob) */
  130. size_t fmt_pb_type1_fixed64(char* dest,uint64_t l) __pure__; /* protocol buffers encoding: 64-bit little endian blob */
  131. /* fmt_pb_type2_string can return 0 if (s,l) is clearly invalid */
  132. size_t fmt_pb_type2_string(char* dest,const char* s,size_t l) __pure__; /* protocol buffers encoding: varint length + blob */
  133. size_t fmt_pb_type5_float(char* dest,float f) __pure__; /* protocol buffers encoding: float (32-bit little endian blob) */
  134. size_t fmt_pb_type5_fixed32(char* dest,uint32_t l) __pure__; /* protocol buffers encoding: 32-bit little endian blob */
  135. size_t fmt_pb_int(char* dest,size_t fieldno,unsigned long long l) __pure__;
  136. size_t fmt_pb_sint(char* dest,size_t fieldno,signed long long l) __pure__;
  137. size_t fmt_pb_double(char* dest,size_t fieldno,double d) __pure__;
  138. size_t fmt_pb_float(char* dest,size_t fieldno,float f) __pure__;
  139. size_t fmt_pb_string(char* dest,size_t fieldno,const char* s,size_t l) __pure__;
  140. /* fmt_netstring can return 0 if (src,len) is clearly invalid */
  141. size_t fmt_netstring(char* dest,const char* src,size_t len) __pure__;
  142. /* Marshaling helper functions.
  143. * Escape one character, no matter if it needs escaping or not.
  144. * The functions will reject characters that cannot be represented but
  145. * not characters that the standard says should never occur. The idea
  146. * is to make these functions useful for creating bad encoding for
  147. * penetration testing.
  148. * Depending on the escaping method, the input character (uint32_t, a
  149. * unicode codepoint) may be limited to 0x7f, 0xff or 0x10ffff. */
  150. /* XML escaping: '&' -> '&amp;', '<' -> '&lt;', 'ö' -> '&#xf6;' */
  151. size_t fmt_escapecharxml(char* dest,uint32_t ch) __pure__;
  152. /* HTML escaping is the same as XML escaping. */
  153. size_t fmt_escapecharhtml(char* dest,uint32_t ch) __pure__;
  154. /* JSON escaping: '\' -> '\\', '"' -> '\"', 'ö' -> '\u00f6' */
  155. size_t fmt_escapecharjson(char* dest,uint32_t ch) __pure__;
  156. /* MIME quoted-printable escaping: 'ö' -> '=f6', characters > 0xff not supported */
  157. size_t fmt_escapecharquotedprintable(char* dest,uint32_t ch) __pure__;
  158. /* MIME quoted-printable escaping with UTF-8: 'ö' -> '=c3=b6', characters > 0x7fffffff not supported */
  159. size_t fmt_escapecharquotedprintableutf8(char* dest,uint32_t ch) __pure__;
  160. /* C escaping: '\' -> '\\', newline -> '\n', 0xc2 -> '\302' */
  161. size_t fmt_escapecharc(char* dest,uint32_t ch) __pure__;
  162. /* internal functions, may be independently useful */
  163. char fmt_tohex(char c) __attribute__((__const__));
  164. #define fmt_strm(b,...) fmt_strm_internal(b,__VA_ARGS__,(char*)0)
  165. size_t fmt_strm_internal(char* dest,...) __pure__;
  166. #ifndef MAX_ALLOCA
  167. #define MAX_ALLOCA 100000
  168. #endif
  169. #define fmt_strm_alloca(a,...) ({ size_t len=fmt_strm((char*)0,a,__VA_ARGS__)+1; char* c=(len<MAX_ALLOCA?alloca(len):0); if (c) c[fmt_strm(c,a,__VA_ARGS__)]=0; c;})
  170. #ifdef __cplusplus
  171. }
  172. #endif
  173. #endif