/*
- * Copyright (c) 2008 Nicira Networks.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <config.h>
#include "dynamic-string.h"
-#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "timeval.h"
#include "util.h"
+/* Initializes 'ds' as an empty string buffer. */
void
ds_init(struct ds *ds)
{
ds->allocated = 0;
}
+/* Sets 'ds''s length to 0, effectively clearing any existing content. Does
+ * not free any memory. */
void
-ds_clear(struct ds *ds)
+ds_clear(struct ds *ds)
{
ds->length = 0;
}
+/* Reduces 'ds''s length to no more than 'new_length'. (If its length is
+ * already 'new_length' or less, does nothing.) */
void
ds_truncate(struct ds *ds, size_t new_length)
{
}
}
+/* Ensures that at least 'min_length + 1' bytes (including space for a null
+ * terminator) are allocated for ds->string, allocating or reallocating memory
+ * as necessary. */
void
ds_reserve(struct ds *ds, size_t min_length)
{
}
}
+/* Appends space for 'n' bytes to the end of 'ds->string', increasing
+ * 'ds->length' by the same amount, and returns the first appended byte. The
+ * caller should fill in all 'n' bytes starting at the return value. */
char *
ds_put_uninit(struct ds *ds, size_t n)
{
}
void
-ds_put_char(struct ds *ds, char c)
+ds_put_char__(struct ds *ds, char c)
{
*ds_put_uninit(ds, 1) = c;
}
+/* Appends unicode code point 'uc' to 'ds' in UTF-8 encoding. */
+void
+ds_put_utf8(struct ds *ds, int uc)
+{
+ if (uc <= 0x7f) {
+ ds_put_char(ds, uc);
+ } else if (uc <= 0x7ff) {
+ ds_put_char(ds, 0xc0 | (uc >> 6));
+ ds_put_char(ds, 0x80 | (uc & 0x3f));
+ } else if (uc <= 0xffff) {
+ ds_put_char(ds, 0xe0 | (uc >> 12));
+ ds_put_char(ds, 0x80 | ((uc >> 6) & 0x3f));
+ ds_put_char(ds, 0x80 | (uc & 0x3f));
+ } else if (uc <= 0x10ffff) {
+ ds_put_char(ds, 0xf0 | (uc >> 18));
+ ds_put_char(ds, 0x80 | ((uc >> 12) & 0x3f));
+ ds_put_char(ds, 0x80 | ((uc >> 6) & 0x3f));
+ ds_put_char(ds, 0x80 | (uc & 0x3f));
+ } else {
+ /* Invalid code point. Insert the Unicode general substitute
+ * REPLACEMENT CHARACTER. */
+ ds_put_utf8(ds, 0xfffd);
+ }
+}
+
void
ds_put_char_multiple(struct ds *ds, char c, size_t n)
{
memcpy(ds_put_uninit(ds, s_len), s, s_len);
}
+void
+ds_put_and_free_cstr(struct ds *ds, char *s)
+{
+ ds_put_cstr(ds, s);
+ free(s);
+}
+
void
ds_put_format(struct ds *ds, const char *format, ...)
{
if (needed < available) {
ds->length += needed;
} else {
- size_t available;
-
ds_reserve(ds, ds->length + needed);
va_copy(args, args_);
needed = vsnprintf(&ds->string[ds->length], available, format, args);
va_end(args);
- assert(needed < available);
+ ovs_assert(needed < available);
ds->length += needed;
}
}
void
-ds_put_printable(struct ds *ds, const char *s, size_t n)
+ds_put_printable(struct ds *ds, const char *s, size_t n)
{
ds_reserve(ds, ds->length + n);
while (n-- > 0) {
}
}
+/* Writes the current time to 'string' based on 'template'.
+ * The current time is either localtime or UTC based on 'utc'. */
void
-ds_put_strftime(struct ds *ds, const char *template, const struct tm *tm)
+ds_put_strftime(struct ds *ds, const char *template, bool utc)
{
- if (!tm) {
- time_t now = time_now();
+ const struct tm *tm;
+ time_t now = time_wall();
+ if (utc) {
+ tm = gmtime(&now);
+ } else {
tm = localtime(&now);
}
+
for (;;) {
size_t avail = ds->string ? ds->allocated - ds->length + 1 : 0;
size_t used = strftime(&ds->string[ds->length], avail, template, tm);
ds->length += used;
return;
}
- ds_reserve(ds, ds->length + (avail < 32 ? 64 : 2 * avail));
+ ds_reserve(ds, ds->length + (avail < 32 ? 64 : 2 * avail));
}
}
}
}
+/* Reads a line from 'file' into 'ds', clearing anything initially in 'ds'.
+ * Deletes comments introduced by "#" and skips lines that contains only white
+ * space (after deleting comments).
+ *
+ * Returns 0 if successful, EOF if no non-blank line was found. */
+int
+ds_get_preprocessed_line(struct ds *ds, FILE *file)
+{
+ while (!ds_get_line(ds, file)) {
+ char *line = ds_cstr(ds);
+ char *comment;
+
+ /* Delete comments. */
+ comment = strchr(line, '#');
+ if (comment) {
+ *comment = '\0';
+ }
+
+ /* Return successfully unless the line is all spaces. */
+ if (line[strspn(line, " \t\n")] != '\0') {
+ return 0;
+ }
+ }
+ return EOF;
+}
+
+/* Reads a line from 'file' into 'ds' and does some preprocessing on it:
+ *
+ * - If the line begins with #, prints it on stdout and reads the next line.
+ *
+ * - Otherwise, if the line contains an # somewhere else, strips it and
+ * everything following it (as a comment).
+ *
+ * - If (after comment removal) the line contains only white space, prints
+ * a blank line on stdout and reads the next line.
+ *
+ * - Otherwise, returns the line to the caller.
+ *
+ * This is useful in some of the OVS tests, where we want to check that parsing
+ * and then re-formatting some kind of data does not change it, but we also
+ * want to be able to put comments in the input.
+ *
+ * Returns 0 if successful, EOF if no non-blank line was found. */
+int
+ds_get_test_line(struct ds *ds, FILE *file)
+{
+ for (;;) {
+ char *s, *comment;
+ int retval;
+
+ retval = ds_get_line(ds, file);
+ if (retval) {
+ return retval;
+ }
+
+ s = ds_cstr(ds);
+ if (*s == '#') {
+ puts(s);
+ continue;
+ }
+
+ comment = strchr(s, '#');
+ if (comment) {
+ *comment = '\0';
+ }
+ if (s[strspn(s, " \t\n")] == '\0') {
+ putchar('\n');
+ continue;
+ }
+
+ return 0;
+ }
+}
+
char *
ds_cstr(struct ds *ds)
{
return ds->string;
}
+const char *
+ds_cstr_ro(const struct ds *ds)
+{
+ return ds_cstr(CONST_CAST(struct ds *, ds));
+}
+
+/* Returns a null-terminated string representing the current contents of 'ds',
+ * which the caller is expected to free with free(), then clears the contents
+ * of 'ds'. */
+char *
+ds_steal_cstr(struct ds *ds)
+{
+ char *s = ds_cstr(ds);
+ ds_init(ds);
+ return s;
+}
+
void
ds_destroy(struct ds *ds)
{
free(ds->string);
}
+/* Swaps the content of 'a' and 'b'. */
+void
+ds_swap(struct ds *a, struct ds *b)
+{
+ struct ds temp = *a;
+ *a = *b;
+ *b = temp;
+}
+
/* Writes the 'size' bytes in 'buf' to 'string' as hex bytes arranged 16 per
* line. Numeric offsets are also included, starting at 'ofs' for the first
* byte in 'buf'. If 'ascii' is true then the corresponding ASCII characters
git://git.onelab.eu / sliver-openvswitch.git / blobdiff