Initial revision

1 files changed, 446 insertions, 0 deletions

diff --git a/lib/ephy-string.c b/lib/ephy-string.c
new file mode 100644
index 000000000..7ca28cf1f
--- /dev/null
+++ b/lib/ephy-string.c
@@ -0,0 +1,446 @@
+/*
+ *  Copyright (C) 2002 Marco Pesenti Gritti
+ *
+ *  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, 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-1307, USA.
+ */
+
+#include "ephy-string.h"
+
+#include <string.h>
+#include <glib.h>
+#include <libgnome/libgnome.h>
+#include <libgnome/gnome-i18n.h>
+#include <libgnomevfs/gnome-vfs-mime.h>
+#include <libxml/parser.h>
+
+/**
+ * ephy_string_shorten: returns a newly allocated shortened version of str.
+ * the new string will be no longer than target_length characters, and will
+ * be of the form "http://blahblah...blahblah.html".
+ */
+gchar *
+ephy_string_shorten (const gchar *str, gint target_length)
+{
+	gchar *new_str;
+	gint actual_length, first_length, second_length;
+
+	if (!str) return NULL;
+
+	actual_length = strlen (str);
+
+	/* if the string is already short enough, or if it's too short for
+	 * us to shorten it, return a new copy */
+	if (actual_length <= target_length ||
+	    actual_length <= 3)
+		return g_strdup (str);
+
+	/* allocate new string */
+	new_str = g_new (gchar, target_length + 1);
+
+	/* calc lengths to take from beginning and ending of str */
+	second_length = (target_length - 3) / 2;
+	first_length = target_length - 3 - second_length;
+
+	/* create string */
+	strncpy (new_str, str, first_length);
+	strncpy (new_str + first_length, "...", 3);
+	strncpy (new_str + first_length + 3,
+		 str + actual_length - second_length, second_length);
+	new_str[target_length] = '\0';
+
+	return new_str;
+}
+
+char *
+ephy_string_double_underscores (const char *string)
+{
+        int underscores;
+        const char *p;
+        char *q;
+        char *escaped;
+
+        if (string == NULL) {
+                return NULL;
+        }
+
+        underscores = 0;
+        for (p = string; *p != '\0'; p++) {
+                underscores += (*p == '_');
+        }
+
+        if (underscores == 0) {
+                return g_strdup (string);
+        }
+
+        escaped = g_new (char, strlen (string) + underscores + 1);
+        for (p = string, q = escaped; *p != '\0'; p++, q++) {
+                /* Add an extra underscore. */
+                if (*p == '_') {
+                        *q++ = '_';
+                }
+                *q = *p;
+        }
+        *q = '\0';
+
+        return escaped;
+}
+
+/**
+ * ephy_string_store_time_in_string:
+ * NOTE: str must be at least 256 chars long
+ */
+void
+ephy_string_store_time_in_string (GDate *t, gchar *str, const char *format)
+{
+	int length;
+
+	if (t > 0)
+	{
+		/* format into string */
+		/* this is used whenever a brief date is needed, like
+		 * in the history (for last visited, first time visited) */
+		length = g_date_strftime (str, 255,
+				          format ? format : _("%Y-%m-%d"), t);
+		str[length] = '\0';
+	}
+	else
+	{
+		str[0] = '\0';
+	}
+}
+
+/**
+ * ephy_string_time_to_string:
+ */
+gchar *
+ephy_string_time_to_string (GDate *t,
+			    const char *format)
+{
+	gchar str[256];
+
+	/* write into stack string */
+	ephy_string_store_time_in_string (t, str, format);
+
+	/* copy in heap and return */
+	return g_strdup (str);
+}
+
+gboolean
+ephy_str_to_int (const char *string, int *integer)
+{
+	long result;
+	char *parse_end;
+
+	/* Check for the case of an empty string. */
+	if (string == NULL || *string == '\0') {
+		return FALSE;
+	}
+
+	/* Call the standard library routine to do the conversion. */
+	errno = 0;
+	result = strtol (string, &parse_end, 0);
+
+	/* Check that the result is in range. */
+	if ((result == G_MINLONG || result == G_MAXLONG) && errno == ERANGE) {
+		return FALSE;
+	}
+	if (result < G_MININT || result > G_MAXINT) {
+		return FALSE;
+	}
+
+	/* Check that all the trailing characters are spaces. */
+	while (*parse_end != '\0') {
+		if (!g_ascii_isspace (*parse_end++)) {
+			return FALSE;
+		}
+	}
+
+	/* Return the result. */
+	*integer = result;
+	return TRUE;
+}
+
+/**
+ * ephy_str_strip_chr:
+ * Remove all occurrences of a character from a string.
+ *
+ * @source: The string to be stripped.
+ * @remove_this: The char to remove from @source
+ *
+ * Return value: A copy of @source, after removing all occurrences
+ * of @remove_this.
+ */
+char *
+ephy_str_strip_chr (const char *source, char remove_this)
+{
+	char *result, *out;
+	const char *in;
+
+        if (source == NULL) {
+		return NULL;
+	}
+
+	result = g_new (char, strlen (source) + 1);
+	in = source;
+	out = result;
+	do {
+		if (*in != remove_this) {
+			*out++ = *in;
+		}
+	} while (*in++ != '\0');
+
+        return result;
+}
+
+int
+ephy_strcasecmp (const char *string_a, const char *string_b)
+{
+        return g_ascii_strcasecmp (string_a == NULL ? "" : string_a,
+                                   string_b == NULL ? "" : string_b);
+}
+
+int
+ephy_strcasecmp_compare_func (gconstpointer string_a, gconstpointer string_b)
+{
+        return ephy_strcasecmp ((const char *) string_a,
+			       (const char *) string_b);
+}
+
+/**
+ * like strpbrk but ignores chars preceded by slashes, unless the
+ * slash is also preceded by a slash unless that later slash is
+ * preceded by another slash... ;-)
+ */
+static char *
+ephy_strpbrk_unescaped (const char *s, const char *accept)
+{
+	gchar *ret = strpbrk (s, accept);
+
+	if (!ret || ret == s || *(ret - 1) != '\\')
+	{
+		return ret;
+	}
+	else
+	{
+		gchar *c = ret - 1;
+		g_assert (*c == '\\');
+
+		while (c >= s && *c == '\\') c--;
+
+		if ((ret - c) % 2 == 0)
+		{
+			return ephy_strpbrk_unescaped (ret + 1, accept);
+		}
+		else
+		{
+			return ret;
+		}
+	}
+}
+
+/**
+ * like strstr but supports quoting, ignoring matches inside quoted text
+ */
+static char *
+ephy_strstr_with_quotes (const char *haystack, const char *needle,
+			 const char *quotes)
+{
+	gchar *quot = ephy_strpbrk_unescaped (haystack, quotes);
+	gchar *ret = strstr (haystack, needle);
+
+	if (!quot || !ret || ret < quot)
+	{
+		return ret;
+	}
+
+	quot = ephy_strpbrk_unescaped (quot + 1, quotes);
+
+	if (quot)
+	{
+		return ephy_strstr_with_quotes (quot + 1, needle, quotes);
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+/**
+ * like strpbrk but supports quoting, ignoring matches inside quoted text
+ */
+static char *
+ephy_strpbrk_with_quotes (const char *haystack, const char *needles,
+			  const char *quotes)
+{
+	gchar *quot = ephy_strpbrk_unescaped (haystack, quotes);
+	gchar *ret = strpbrk (haystack, needles);
+
+	if (!quot || !ret || ret < quot)
+	{
+		return ret;
+	}
+
+	quot = ephy_strpbrk_unescaped (quot + 1, quotes);
+
+	if (quot)
+	{
+		return ephy_strpbrk_with_quotes (quot + 1, needles, quotes);
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+/**
+ * Like g_strsplit, but does not split tokens betwen quotes. Ignores
+ * quotes preceded by '\'.
+ */
+gchar **
+ephy_strsplit_with_quotes (const gchar *string,
+			   const gchar *delimiter,
+			   gint max_tokens,
+			   const gchar *quotes)
+{
+	GSList *string_list = NULL, *slist;
+	gchar **str_array, *s;
+	guint n = 0;
+	const gchar *remainder;
+
+	g_return_val_if_fail (string != NULL, NULL);
+	g_return_val_if_fail (delimiter != NULL, NULL);
+	g_return_val_if_fail (delimiter[0] != '\0', NULL);
+
+	if (quotes == NULL)
+	{
+		return g_strsplit (string, delimiter, max_tokens);
+	}
+
+	if (max_tokens < 1)
+	{
+		max_tokens = G_MAXINT;
+	}
+
+	remainder = string;
+	s = ephy_strstr_with_quotes (remainder, delimiter, quotes);
+	if (s)
+	{
+		gsize delimiter_len = strlen (delimiter);
+
+		while (--max_tokens && s)
+		{
+			gsize len;
+			gchar *new_string;
+
+			len = s - remainder;
+			new_string = g_new (gchar, len + 1);
+			strncpy (new_string, remainder, len);
+			new_string[len] = 0;
+			string_list = g_slist_prepend (string_list, new_string);
+			n++;
+			remainder = s + delimiter_len;
+			s = ephy_strstr_with_quotes (remainder, delimiter, quotes);
+		}
+	}
+	if (*string)
+	{
+		n++;
+		string_list = g_slist_prepend (string_list, g_strdup (remainder));
+	}
+
+	str_array = g_new (gchar*, n + 1);
+
+	str_array[n--] = NULL;
+	for (slist = string_list; slist; slist = slist->next)
+	{
+		str_array[n--] = slist->data;
+	}
+
+	g_slist_free (string_list);
+
+	return str_array;
+}
+
+/**
+ * like ephy_strsplit_with_quotes, but matches any char in 'delimiters' as delimiter
+ * and does not return empty tokens
+ */
+gchar **
+ephy_strsplit_multiple_delimiters_with_quotes (const gchar *string,
+					       const gchar *delimiters,
+					       gint max_tokens,
+					       const gchar *quotes)
+{
+	GSList *string_list = NULL, *slist;
+	gchar **str_array, *s;
+	guint n = 0;
+	const gchar *remainder;
+
+	g_return_val_if_fail (string != NULL, NULL);
+	g_return_val_if_fail (delimiters != NULL, NULL);
+	g_return_val_if_fail (delimiters[0] != '\0', NULL);
+
+	if (quotes == NULL)
+	{
+		quotes = "";
+	}
+
+	if (max_tokens < 1)
+	{
+		max_tokens = G_MAXINT;
+	}
+
+	remainder = string;
+	s = ephy_strpbrk_with_quotes (remainder, delimiters, quotes);
+	if (s)
+	{
+		const gsize delimiter_len = 1; /* only chars */
+
+		while (--max_tokens && s)
+		{
+			gsize len;
+			gchar *new_string;
+
+			len = s - remainder;
+			if (len > 0) /* ignore empty strings */
+			{
+				new_string = g_new (gchar, len + 1);
+				strncpy (new_string, remainder, len);
+				new_string[len] = 0;
+				string_list = g_slist_prepend (string_list, new_string);
+				n++;
+			}
+			remainder = s + delimiter_len;
+			s = ephy_strpbrk_with_quotes (remainder, delimiters, quotes);
+		}
+	}
+	if (*string)
+	{
+		n++;
+		string_list = g_slist_prepend (string_list, g_strdup (remainder));
+	}
+
+	str_array = g_new (gchar*, n + 1);
+
+	str_array[n--] = NULL;
+	for (slist = string_list; slist; slist = slist->next)
+	{
+		str_array[n--] = slist->data;
+	}
+
+	g_slist_free (string_list);
+
+	return str_array;
+}