Initial revision

3 files changed, 914 insertions, 0 deletions

diff --git a/dlib/Makefile.am b/dlib/Makefile.am
new file mode 100644
index 00000000..378cd785
--- /dev/null
+++ b/dlib/Makefile.am
@@ -0,0 +1,6 @@
+noinst_LIBRARIES = libDlib.a
+
+libDlib_a_SOURCES = \
+	dlib.h \
+	dlib.c
+	      
diff --git a/dlib/dlib.c b/dlib/dlib.c
new file mode 100644
index 00000000..bba1cc5e
--- /dev/null
+++ b/dlib/dlib.c
@@ -0,0 +1,750 @@
+/*
+ * File: dlib.c
+ *
+ * Copyright (C) 2006 Jorge Arellano Cid <jcid@dillo.org>
+ *
+ * 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 3 of the License, or
+ * (at your option) any later version.
+ */
+
+/* Memory allocation, Simple dynamic strings, Lists (simple and sorted),
+ * and a few utility functions
+ */
+
+/*
+ * TODO: vsnprintf() is in C99, maybe a simple replacement if necessary.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include "dlib.h"
+
+/*
+ *- Memory --------------------------------------------------------------------
+ */
+
+void *dMalloc (size_t size)
+{
+  void *value = malloc (size);
+  if (value == 0)
+     exit(1);
+  return value;
+}
+
+void *dRealloc (void *mem, size_t size)
+{
+  void *value = realloc (mem, size);
+  if (value == 0)
+     exit(1);
+  return value;
+}
+
+void *dMalloc0 (size_t size)
+{
+  void *value = dMalloc (size);
+  memset (value, 0, size);
+  return value;
+}
+
+void dFree (void *mem)
+{
+   if (mem)
+      free(mem);
+}
+
+/*
+ *- strings (char *) ----------------------------------------------------------
+ */
+
+char *dStrdup(const char *s)
+{
+   if (s) {
+      int len = strlen(s)+1;
+      char *ns = dNew(char, len);
+      memcpy(ns, s, len);
+      return ns;
+   }
+   return NULL;
+}
+
+char *dStrndup(const char *s, size_t sz)
+{
+   if (s) {
+      char *ns = dNew(char, sz+1);
+      memcpy(ns, s, sz);
+      ns[sz] = 0;
+      return ns;
+   }
+   return NULL;
+}
+
+/*
+ * Concatenate a NULL-terminated list of strings
+ */
+char *dStrconcat(const char *s1, ...)
+{
+   va_list args;
+   char *s, *ns = NULL;
+
+   if (s1) {
+      Dstr *dstr = dStr_sized_new(64);
+      va_start(args, s1);
+      for (s = (char*)s1; s; s = va_arg(args, char*))
+         dStr_append(dstr, s);
+      va_end(args);
+      ns = dstr->str;
+      dStr_free(dstr, 0);
+   }
+   return ns;
+}
+
+/*
+ * Remove leading and trailing whitespace
+ */
+char *dStrstrip(char *s)
+{
+   char *p;
+   int len;
+
+   if (s && *s) {
+      for (p = s; isspace(*p); ++p);
+      for (len = strlen(p); len && isspace(p[len-1]); --len);
+      if (p > s)
+         memmove(s, p, len);
+      s[len] = 0;
+   }
+   return s;
+}
+
+/*
+ * Return a new string of length 'len' filled with 'c' characters
+ */
+char *dStrnfill(size_t len, char c)
+{
+   char *ret = dNew(char, len+1);
+   for (ret[len] = 0; len > 0; ret[--len] = c);
+   return ret;
+}
+
+/*
+ * strsep() implementation
+ */
+char *dStrsep(char **orig, const char *delim)
+{
+   char *str, *p;
+
+   if (!(str = *orig))
+      return NULL;
+
+   p = strpbrk(str, delim);
+   if (p) {
+      *p++ = 0;
+      *orig = p;
+   } else {
+      *orig = NULL;
+   }
+   return str;
+}
+
+/*
+ * Case insensitive strstr
+ */
+char *dStristr(const char *haystack, const char *needle)
+{
+   int i, j;
+
+   for (i = 0, j = 0; haystack[i] && needle[j]; ++i)
+      if (tolower(haystack[i]) == tolower(needle[j])) {
+         ++j;
+      } else if (j) {
+         i -= j;
+         j = 0;
+      }
+
+   if (!needle[j])                 /* Got all */
+      return (char *)(haystack + i - j);
+   return NULL;
+}
+
+
+/*
+ *- dStr ----------------------------------------------------------------------
+ */
+
+/*
+ * Private allocator
+ */
+static void dStr_resize(Dstr *ds, int n_sz, int keep)
+{
+   if (n_sz >= 0) {
+      if (keep && n_sz > ds->len) {
+         ds->str = (Dstr_char_t*) dRealloc (ds->str, n_sz*sizeof(Dstr_char_t));
+         ds->sz = n_sz;
+      } else {
+         if (ds->str)
+            free(ds->str);
+         ds->str = dNew(Dstr_char_t, n_sz);
+         ds->sz = n_sz;
+         ds->len = 0;
+         ds->str[0] = 0;
+      }
+   }
+}
+
+/*
+ * Create a new string with a given size.
+ * Initialized to ""
+ */
+Dstr *dStr_sized_new (int sz)
+{
+   if (sz < 2)
+      sz = 2;
+
+   Dstr *ds = dNew(Dstr, 1);
+   ds->str = NULL;
+   dStr_resize(ds, sz, 0);
+   return ds;
+}
+
+/*
+ * Return memory if there's too much allocated
+ */
+void dStr_fit (Dstr *ds)
+{
+   dStr_resize(ds, ds->len + 1, 1);
+}
+
+/*
+ * Insert a C string, at a given position, into a Dstr (providing length).
+ * Note: It also works with embedded nil characters.
+ */
+void dStr_insert_l (Dstr *ds, int pos_0, const char *s, int l)
+{
+   int n_sz;
+
+   if (ds && s && l && pos_0 >= 0 && pos_0 <= ds->len) {
+      for (n_sz = ds->sz; ds->len + l >= n_sz; n_sz *= 2);
+      if (n_sz > ds->sz) {
+         dStr_resize(ds, n_sz, (ds->len > 0) ? 1 : 0);
+      }
+      if (pos_0 < ds->len)
+         memmove(ds->str+pos_0+l, ds->str+pos_0, ds->len-pos_0);
+      memcpy(ds->str+pos_0, s, l);
+      ds->len += l;
+      ds->str[ds->len] = 0;
+   }
+}
+
+/*
+ * Insert a C string, at a given position, into a Dstr
+ */
+void dStr_insert (Dstr *ds, int pos_0, const char *s)
+{
+   if (s)
+      dStr_insert_l(ds, pos_0, s, strlen(s));
+}
+
+/*
+ * Append a C string to a Dstr (providing length).
+ * Note: It also works with embedded nil characters.
+ */
+void dStr_append_l (Dstr *ds, const char *s, int l)
+{
+   dStr_insert_l(ds, ds->len, s, l);
+}
+
+/*
+ * Append a C string to a Dstr.
+ */
+void dStr_append (Dstr *ds, const char *s)
+{
+   dStr_append_l(ds, s, strlen(s));
+}
+
+/*
+ * Create a new string.
+ * Initialized to 's' or empty if 's == NULL'
+ */
+Dstr *dStr_new (const char *s)
+{
+   Dstr *ds = dStr_sized_new(0);
+   if (s)
+      dStr_append(ds, s);
+   return ds;
+}
+
+/*
+ * Free a dillo string.
+ * if 'all' free everything, else free the structure only.
+ */
+void dStr_free (Dstr *ds, int all)
+{
+   if (ds) {
+      if (all && ds->str)
+         free(ds->str);
+      free(ds);
+   }
+}
+
+/*
+ * Append one character.
+ */
+void dStr_append_c (Dstr *ds, int c)
+{
+   char cs[2];
+
+   if (ds) {
+      if (ds->sz > ds->len + 1) {
+         ds->str[ds->len++] = (Dstr_char_t)c;
+         ds->str[ds->len] = 0;
+      } else {
+         cs[0] = (Dstr_char_t)c;
+         cs[1] = 0;
+         dStr_append_l (ds, cs, 1);
+      }
+   }
+}
+
+/*
+ * Truncate a Dstr to be 'len' bytes long.
+ */
+void dStr_truncate (Dstr *ds, int len)
+{
+   if (ds && len < ds->len) {
+      ds->str[len] = 0;
+      ds->len = len;
+   }
+}
+
+/*
+ * Erase a substring.
+ */
+void dStr_erase (Dstr *ds, int pos_0, int len)
+{
+   if (ds && pos_0 >= 0 && len > 0 && pos_0 + len <= ds->len) {
+      memmove(ds->str + pos_0, ds->str + pos_0 + len, ds->len - pos_0 - len);
+      ds->len -= len;
+      ds->str[ds->len] = 0;
+   }
+}
+
+/*
+ * vsprintf-like function that appends.
+ * Used by: dStr_vsprintf(), dStr_sprintf() and dStr_sprintfa().
+ */
+void dStr_vsprintfa (Dstr *ds, const char *format, va_list argp)
+{
+   int n, n_sz;
+
+   if (ds && format) {
+      while (1) {
+         n = vsnprintf(ds->str + ds->len, ds->sz - ds->len, format, argp);
+         if (n > -1 && n < ds->sz - ds->len) {
+            ds->len += n;      /* Success! */
+            break;
+         } else if (n > -1) {  /* glibc >= 2.1 */
+            n_sz = ds->len + n + 1;
+         } else {              /* old glibc */
+            n_sz = ds->sz * 2;
+         }
+         dStr_resize(ds, n_sz, (ds->len > 0) ? 1 : 0);
+      }
+   }
+}
+
+/*
+ * vsprintf-like function.
+ */
+void dStr_vsprintf (Dstr *ds, const char *format, va_list argp)
+{
+   if (ds) {
+      dStr_truncate(ds, 0);
+      dStr_vsprintfa(ds, format, argp);
+   }
+}
+
+/*
+ * Printf-like function
+ */
+void dStr_sprintf (Dstr *ds, const char *format, ...)
+{
+   va_list argp;
+
+   if (ds && format) {
+      va_start(argp, format);
+      dStr_vsprintf(ds, format, argp);
+      va_end(argp);
+   }
+}
+
+/*
+ * Printf-like function that appends.
+ */
+void dStr_sprintfa (Dstr *ds, const char *format, ...)
+{
+   va_list argp;
+
+   if (ds && format) {
+      va_start(argp, format);
+      dStr_vsprintfa(ds, format, argp);
+      va_end(argp);
+   }
+}
+
+/*
+ *- dList ---------------------------------------------------------------------
+ */
+
+/*
+ * Create a new empty list
+ */
+Dlist *dList_new(int size)
+{
+   if (size <= 0)
+      return NULL;
+
+   Dlist *l = dNew(Dlist, 1);
+   l->len = 0;
+   l->sz = size;
+   l->list = dNew(void*, l->sz);
+   return l;
+}
+
+/*
+ * Free a list (not its elements)
+ */
+void dList_free (Dlist *lp)
+{
+   if (!lp)
+      return;
+
+   dFree(lp->list);
+   dFree(lp);
+}
+
+/*
+ * Insert an element at a given position [0 based]
+ */
+void dList_insert_pos (Dlist *lp, void *data, int pos0)
+{
+   int i;
+
+   if (!lp || pos0 < 0 || pos0 > lp->len)
+      return;
+
+   if (lp->sz == lp->len) {
+      lp->sz *= 2;
+      lp->list = (void**) dRealloc (lp->list, lp->sz*sizeof(void*));
+   }
+   ++lp->len;
+
+   for (i = lp->len - 1; i > pos0; --i)
+      lp->list[i] = lp->list[i - 1];
+   lp->list[pos0] = data;
+}
+
+/*
+ * Append a data item to the list
+ */
+void dList_append (Dlist *lp, void *data)
+{
+   dList_insert_pos(lp, data, lp->len);
+}
+
+/*
+ * Prepend a data item to the list
+ */
+void dList_prepend (Dlist *lp, void *data)
+{
+   dList_insert_pos(lp, data, 0);
+}
+
+/*
+ * For completing the ADT.
+ */
+int dList_length (Dlist *lp)
+{
+   if (!lp)
+      return 0;
+   return lp->len;
+}
+
+/*
+ * Remove a data item without preserving order.
+ */
+void dList_remove_fast (Dlist *lp, const void *data)
+{
+   int i;
+
+   if (!lp)
+      return;
+
+   for (i = 0; i < lp->len; ++i) {
+      if (lp->list[i] == data) {
+         lp->list[i] = lp->list[--lp->len];
+         break;
+      }
+   }
+}
+
+/*
+ * Remove a data item preserving order.
+ */
+void dList_remove (Dlist *lp, const void *data)
+{
+   int i, j;
+
+   if (!lp)
+      return;
+
+   for (i = 0; i < lp->len; ++i) {
+      if (lp->list[i] == data) {
+         --lp->len;
+         for (j = i; j < lp->len; ++j)
+            lp->list[j] = lp->list[j + 1];
+         break;
+      }
+   }
+}
+
+/*
+ * Return the nth data item,
+ * NULL when not found or 'n0' is out of range
+ */
+void *dList_nth_data (Dlist *lp, int n0)
+{
+   if (!lp || n0 < 0 || n0 >= lp->len)
+      return NULL;
+   return lp->list[n0];
+}
+
+/*
+ * Return the found data item, or NULL if not present.
+ */
+void *dList_find (Dlist *lp, const void *data)
+{
+   int i = dList_find_idx(lp, data);
+   return (i >= 0) ? lp->list[i] : NULL;
+}
+
+/*
+ * Search a data item.
+ * Return value: its index if found, -1 if not present.
+ * (this is useful for a list of integers, for finding number zero).
+ */
+int dList_find_idx (Dlist *lp, const void *data)
+{
+   int i, ret = -1;
+
+   if (!lp)
+      return ret;
+
+   for (i = 0; i < lp->len; ++i) {
+      if (lp->list[i] == data) {
+         ret = i;
+         break;
+      }
+   }
+   return ret;
+}
+
+/*
+ * Search a data item using a custom function.
+ * func() is given the list item and the user data as parameters.
+ * Return: data item when found, NULL otherwise.
+ */
+void *dList_find_custom (Dlist *lp, const void *data, dCompareFunc func)
+{
+   int i;
+   void *ret = NULL;
+
+   if (!lp)
+      return ret;
+
+   for (i = 0; i < lp->len; ++i) {
+      if (func(lp->list[i], data) == 0) {
+         ret = lp->list[i];
+         break;
+      }
+   }
+   return ret;
+}
+
+/*
+ * QuickSort implementation.
+ * This allows for a simple compare function for all the ADT.
+ */
+static void QuickSort(void **left, void **right, dCompareFunc compare)
+{
+  void **p = left, **q = right, **t = left;
+
+  while (1) {
+     while (p != t && compare(*p, *t) < 0)
+        ++p;
+     while (q != t && compare(*q, *t) > 0)
+        --q;
+     if (p > q)
+        break;
+     if (p < q) {
+        void *tmp = *p;
+        *p = *q;
+        *q = tmp;
+        if (t == p)
+           t = q;
+        else if (t == q)
+           t = p;
+     }
+     if (++p > --q)
+        break;
+  }
+
+  if (left < q)
+     QuickSort(left, q, compare);
+  if (p < right)
+     QuickSort(p, right, compare);
+}
+
+/*
+ * Sort the list using a custom function
+ */
+void dList_sort (Dlist *lp, dCompareFunc func)
+{
+   if (lp && lp->len > 1) {
+      QuickSort(lp->list, lp->list + lp->len - 1, func);
+   }
+}
+
+/*
+ * Insert an element into a sorted list.
+ * The comparison function receives two list elements.
+ */
+void dList_insert_sorted (Dlist *lp, void *data, dCompareFunc func)
+{
+   int i, st, min, max;
+
+   if (lp) {
+      min = st = i = 0;
+      max = lp->len - 1;
+      while (min <= max) {
+         i = (min + max) / 2;
+         st = func(lp->list[i], data);
+         if (st < 0) {
+            min = i + 1;
+         } else if (st > 0) {
+            max = i - 1;
+         } else {
+            break;
+         }
+      }
+      dList_insert_pos(lp, data, (st >= 0) ? i : i+1);
+   }
+}
+
+/*
+ * Search a sorted list.
+ * Return the found data item, or NULL if not present.
+ * func() is given the list item and the user data as parameters.
+ */
+void *dList_find_sorted (Dlist *lp, const void *data, dCompareFunc func)
+{
+   int i, st, min, max;
+   void *ret = NULL;
+
+   if (lp && lp->len) {
+      min = 0;
+      max = lp->len - 1;
+      while (min <= max) {
+         i = (min + max) / 2;
+         st = func(lp->list[i], data);
+         if (st < 0) {
+            min = i + 1;
+         } else if (st > 0) {
+            max = i - 1;
+         } else {
+            ret = lp->list[i];
+            break;
+         }
+      }
+   }
+
+   return ret;
+}
+
+/*
+ *- Misc utility functions ----------------------------------------------------
+ */
+
+/*
+ * Return the current working directory in a new string
+ */
+char *dGetcwd ()
+{
+  size_t size = 128;
+
+  while (1) {
+      char *buffer = dNew(char, size);
+      if (getcwd (buffer, size) == buffer)
+        return buffer;
+      dFree (buffer);
+      if (errno != ERANGE)
+        return 0;
+      size *= 2;
+  }
+}
+
+/*
+ * Return the home directory in a static string (don't free)
+ */
+char *dGethomedir ()
+{
+   static char *homedir = NULL;
+
+   if (!homedir) {
+      if (getenv("HOME")) {
+         homedir = dStrdup(getenv("HOME"));
+
+      } else if (getenv("HOMEDRIVE") && getenv("HOMEPATH")) {
+         homedir = dStrconcat(getenv("HOMEDRIVE"), getenv("HOMEPATH"), NULL);
+      }
+   }
+   return homedir;
+}
+
+/*
+ * Get a line from a FILE stream.
+ * It handles backslash as line-continues character.
+ * Return value: read line on success, NULL on EOF.
+ */
+char *dGetline (FILE *stream)
+{
+   int ch;
+   Dstr *dstr;
+   char *line;
+
+   dReturn_val_if_fail (stream, 0);
+
+   dstr = dStr_sized_new(64);
+   while((ch = fgetc(stream)) != EOF) {
+      if (ch == '\\') {
+         /* continue with the next line */
+         while((ch = fgetc(stream)) != EOF && ch != '\n');
+         continue;
+      }
+      dStr_append_c(dstr, ch);
+      if (ch == '\n')
+         break;
+   }
+
+   line = (dstr->len) ? dstr->str : NULL;
+   dStr_free(dstr, (line) ? 0 : 1);
+   return line;
+}
+
diff --git a/dlib/dlib.h b/dlib/dlib.h
new file mode 100644
index 00000000..6caf7c97
--- /dev/null
+++ b/dlib/dlib.h
@@ -0,0 +1,158 @@
+#ifndef __DLIB_H__
+#define __DLIB_H__
+
+#include <stdio.h>     /* for FILE*  */
+#include <stddef.h>    /* for size_t */
+#include <stdarg.h>    /* for va_list */
+#include <string.h>    /* for strerror */
+#include <strings.h>   /* for strcasecmp, strncasecmp (POSIX 2001) */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+ *-- Common macros -----------------------------------------------------------
+ */
+#ifndef FALSE
+#define FALSE   (0)
+#endif
+
+#ifndef TRUE
+#define TRUE    (!FALSE)
+#endif
+
+#undef  MAX
+#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
+
+#undef  MIN
+#define MIN(a, b)  (((a) < (b)) ? (a) : (b))
+
+/*
+ *-- Casts -------------------------------------------------------------------
+ */
+/* TODO: include a void* size test in configure.in */
+#define VOIDP2INT(p)    ((int)(p))
+#define INT2VOIDP(i)    ((void*)(i))
+
+/*
+ *-- Memory -------------------------------------------------------------------
+ */
+#define dNew(type, count) \
+   ((type *) dMalloc ((unsigned) sizeof (type) * (count)))
+#define dNew0(type, count) \
+   ((type *) dMalloc0 ((unsigned) sizeof (type) * (count)))
+
+void *dMalloc (size_t size);
+void *dRealloc (void *mem, size_t size);
+void *dMalloc0 (size_t size);
+void dFree (void *mem);
+
+/*
+ *- Debug macros --------------------------------------------------------------
+ */
+#define D_STMT_START      do
+#define D_STMT_END        while (0)
+#define dReturn_if_fail(expr)          \
+   D_STMT_START{                       \
+      if (!(expr)) { return; };        \
+   }D_STMT_END
+#define dReturn_val_if_fail(expr,val)  \
+   D_STMT_START{                       \
+      if (!(expr)) { return val; };    \
+   }D_STMT_END
+
+/*
+ *- C strings -----------------------------------------------------------------
+ */
+char *dStrdup(const char *s);
+char *dStrndup(const char *s, size_t sz);
+char *dStrconcat(const char *s1, ...);
+char *dStrstrip(char *s);
+char *dStrnfill(size_t len, char c);
+char *dStrsep(char **orig, const char *delim);
+char *dStristr(const char *haystack, const char *needle);
+
+/* these are in POSIX 2001. Could be implemented if a port requires it */
+#define dStrcasecmp strcasecmp
+#define dStrncasecmp strncasecmp
+#define dStrerror strerror
+
+/*
+ *-- dStr ---------------------------------------------------------------------
+ */
+#define Dstr_char_t    char
+
+typedef struct _dstr {
+   int sz;          /* allocated size (private) */
+   int len;
+   Dstr_char_t *str;
+} Dstr;
+
+Dstr *dStr_new (const char *s);
+Dstr *dStr_sized_new (int sz);
+void dStr_fit (Dstr *ds);
+void dStr_free (Dstr *ds, int all);
+void dStr_append_c (Dstr *ds, int c);
+void dStr_append (Dstr *ds, const char *s);
+void dStr_append_l (Dstr *ds, const char *s, int l);
+void dStr_insert (Dstr *ds, int pos_0, const char *s);
+void dStr_insert_l (Dstr *ds, int pos_0, const char *s, int l);
+void dStr_truncate (Dstr *ds, int len);
+void dStr_erase (Dstr *ds, int pos_0, int len);
+void dStr_vsprintfa (Dstr *ds, const char *format, va_list argp);
+void dStr_vsprintf (Dstr *ds, const char *format, va_list argp);
+void dStr_sprintf (Dstr *ds, const char *format, ...);
+void dStr_sprintfa (Dstr *ds, const char *format, ...);
+
+/*
+ *-- dList --------------------------------------------------------------------
+ */
+struct Dlist_ {
+   int sz;          /* allocated size (private) */
+   int len;
+   void **list;
+};
+
+typedef struct Dlist_ Dlist;
+
+/* dCompareFunc:
+ * Return: 0 if parameters are equal (for dList_find_custom).
+ * Return: 0 if equal,  < 0 if (a < b),  > 0 if (b < a) --for insert sorted.
+ *
+ * For finding a data node with an external key, the comparison function
+ * parameters are: first the data node, and then the key.
+ */
+typedef int (*dCompareFunc) (const void *a, const void *b);
+
+
+Dlist *dList_new(int size);
+void dList_free (Dlist *lp);
+void dList_append (Dlist *lp, void *data);
+void dList_prepend (Dlist *lp, void *data);
+int  dList_length (Dlist *lp);
+void dList_remove (Dlist *lp, const void *data);
+void dList_remove_fast (Dlist *lp, const void *data);
+void *dList_nth_data (Dlist *lp, int n0);
+void *dList_find (Dlist *lp, const void *data);
+int  dList_find_idx (Dlist *lp, const void *data);
+void *dList_find_custom (Dlist *lp, const void *data, dCompareFunc func);
+void dList_sort (Dlist *lp, dCompareFunc func);
+void dList_insert_sorted (Dlist *lp, void *data, dCompareFunc func);
+void *dList_find_sorted (Dlist *lp, const void *data, dCompareFunc func);
+
+/*
+ *- Misc utility functions ----------------------------------------------------
+ */
+char *dGetcwd ();
+char *dGethomedir ();
+char *dGetline (FILE *stream);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __DLIB_H__ */
+