/* xbt_str.c - various helping functions to deal with strings */
-/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2007-2014. The SimGrid Team.
* All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#include "portable.h"
+#include "src/portable.h"
#include "xbt/misc.h"
#include "xbt/sysdep.h"
#include "xbt/str.h" /* headers of these functions */
* Strips the whitespaces from the end of s.
* By default (when char_list=NULL), these characters get stripped:
*
- * - " " (ASCII 32 (0x20)) space.
- * - "\t" (ASCII 9 (0x09)) tab.
- * - "\n" (ASCII 10 (0x0A)) line feed.
- * - "\r" (ASCII 13 (0x0D)) carriage return.
- * - "\0" (ASCII 0 (0x00)) NULL.
- * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
+ * - " " (ASCII 32 (0x20)) space.
+ * - "\t" (ASCII 9 (0x09)) tab.
+ * - "\n" (ASCII 10 (0x0A)) line feed.
+ * - "\r" (ASCII 13 (0x0D)) carriage return.
+ * - "\0" (ASCII 0 (0x00)) NULL.
+ * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
*
* @param s The string to strip. Modified in place.
* @param char_list A string which contains the characters you want to strip.
* Strips the whitespaces from the begining of s.
* By default (when char_list=NULL), these characters get stripped:
*
- * - " " (ASCII 32 (0x20)) space.
- * - "\t" (ASCII 9 (0x09)) tab.
- * - "\n" (ASCII 10 (0x0A)) line feed.
- * - "\r" (ASCII 13 (0x0D)) carriage return.
- * - "\0" (ASCII 0 (0x00)) NULL.
- * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
+ * - " " (ASCII 32 (0x20)) space.
+ * - "\t" (ASCII 9 (0x09)) tab.
+ * - "\n" (ASCII 10 (0x0A)) line feed.
+ * - "\r" (ASCII 13 (0x0D)) carriage return.
+ * - "\0" (ASCII 0 (0x00)) NULL.
+ * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
*
* @param s The string to strip. Modified in place.
* @param char_list A string which contains the characters you want to strip.
* Strips the whitespaces from both the beginning and the end of s.
* By default (when char_list=NULL), these characters get stripped:
*
- * - " " (ASCII 32 (0x20)) space.
- * - "\t" (ASCII 9 (0x09)) tab.
- * - "\n" (ASCII 10 (0x0A)) line feed.
- * - "\r" (ASCII 13 (0x0D)) carriage return.
- * - "\0" (ASCII 0 (0x00)) NULL.
- * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
+ * - " " (ASCII 32 (0x20)) space.
+ * - "\t" (ASCII 9 (0x09)) tab.
+ * - "\n" (ASCII 10 (0x0A)) line feed.
+ * - "\r" (ASCII 13 (0x0D)) carriage return.
+ * - "\0" (ASCII 0 (0x00)) NULL.
+ * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
*
* @param s The string to strip.
* @param char_list A string which contains the characters you want to strip.
xbt_str_ltrim(s, char_list);
}
-/** @brief Replace double whitespaces (but no other characters) from the string.
- *
- * The function modifies the string so that each time that several spaces appear,
- * they are replaced by a single space. It will only do so for spaces (ASCII 32, 0x20).
- *
- * @param s The string to strip. Modified in place.
- *
- */
-void xbt_str_strip_spaces(char *s)
-{
- char *p = s;
- int e = 0;
-
- if (!s)
- return;
-
- while (1) {
- if (!*p)
- goto end;
-
- if (*p != ' ')
- break;
-
- p++;
- }
-
- e = 1;
-
- do {
- if (e)
- *s++ = *p;
-
- if (!*++p)
- goto end;
-
- if (e ^ (*p != ' '))
- if ((e = !e))
- *s++ = ' ';
- } while (1);
-
-end:
- *s = '\0';
-}
-
/** @brief Substitutes a char for another in a string
*
* @param str the string to modify
*
* By default (with sep=NULL), these characters are used as separator:
*
- * - " " (ASCII 32 (0x20)) space.
- * - "\t" (ASCII 9 (0x09)) tab.
- * - "\n" (ASCII 10 (0x0A)) line feed.
- * - "\r" (ASCII 13 (0x0D)) carriage return.
- * - "\0" (ASCII 0 (0x00)) NULL.
- * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
+ * - " " (ASCII 32 (0x20)) space.
+ * - "\t" (ASCII 9 (0x09)) tab.
+ * - "\n" (ASCII 10 (0x0A)) line feed.
+ * - "\r" (ASCII 13 (0x0D)) carriage return.
+ * - "\0" (ASCII 0 (0x00)) NULL.
+ * - "\x0B" (ASCII 11 (0x0B)) vertical tab.
*/
xbt_dynar_t xbt_str_split(const char *s, const char *sep)
//if substring was not found add the entire string
if (NULL == q) {
v = strlen(p);
- to_push = malloc(v + 1);
+ to_push = xbt_malloc(v + 1);
memcpy(to_push, p, v);
to_push[v] = '\0';
xbt_dynar_push(res, &to_push);
done = 1;
} else {
//get the appearance
- to_push = malloc(q - p + 1);
+ to_push = xbt_malloc(q - p + 1);
memcpy(to_push, p, q - p);
//add string terminator
to_push[q - p] = '\0';
*
* The string passed as argument must be writable (not const)
* The elements of the dynar are just parts of the string passed as argument.
+ * So if you don't store that argument elsewhere, you should free it in addition
+ * to freeing the dynar. This can be done by simply freeing the first argument
+ * of the dynar:
+ * free(xbt_dynar_get_ptr(dynar,0));
*
- * To free the structure constructed by this function, free the first element and free the dynar:
- *
- * free(xbt_dynar_get_ptr(dynar,0));
- * xbt_dynar_free(&dynar);
+ * Actually this function puts a bunch of \0 in the memory area you passed as
+ * argument to separate the elements, and pushes the address of each chunk
+ * in the resulting dynar. Yes, that's uneven. Yes, that's gory. But that's efficient.
*/
xbt_dynar_t xbt_str_split_quoted_in_place(char *s) {
xbt_dynar_t res = xbt_dynar_new(sizeof(char *), NULL);
beg = s;
- /* do not trim leading spaces: caller responsability to clean his cruft */
+ /* do not trim leading spaces: caller responsibility to clean his cruft */
end = beg;
while (!done) {
return res;
}
-#if defined(SIMGRID_NEED_GETLINE) || defined(DOXYGEN)
-/** @brief Get a single line from the stream (reimplementation of the GNU getline)
- *
- * This is a redefinition of the GNU getline function, used on platforms where it does not exists.
- *
- * getline() reads an entire line from stream, storing the address of the buffer
- * containing the text into *buf. The buffer is null-terminated and includes
- * the newline character, if one was found.
- *
- * If *buf is NULL, then getline() will allocate a buffer for storing the line,
- * which should be freed by the user program. Alternatively, before calling getline(),
- * *buf can contain a pointer to a malloc()-allocated buffer *n bytes in size. If the buffer
- * is not large enough to hold the line, getline() resizes it with realloc(), updating *buf and *n
- * as necessary. In either case, on a successful call, *buf and *n will be updated to
- * reflect the buffer address and allocated size respectively.
- */
-long getline(char **buf, size_t * n, FILE * stream)
-{
-
- size_t i;
- int ch;
-
- if (!*buf) {
- *buf = xbt_malloc(512);
- *n = 512;
- }
-
- if (feof(stream))
- return (ssize_t) - 1;
-
- for (i = 0; (ch = fgetc(stream)) != EOF; i++) {
-
- if (i >= (*n) + 1)
- *buf = xbt_realloc(*buf, *n += 512);
-
- (*buf)[i] = ch;
-
- if ((*buf)[i] == '\n') {
- i++;
- (*buf)[i] = '\0';
- break;
- }
- }
-
- if (i == *n)
- *buf = xbt_realloc(*buf, *n += 1);
-
- (*buf)[i] = '\0';
-
- return (ssize_t) i;
-}
-
-#endif /* HAVE_GETLINE */
-
/*
* Diff related functions
*
- * Implementation of the algorithm described in "An O(NP) Sequence
- * Comparison Algorithm", by Sun Wu, Udi Manber, Gene Myers, and Webb
- * Miller.
+ * Implementation of the algorithm described in "An O(NP) Sequence Comparison
+ * Algorithm", by Sun Wu, Udi Manber, Gene Myers, and Webb Miller (Information
+ * Processing Letters 35(6):317-323, 1990), with the linear-space
+ * divide-and-conquer strategy described in "An O(ND) Difference Algorithm and
+ * Its Variations", by Eugene W. Myers (Algorithmica 1:251-266, 1986).
*/
struct subsequence {
};
static XBT_INLINE
-void diff_snake(const xbt_dynar_t da, int a0, int len_a,
- const xbt_dynar_t db, int b0, int len_b,
+void diff_snake(const char *vec_a[], int a0, int len_a,
+ const char *vec_b[], int b0, int len_b,
struct subsequence *seqs, int *fp, int k, int limit)
{
int record_seq;
} else {
seqs[k] = seqs[record_seq];
}
- while (x < len_a && y < len_b && !strcmp(xbt_dynar_get_as(da, a0 + x, char*),
- xbt_dynar_get_as(db, b0 + y, char*)))
+ while (x < len_a && y < len_b && !strcmp(vec_a[a0 + x], vec_b[b0 + y]))
++x, ++y;
fp[k] = x;
if (record_seq == k)
/* Returns the length of a shortest edit script, and a common
* subsequence from the middle.
*/
-static int diff_middle_subsequence(const xbt_dynar_t da, int a0, int len_a,
- const xbt_dynar_t db, int b0, int len_b,
+static int diff_middle_subsequence(const char *vec_a[], int a0, int len_a,
+ const char *vec_b[], int b0, int len_b,
struct subsequence *subseq,
struct subsequence *seqs, int *fp)
{
p++;
fp[kmin - p - 1] = fp[kmax + p + 1] = -1;
for (k = kmax + p; k > delta; k--)
- diff_snake(da, a0, len_a, db, b0, len_b, seqs, fp, k, limit);
+ diff_snake(vec_a, a0, len_a, vec_b, b0, len_b, seqs, fp, k, limit);
for (k = kmin - p; k <= delta; k++)
- diff_snake(da, a0, len_a, db, b0, len_b, seqs, fp, k, limit);
+ diff_snake(vec_a, a0, len_a, vec_b, b0, len_b, seqs, fp, k, limit);
} while (fp[delta] != len_a);
subseq->x = a0 + seqs[delta].x;
}
/* Finds a longest common subsequence.
+ * Returns its length.
*/
-static void diff_compute_lcs(const xbt_dynar_t da, int a0, int len_a,
- const xbt_dynar_t db, int b0, int len_b,
- xbt_dynar_t common_sequence,
- struct subsequence *seqs, int *fp)
+static int diff_compute_lcs(const char *vec_a[], int a0, int len_a,
+ const char *vec_b[], int b0, int len_b,
+ xbt_dynar_t common_sequence,
+ struct subsequence *seqs, int *fp)
{
if (len_a > 0 && len_b > 0) {
struct subsequence subseq;
- int ses_len = diff_middle_subsequence(da, a0, len_a, db, b0, len_b,
+ int ses_len = diff_middle_subsequence(vec_a, a0, len_a, vec_b, b0, len_b,
&subseq, seqs, fp);
- if (ses_len > 1) {
- int u = subseq.x + subseq.len;
- int v = subseq.y + subseq.len;
- diff_compute_lcs(da, a0, subseq.x - a0, db, b0, subseq.y - b0,
- common_sequence, seqs, fp);
+ int lcs_len = (len_a + len_b - ses_len) / 2;
+ if (lcs_len == 0) {
+ return 0;
+ } else if (ses_len > 1) {
+ int lcs_len1 = subseq.len;
+ if (lcs_len1 < lcs_len)
+ lcs_len1 += diff_compute_lcs(vec_a, a0, subseq.x - a0,
+ vec_b, b0, subseq.y - b0,
+ common_sequence, seqs, fp);
if (subseq.len > 0)
xbt_dynar_push(common_sequence, &subseq);
- diff_compute_lcs(da, u, a0 + len_a - u, db, v, b0 + len_b - v,
- common_sequence, seqs, fp);
+ if (lcs_len1 < lcs_len) {
+ int u = subseq.x + subseq.len;
+ int v = subseq.y + subseq.len;
+ diff_compute_lcs(vec_a, u, a0 + len_a - u, vec_b, v, b0 + len_b - v,
+ common_sequence, seqs, fp);
+ }
} else {
int len = MIN(len_a, len_b) - subseq.len;
if (subseq.x == a0 && subseq.y == b0) {
xbt_dynar_push(common_sequence, &subseq);
}
}
+ return lcs_len;
+ } else {
+ return 0;
}
}
-static int diff_member(const char *s, xbt_dynar_t d, int from, int to)
+static int diff_member(const char *s, const char *vec[], int from, int to)
{
for ( ; from < to ; from++)
- if (!strcmp(s, xbt_dynar_get_as(d, from, char *)))
+ if (!strcmp(s, vec[from]))
return 1;
return 0;
}
/* Extract common prefix.
*/
-static void diff_easy_prefix(const xbt_dynar_t da, int *a0_p, int *len_a_p,
- const xbt_dynar_t db, int *b0_p, int *len_b_p,
+static void diff_easy_prefix(const char *vec_a[], int *a0_p, int *len_a_p,
+ const char *vec_b[], int *b0_p, int *len_b_p,
xbt_dynar_t common_sequence)
{
int a0 = *a0_p;
while (len_a > 0 && len_b > 0) {
struct subsequence subseq = {a0, b0, 0};
- while (len_a > 0 && len_b > 0 && !strcmp(xbt_dynar_get_as(da, a0, char*),
- xbt_dynar_get_as(db, b0, char*))) {
+ while (len_a > 0 && len_b > 0 && !strcmp(vec_a[a0], vec_b[b0])) {
a0++, len_a--;
b0++, len_b--;
subseq.len++;
if (subseq.len > 0)
xbt_dynar_push(common_sequence, &subseq);
if (len_a > 0 && len_b > 0 &&
- !diff_member(xbt_dynar_get_as(da, a0, char*),
- db, b0 + 1, b0 + len_b)) {
+ !diff_member(vec_a[a0], vec_b, b0 + 1, b0 + len_b)) {
a0++, len_a--;
} else {
break;
/* Extract common suffix.
*/
-static void diff_easy_suffix(const xbt_dynar_t da, int *a0_p, int *len_a_p,
- const xbt_dynar_t db, int *b0_p, int *len_b_p,
+static void diff_easy_suffix(const char *vec_a[], int *a0_p, int *len_a_p,
+ const char *vec_b[], int *b0_p, int *len_b_p,
xbt_dynar_t common_suffix)
{
int a0 = *a0_p;
struct subsequence subseq;
subseq.len = 0;
while (len_a > 0 && len_b > 0 &&
- !strcmp(xbt_dynar_get_as(da, a0 + len_a - 1, char*),
- xbt_dynar_get_as(db, b0 + len_b - 1, char*))) {
+ !strcmp(vec_a[a0 + len_a - 1], vec_b[b0 + len_b - 1])) {
len_a--;
len_b--;
subseq.len++;
xbt_dynar_push(common_suffix, &subseq);
}
if (len_a > 0 && len_b > 0 &&
- !diff_member(xbt_dynar_get_as(db, b0 + len_b - 1, char*),
- da, a0, a0 + len_a - 1)) {
+ !diff_member(vec_b[b0 + len_b - 1], vec_a, a0, a0 + len_a - 1)) {
len_b--;
} else {
break;
xbt_dynar_t db = xbt_str_split(b, "\n");
xbt_dynar_t common_sequence, common_suffix;
size_t len;
+ const char **vec_a, **vec_b;
int a0, b0;
int len_a, len_b;
int max;
xbt_dynar_pop(db, NULL);
/* Various initializations */
+ /* Assume that dynar's content is contiguous */
a0 = 0;
len_a = xbt_dynar_length(da);
+ vec_a = len_a ? xbt_dynar_get_ptr(da, 0) : NULL;
b0 = 0;
len_b = xbt_dynar_length(db);
+ vec_b = len_b ? xbt_dynar_get_ptr(db, 0) : NULL;
max = MAX(len_a, len_b) + 1;
fp_base = xbt_new(int, 2 * max + 1);
fp = fp_base + max; /* indexes in [-max..max] */
xbt_dynar_push(common_suffix, &subseq);
/* Compute the Longest Common Subsequence */
- diff_easy_prefix(da, &a0, &len_a, db, &b0, &len_b, common_sequence);
- diff_easy_suffix(da, &a0, &len_a, db, &b0, &len_b, common_suffix);
- diff_compute_lcs(da, a0, len_a, db, b0, len_b, common_sequence, seqs, fp);
+ diff_easy_prefix(vec_a, &a0, &len_a, vec_b, &b0, &len_b, common_sequence);
+ diff_easy_suffix(vec_a, &a0, &len_a, vec_b, &b0, &len_b, common_suffix);
+ diff_compute_lcs(vec_a, a0, len_a, vec_b, b0, len_b, common_sequence, seqs, fp);
while (!xbt_dynar_is_empty(common_suffix)) {
xbt_dynar_pop(common_suffix, &subseq);
xbt_dynar_push(common_sequence, &subseq);
y = 0;
xbt_dynar_foreach(common_sequence, s, subseq) {
while (x < subseq.x) {
- char *topush = bprintf("- %s", xbt_dynar_get_as(da, x++, char*));
+ char *topush = bprintf("- %s", vec_a[x++]);
xbt_dynar_push_as(diff, char*, topush);
}
while (y < subseq.y) {
- char *topush = bprintf("+ %s", xbt_dynar_get_as(db, y++, char*));
+ char *topush = bprintf("+ %s", vec_b[y++]);
xbt_dynar_push_as(diff, char*, topush);
}
while (x < subseq.x + subseq.len) {
- char *topush = bprintf(" %s", xbt_dynar_get_as(da, x++, char*));
+ char *topush = bprintf(" %s", vec_a[x++]);
xbt_dynar_push_as(diff, char*, topush);
y++;
}
return res;
}
+/** @brief Parse an integer out of a string, or raise an error
+ *
+ * The #str is passed as argument to your #error_msg, as follows:
+ * THROWF(arg_error, 0, error_msg, str);
+ */
+long int xbt_str_parse_int(const char* str, const char* error_msg)
+{
+ char *endptr;
+ if (str == NULL || str[0] == '\0')
+ THROWF(arg_error, 0, error_msg, str);
+
+ long int res = strtol(str, &endptr, 10);
+ if (endptr[0] != '\0')
+ THROWF(arg_error, 0, error_msg, str);
+
+ return res;
+}
+/** @brief Parse a double out of a string, or raise an error
+ *
+ * The #str is passed as argument to your #error_msg, as follows:
+ * THROWF(arg_error, 0, error_msg, str);
+ */
+double xbt_str_parse_double(const char* str, const char* error_msg)
+{
+ char *endptr;
+ if (str == NULL || str[0] == '\0')
+ THROWF(arg_error, 0, error_msg, str);
+
+ double res = strtod(str, &endptr);
+ if (endptr[0] != '\0')
+ THROWF(arg_error, 0, error_msg, str);
+
+ return res;
+}
+
#ifdef SIMGRID_TEST
#include "xbt/str.h"
+XBT_TEST_SUITE("xbt_str", "String Handling");
+
#define mytest(name, input, expected) \
xbt_test_add(name); \
d=xbt_str_split_quoted(input); \
input,s,expected);\
free(s); \
xbt_dynar_free(&d);
-
-XBT_TEST_SUITE("xbt_str", "String Handling");
XBT_TEST_UNIT("xbt_str_split_quoted", test_split_quoted, "test the function xbt_str_split_quoted")
{
xbt_dynar_t d;
}
}
+#define test_parse_error(function, name, variable, str) \
+ do { \
+ xbt_test_add(name); \
+ TRY { \
+ variable = function(str, "Parse error"); \
+ xbt_test_fail("The test '%s' did not detect the problem",name ); \
+ } CATCH(e) { \
+ if (e.category != arg_error) { \
+ xbt_test_exception(e); \
+ } else { \
+ xbt_ex_free(e); \
+ } \
+ } \
+ } while (0)
+#define test_parse_ok(function, name, variable, str, value) \
+ do { \
+ xbt_test_add(name); \
+ TRY { \
+ variable = function(str, "Parse error"); \
+ } CATCH(e) { \
+ xbt_test_exception(e); \
+ } \
+ xbt_test_assert(variable == value, "Fail to parse '%s'", str); \
+ } while (0)
+
+XBT_TEST_UNIT("xbt_str_parse", test_parse, "Test the parsing functions")
+{
+ xbt_ex_t e;
+ int rint = -9999;
+ test_parse_ok(xbt_str_parse_int, "Parse int", rint, "42", 42);
+ test_parse_ok(xbt_str_parse_int, "Parse 0 as an int", rint, "0", 0);
+ test_parse_ok(xbt_str_parse_int, "Parse -1 as an int", rint, "-1", -1);
+
+ test_parse_error(xbt_str_parse_int, "Parse int + noise", rint, "342 cruft");
+ test_parse_error(xbt_str_parse_int, "Parse NULL as an int", rint, NULL);
+ test_parse_error(xbt_str_parse_int, "Parse '' as an int", rint, "");
+ test_parse_error(xbt_str_parse_int, "Parse cruft as an int", rint, "cruft");
+
+ double rdouble = -9999;
+ test_parse_ok(xbt_str_parse_double, "Parse 42 as a double", rdouble, "42", 42);
+ test_parse_ok(xbt_str_parse_double, "Parse 42.5 as a double", rdouble, "42.5", 42.5);
+ test_parse_ok(xbt_str_parse_double, "Parse 0 as a double", rdouble, "0", 0);
+ test_parse_ok(xbt_str_parse_double, "Parse -1 as a double", rdouble, "-1", -1);
+
+ test_parse_error(xbt_str_parse_double, "Parse double + noise", rdouble, "342 cruft");
+ test_parse_error(xbt_str_parse_double, "Parse NULL as a double", rdouble, NULL);
+ test_parse_error(xbt_str_parse_double, "Parse '' as a double", rdouble, "");
+ test_parse_error(xbt_str_parse_double, "Parse cruft as a double", rdouble, "cruft");
+}
+
#endif /* SIMGRID_TEST */
