comparison: src/cx/printf.h
src/cx/printf.h
- changeset 810
- 85859399a0cc
- parent 805
- 26500fc24058
- child 849
- edb9f875b7f9
equal
deleted
inserted
replaced
| 809:b7e2e1d7ed22 | 810:85859399a0cc |
|---|---|
| 162 * @see ucx_fprintf() | 162 * @see ucx_fprintf() |
| 163 */ | 163 */ |
| 164 #define cx_bprintf(buffer, fmt, ...) cx_fprintf((CxBuffer*)buffer, \ | 164 #define cx_bprintf(buffer, fmt, ...) cx_fprintf((CxBuffer*)buffer, \ |
| 165 (cx_write_func) cxBufferWrite, fmt, __VA_ARGS__) | 165 (cx_write_func) cxBufferWrite, fmt, __VA_ARGS__) |
| 166 | 166 |
| 167 | |
| 168 /** | |
| 169 * An \c sprintf like function which reallocates the string when the buffer is not large enough. | |
| 170 * | |
| 171 * \note The resulting string is guaranteed to be zero-terminated. | |
| 172 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 173 * the length returned by this function plus one. | |
| 174 * | |
| 175 * @param str a pointer to the string buffer | |
| 176 * @param len the current length of the buffer | |
| 177 * @param fmt the format string | |
| 178 * @param ... additional arguments | |
| 179 * @return the length of produced string | |
| 180 */ | |
| 181 #define cx_sprintf(str, len, fmt, ...) cx_sprintf_a(cxDefaultAllocator, str, len, fmt, __VA_ARGS__) | |
| 182 | |
| 183 /** | |
| 184 * An \c sprintf like function which reallocates the string when the buffer is not large enough. | |
| 185 * | |
| 186 * \note The resulting string is guaranteed to be zero-terminated. | |
| 187 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 188 * the length returned by this function plus one. | |
| 189 * | |
| 190 * \attention The original buffer MUST have been allocated with the same allocator! | |
| 191 * | |
| 192 * @param alloc the allocator to use | |
| 193 * @param str a pointer to the string buffer | |
| 194 * @param len the current length of the buffer | |
| 195 * @param fmt the format string | |
| 196 * @param ... additional arguments | |
| 197 * @return the length of produced string | |
| 198 */ | |
| 199 __attribute__((__nonnull__(1, 2, 4), __format__(printf, 4, 5))) | |
| 200 int cx_sprintf_a(CxAllocator *alloc, char **str, size_t len, const char *fmt, ... ); | |
| 201 | |
| 202 | |
| 203 /** | |
| 204 * An \c sprintf like function which reallocates the string when the buffer is not large enough. | |
| 205 * | |
| 206 * \note The resulting string is guaranteed to be zero-terminated. | |
| 207 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 208 * the length returned by this function plus one. | |
| 209 * | |
| 210 * @param str a pointer to the string buffer | |
| 211 * @param len the current length of the buffer | |
| 212 * @param fmt the format string | |
| 213 * @param ap argument list | |
| 214 * @return the length of produced string | |
| 215 */ | |
| 216 #define cx_vsprintf(str, len, fmt, ap) cx_vsprintf_a(cxDefaultAllocator, str, len, fmt, ap) | |
| 217 | |
| 218 /** | |
| 219 * An \c sprintf like function which reallocates the string when the buffer is not large enough. | |
| 220 * | |
| 221 * \note The resulting string is guaranteed to be zero-terminated. | |
| 222 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 223 * the length returned by this function plus one. | |
| 224 * | |
| 225 * \attention The original buffer MUST have been allocated with the same allocator! | |
| 226 * | |
| 227 * @param alloc the allocator to use | |
| 228 * @param str a pointer to the string buffer | |
| 229 * @param len the current length of the buffer | |
| 230 * @param fmt the format string | |
| 231 * @param ap argument list | |
| 232 * @return the length of produced string | |
| 233 */ | |
| 234 __attribute__((__nonnull__)) | |
| 235 int cx_vsprintf_a(CxAllocator *alloc, char **str, size_t len, const char *fmt, va_list ap); | |
| 236 | |
| 237 | |
| 238 /** | |
| 239 * An \c sprintf like function which allocates a new string when the buffer is not large enough. | |
| 240 * | |
| 241 * The location of the resulting string will \em always be stored to \p str. When the buffer | |
| 242 * was sufficiently large, \p buf itself will be stored to the location of \p str. | |
| 243 * | |
| 244 * \note The resulting string is guaranteed to be zero-terminated. | |
| 245 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 246 * the length returned by this function plus one. | |
| 247 * | |
| 248 * \remark When a new string needed to be allocated, the contents of \p buf will be | |
| 249 * poisoned after the call, because this function tries to produce the string in \p buf, first. | |
| 250 * | |
| 251 * @param buf a pointer to the buffer | |
| 252 * @param len the length of the buffer | |
| 253 * @param str a pointer to the location | |
| 254 * @param fmt the format string | |
| 255 * @param ... additional arguments | |
| 256 * @return the length of produced string | |
| 257 */ | |
| 258 #define cx_sprintf_s(buf, len, str, fmt, ...) cx_sprintf_sa(cxDefaultAllocator, buf, len, str, fmt, __VA_ARGS__) | |
| 259 | |
| 260 /** | |
| 261 * An \c sprintf like function which allocates a new string when the buffer is not large enough. | |
| 262 * | |
| 263 * The location of the resulting string will \em always be stored to \p str. When the buffer | |
| 264 * was sufficiently large, \p buf itself will be stored to the location of \p str. | |
| 265 * | |
| 266 * \note The resulting string is guaranteed to be zero-terminated. | |
| 267 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 268 * the length returned by this function plus one. | |
| 269 * | |
| 270 * \remark When a new string needed to be allocated, the contents of \p buf will be | |
| 271 * poisoned after the call, because this function tries to produce the string in \p buf, first. | |
| 272 * | |
| 273 * @param alloc the allocator to use | |
| 274 * @param buf a pointer to the buffer | |
| 275 * @param len the length of the buffer | |
| 276 * @param str a pointer to the location | |
| 277 * @param fmt the format string | |
| 278 * @param ... additional arguments | |
| 279 * @return the length of produced string | |
| 280 */ | |
| 281 __attribute__((__nonnull__(1, 2, 4, 5), __format__(printf, 5, 6))) | |
| 282 int cx_sprintf_sa(CxAllocator *alloc, char *buf, size_t len, char **str, const char *fmt, ... ); | |
| 283 | |
| 284 /** | |
| 285 * An \c sprintf like function which allocates a new string when the buffer is not large enough. | |
| 286 * | |
| 287 * The location of the resulting string will \em always be stored to \p str. When the buffer | |
| 288 * was sufficiently large, \p buf itself will be stored to the location of \p str. | |
| 289 * | |
| 290 * \note The resulting string is guaranteed to be zero-terminated. | |
| 291 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 292 * the length returned by this function plus one. | |
| 293 * | |
| 294 * \remark When a new string needed to be allocated, the contents of \p buf will be | |
| 295 * poisoned after the call, because this function tries to produce the string in \p buf, first. | |
| 296 * | |
| 297 * @param buf a pointer to the buffer | |
| 298 * @param len the length of the buffer | |
| 299 * @param str a pointer to the location | |
| 300 * @param fmt the format string | |
| 301 * @param ap argument list | |
| 302 * @return the length of produced string | |
| 303 */ | |
| 304 #define cx_vsprintf_s(buf, len, str, fmt, ap) cx_vsprintf_sa(cxDefaultAllocator, buf, len, str, fmt, ap) | |
| 305 | |
| 306 /** | |
| 307 * An \c sprintf like function which allocates a new string when the buffer is not large enough. | |
| 308 * | |
| 309 * The location of the resulting string will \em always be stored to \p str. When the buffer | |
| 310 * was sufficiently large, \p buf itself will be stored to the location of \p str. | |
| 311 * | |
| 312 * \note The resulting string is guaranteed to be zero-terminated. | |
| 313 * That means, when the buffer needed to be reallocated, the new size of the buffer will be | |
| 314 * the length returned by this function plus one. | |
| 315 * | |
| 316 * \remark When a new string needed to be allocated, the contents of \p buf will be | |
| 317 * poisoned after the call, because this function tries to produce the string in \p buf, first. | |
| 318 * | |
| 319 * @param alloc the allocator to use | |
| 320 * @param buf a pointer to the buffer | |
| 321 * @param len the length of the buffer | |
| 322 * @param str a pointer to the location | |
| 323 * @param fmt the format string | |
| 324 * @param ap argument list | |
| 325 * @return the length of produced string | |
| 326 */ | |
| 327 __attribute__((__nonnull__)) | |
| 328 int cx_vsprintf_sa(CxAllocator *alloc, char *buf, size_t len, char **str, const char *fmt, va_list ap); | |
| 329 | |
| 330 | |
| 167 #ifdef __cplusplus | 331 #ifdef __cplusplus |
| 168 } // extern "C" | 332 } // extern "C" |
| 169 #endif | 333 #endif |
| 170 | 334 |
| 171 #endif //UCX_PRINTF_H | 335 #endif //UCX_PRINTF_H |
