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