X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=string.c;h=8c97ccf75e22397fe3929e84340a05f00b43003c;hp=47c5417df576a56c1d710137c02182a3b7600fa5;hb=d080286b39f943baf22f1b531816d8209d8685d6;hpb=7598d7747435c4de259df09bdb82911ff893113d diff --git a/string.c b/string.c index 47c5417d..8c97ccf7 100644 --- a/string.c +++ b/string.c @@ -1,19 +1,7 @@ /* * Copyright (C) 2004-2007 Andre Noll * - * 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. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file string.c memory allocation and string handling functions */ @@ -48,8 +36,10 @@ __must_check __malloc void *para_realloc(void *p, size_t size) * No need to check for NULL pointers: If p is NULL, the call * to realloc is equivalent to malloc(size) */ + assert(size); if (!(p = realloc(p, size))) { - PARA_EMERG_LOG("%s", "realloc failed, aborting\n"); + PARA_EMERG_LOG("realloc failed (size = %zu), aborting\n", + size); exit(EXIT_FAILURE); } return p; @@ -69,10 +59,12 @@ __must_check __malloc void *para_realloc(void *p, size_t size) */ __must_check __malloc void *para_malloc(size_t size) { + assert(size); void *p = malloc(size); if (!p) { - PARA_EMERG_LOG("%s", "malloc failed, aborting\n"); + PARA_EMERG_LOG("malloc failed (size = %zu), aborting\n", + size); exit(EXIT_FAILURE); } return p; @@ -85,8 +77,8 @@ __must_check __malloc void *para_malloc(size_t size) * * A wrapper for calloc(3) which exits on errors. * - * A pointer to the allocated and zeroed-out memory, which is suitably aligned - * for any kind of variable. + * \return A pointer to the allocated and zeroed-out memory, which is suitably + * aligned for any kind of variable. * * \sa calloc(3) */ @@ -103,8 +95,8 @@ __must_check __malloc void *para_calloc(size_t size) * * \param s string to be duplicated * - * A wrapper for strdup(3). It calls exit(EXIT_FAILURE) on errors, i.e. there - * is no need to check the return value in the caller. + * A wrapper for strdup(3). It calls \p exit(EXIT_FAILURE) on errors, i.e. + * there is no need to check the return value in the caller. * * \return A pointer to the duplicated string. If \p s was the NULL pointer, * an pointer to an empty string is returned. @@ -252,8 +244,11 @@ void chop(char *buf) __must_check __malloc char *para_tmpname(void) { struct timeval now; + unsigned int seed; + gettimeofday(&now, NULL); - srand(now.tv_usec); + seed = now.tv_usec; + srand(seed); return make_message("%08i", rand()); } @@ -317,15 +312,15 @@ __must_check __malloc char *para_homedir(void) * \param argv_ptr pointer to the list of substrings * \param delim delimiter * - * This function modifies \p args by replacing each occurance of \p delim by - * zero. A NULL-terminated array of pointers to char* is allocated dynamically + * This function modifies \a args by replacing each occurance of \a delim by + * zero. A \p NULL-terminated array of pointers to char* is allocated dynamically * and these pointers are initialized to point to the broken-up substrings - * within \p args. A pointer to this array is returned via \p argv_ptr. It's OK - * to call this function with \p args \p == \p NULL. + * within \a args. A pointer to this array is returned via \a argv_ptr. It's OK + * to call this function with \a args \a == \p NULL. * - * \return The number of substrings found in \p args. + * \return The number of substrings found in \a args. */ -__must_check unsigned split_args(char *args, char ***argv_ptr, const char *delim) +__must_check unsigned split_args(char *args, char *** const argv_ptr, const char *delim) { char *p = args; char **argv; @@ -398,3 +393,230 @@ __malloc char *para_hostname(void) uname(&u); return para_strdup(u.nodename); } + +/** + * Used to distinguish between read-only and read-write mode. + * + * \sa for_each_line(), for_each_line_ro(). + */ +enum for_each_line_modes{ + /** Activate read-only mode. */ + LINE_MODE_RO, + /** Activate read-write mode. */ + LINE_MODE_RW +}; + +static int for_each_complete_line(enum for_each_line_modes mode, char *buf, + size_t size, line_handler_t *line_handler, void *private_data) +{ + char *start = buf, *end; + int ret, i, num_lines = 0; + +// PARA_NOTICE_LOG("buf: %s\n", buf); + while (start < buf + size) { + char *next_null; + char *next_cr; + + next_cr = memchr(start, '\n', buf + size - start); + next_null = memchr(start, '\0', buf + size - start); + if (!next_cr && !next_null) + break; + if (next_cr && next_null) { + end = next_cr < next_null? next_cr : next_null; + } else if (next_null) { + end = next_null; + } else + end = next_cr; + num_lines++; + if (!line_handler) { + start = ++end; + continue; + } + if (mode == LINE_MODE_RO) { + size_t s = end - start; + char *b = para_malloc(s + 1); + memcpy(b, start, s); + b[s] = '\0'; +// PARA_NOTICE_LOG("b: %s, start: %s\n", b, start); + ret = line_handler(b, private_data); + free(b); + } else { + *end = '\0'; + ret = line_handler(start, private_data); + } + if (ret < 0) + return ret; + start = ++end; + } + if (!line_handler || mode == LINE_MODE_RO) + return num_lines; + i = buf + size - start; + if (i && i != size) + memmove(buf, start, i); + return i; +} + +/** + * Call a custom function for each complete line. + * + * \param buf The buffer containing data seperated by newlines. + * \param size The number of bytes in \a buf. + * \param line_handler The custom function. + * \param private_data Pointer passed to \a line_handler. + * + * If \p line_handler is \p NULL, the function returns the number of complete + * lines in \p buf. Otherwise, \p line_handler is called for each complete + * line in \p buf. The first argument to \p line_handler is the current line, + * and \p private_data is passed as the second argument. The function returns + * if \p line_handler returns a negative value or no more lines are in the + * buffer. The rest of the buffer (last chunk containing an incomplete line) + * is moved to the beginning of the buffer. + * + * \return If \p line_handler is not \p NULL, this function returns the number + * of bytes not handled to \p line_handler on success, or the negative return + * value of the \p line_handler on errors. + * + * \sa for_each_line_ro(). + */ +int for_each_line(char *buf, size_t size, line_handler_t *line_handler, + void *private_data) +{ + return for_each_complete_line(LINE_MODE_RW, buf, size, line_handler, + private_data); +} + +/** + * Call a custom function for each complete line. + * + * \param buf Same meaning as in \p for_each_line(). + * \param size Same meaning as in \p for_each_line(). + * \param line_handler Same meaning as in \p for_each_line(). + * \param private_data Same meaning as in \p for_each_line(). + * + * This function behaves like \p for_each_line(), but \a buf is left unchanged. + * + * \return On success, the function returns the number of complete lines in \p + * buf, otherwise the (negative) return value of \p line_handler is returned. + * + * \sa for_each_line(). + */ +int for_each_line_ro(char *buf, size_t size, line_handler_t *line_handler, + void *private_data) +{ + return for_each_complete_line(LINE_MODE_RO, buf, size, line_handler, + private_data); +} + +/** + * Safely print into a buffer at a given offset + * + * \param b Determines the buffer, its size, and the offset. + * \param fmt The format string. + * + * This function prints into the buffer given by \a b at the offset which is + * also given by \a b. If there is not enough space to hold the result, the + * buffer size is doubled until the underlying call to vsnprintf() succeeds. + * Upon return, the offset of \a b is adjusted accordingly so that subsequent + * calls to this function append data to what is already contained in the + * buffer. + * + * It's OK to call this function with \p b->buf being \p NULL. In this case, an + * initial buffer is allocated. + * + * \return The number of bytes printed into the buffer (not including the + * therminating \p NULL byte). + * + * \sa make_message(), vsnprintf(3). + */ +__printf_2_3 int para_printf(struct para_buffer *b, const char *fmt, ...) +{ + int ret; + + if (!b->buf) { + b->buf = para_malloc(128); + b->size = 128; + b->offset = 0; + } else if (b->size <= b->offset + 1) { + b->size *= 2; + b->buf = para_realloc(b->buf, b->size); + } + while (1) { + char *p = b->buf + b->offset; + size_t size = b->size - b->offset; + va_list ap; + va_start(ap, fmt); + ret = vsnprintf(p, size, fmt, ap); + va_end(ap); + if (ret > -1 && ret < size) { /* success */ + b->offset += ret; + break; + } + /* try again with more space */ + b->size *= 2; + b->buf = para_realloc(b->buf, b->size); + } + return ret; +} + +/** \cond LLONG_MAX and LLONG_LIN might not be defined. */ +#ifndef LLONG_MAX +#define LLONG_MAX (1 << (sizeof(long) - 1)) +#endif +#ifndef LLONG_MIN +#define LLONG_MIN (-LLONG_MAX - 1LL) +#endif +/** \endcond */ + +/** + * Convert a string to a 64-bit signed integer value. + * + * \param str The string to be converted. + * \param value Result pointer. + * + * \return Positive on success, negative on errors. + * + * \sa para_atoi32(), strtol(3), atoi(3). + */ +int para_atoi64(const char *str, int64_t *value) +{ + char *endptr; + long long tmp; + + errno = 0; /* To distinguish success/failure after call */ + tmp = strtoll(str, &endptr, 10); + if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN)) + return -E_ATOI_OVERFLOW; + if (errno != 0 && tmp == 0) /* other error */ + return -E_STRTOLL; + if (endptr == str) + return -E_ATOI_NO_DIGITS; + if (*endptr != '\0') /* Further characters after number */ + return -E_ATOI_JUNK_AT_END; + *value = tmp; + return 1; +} + +/** + * Convert a string to a 32-bit signed integer value. + * + * \param str The string to be converted. + * \param value Result pointer. + * + * \return Positive on success, negative on errors. + * + * \sa para_atoi64(). +*/ +int para_atoi32(const char *str, int32_t *value) +{ + int64_t tmp; + int ret; + const int32_t max = 2147483647; + + ret = para_atoi64(str, &tmp); + if (ret < 0) + return ret; + if (tmp > max || tmp < -max - 1) + return -E_ATOI_OVERFLOW; + *value = tmp; + return 1; +}