← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mod-mono/trusty

« back to all changes in this revision

Viewing changes to src/glib_compat.c

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2010-09-13 09:57:05 UTC
  • mfrom: (2.1.22 maverick)
  • Revision ID: james.westby@ubuntu.com-20100913095705-gje0z6f8n80wknf6
Tags: 2.6.3-3
Upload to Debian Unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glib_compat.c
 
1
#ifdef HAVE_CONFIG_H
 
2
#include "mod_mono_config.h"
 
3
#endif
 
4
 
 
5
#include <ctype.h>
 
6
 
 
7
#include "glib_compat.h"
 
8
 
 
9
#define ASCII_TOLOWER(_ch_) (isascii ((int)(_ch_)) && isalpha ((int)(_ch_))) ? tolower ((_ch_)) : (_ch_)
 
10
 
 
11
static gchar *
 
12
g_strndup (const char *str, int n)
 
13
{
 
14
#ifdef HAVE_STRNDUP
 
15
        return strndup (str, n);
 
16
#else
 
17
        if (str) {
 
18
                char *retval = malloc (n + 1);
 
19
                if (retval)
 
20
                        strncpy (retval, str, n)[n] = 0;
 
21
                return retval;
 
22
        }
 
23
        return NULL;
 
24
#endif
 
25
}
 
26
 
 
27
static void add_to_vector (gchar ***vector, int size, gchar *token)
 
28
{
 
29
        *vector = *vector == NULL ? 
 
30
                (gchar **) malloc (2 * sizeof (*vector)) :
 
31
                (gchar **) realloc (*vector, (size + 1) * sizeof (*vector));
 
32
                
 
33
        (*vector)[size - 1] = token;
 
34
}
 
35
 
 
36
static gchar **make_empty_vector ()
 
37
{
 
38
        gchar **vector = (gchar**)malloc (2 * sizeof (vector));
 
39
        vector [0] = NULL;
 
40
 
 
41
        return vector;
 
42
}
 
43
 
 
44
gchar **g_strsplit (const gchar *string, const gchar *delimiter, int max_tokens)
 
45
{
 
46
        gchar **vector = NULL;
 
47
        int delimiter_len = strlen (delimiter);
 
48
        int size = 1;
 
49
        const gchar *c;
 
50
        gchar *token;
 
51
        
 
52
        if (!string || !*string)
 
53
                return make_empty_vector ();
 
54
        
 
55
        if (!delimiter || !*delimiter) {
 
56
                add_to_vector (&vector, size, strdup (string));
 
57
                return vector;
 
58
        }
 
59
        
 
60
        if (strncmp (string, delimiter, delimiter_len) == 0) {
 
61
                add_to_vector (&vector, size, strdup (""));
 
62
                size++;
 
63
                string += delimiter_len;
 
64
        } else
 
65
                vector = NULL;
 
66
 
 
67
        while (*string && !(max_tokens > 0 && size >= max_tokens)) {
 
68
                c = string;
 
69
 
 
70
                if (*string == *delimiter && strncmp (string, delimiter, delimiter_len) == 0) {
 
71
                        token = strdup ("");
 
72
                        string += delimiter_len;
 
73
                } else {
 
74
                        while (*string && (*string != *delimiter || strncmp (string, delimiter, delimiter_len) != 0))
 
75
                                string++;
 
76
 
 
77
                        if (*string) {
 
78
                                size_t toklen = (size_t)(string - c);
 
79
                                token = g_strndup (c, toklen);
 
80
 
 
81
                                if (strcmp (string, delimiter) != 0)
 
82
                                        string += delimiter_len;
 
83
                        } else
 
84
                                token = strdup (c);
 
85
                }
 
86
 
 
87
                add_to_vector (&vector, size, token);
 
88
                size++;
 
89
        }
 
90
 
 
91
        if (*string) {
 
92
                add_to_vector (&vector, size, strdup (string));
 
93
                size++;
 
94
        }
 
95
        
 
96
        if (!vector)
 
97
                return make_empty_vector ();
 
98
        else if (size > 0)
 
99
                vector [size - 1] = NULL;
 
100
        
 
101
        return vector;
 
102
}
 
103
 
 
104
gint g_ascii_strcasecmp (const gchar *s1, const gchar *s2)
 
105
{
 
106
        gchar ch1, ch2;
 
107
        
 
108
        if (s1 == s2)
 
109
                return 0;
 
110
 
 
111
        do {
 
112
                ch1 = ASCII_TOLOWER (*s1);
 
113
                ch2 = ASCII_TOLOWER (*s2);
 
114
 
 
115
                if (ch1 == 0)
 
116
                        break;
 
117
 
 
118
                s1++;
 
119
                s2++;
 
120
        } while (ch1 == ch2);
 
121
 
 
122
        return (ch1 > ch2 ? 1 : ch1 < ch2 ? -1 : 0);
 
123
}
 
124
 
 
125
gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter)
 
126
{
 
127
        gchar *ptr;
 
128
 
 
129
        if (!string)
 
130
                return NULL;
 
131
 
 
132
        if (delimiters == NULL)
 
133
                delimiters = G_STR_DELIMITERS;
 
134
 
 
135
        for (ptr = string; *ptr; ptr++) {
 
136
                if (strchr (delimiters, *ptr))
 
137
                        *ptr = new_delimiter;
 
138
        }
 
139
        
 
140
        return string;
 
141
}
 
142
 
 
143
gchar* g_strdup (const gchar *str)
 
144
{
 
145
        if (!str)
 
146
                return NULL;
 
147
        
 
148
        return (gchar*) strdup (str);
 
149
}
 
150
 
 
151
void g_free (gpointer mem)
 
152
{
 
153
        if (!mem)
 
154
                return;
 
155
 
 
156
        free (mem);
 
157
}
 
158
 
 
159
gboolean g_ascii_isalpha (gchar c)
 
160
{
 
161
        return (isascii ((int)c) && isalpha ((int)c));
 
162
}
 
163
 
 
164
void g_strfreev (gchar **str_array)
 
165
{
 
166
        gchar **orig = str_array;
 
167
        if (str_array == NULL)
 
168
                return;
 
169
        while (*str_array != NULL){
 
170
                g_free (*str_array);
 
171
                str_array++;
 
172
        }
 
173
        g_free (orig);
 
174
}
 
175
 
 
176
gchar *g_strjoinv (const gchar *separator, gchar **str_array)
 
177
{
 
178
        char *res;
 
179
        size_t slen, len, i;
 
180
        
 
181
        if (separator != NULL)
 
182
                slen = strlen (separator);
 
183
        else
 
184
                slen = 0;
 
185
        
 
186
        len = 0;
 
187
        for (i = 0; str_array [i] != NULL; i++){
 
188
                len += strlen (str_array [i]);
 
189
                len += slen;
 
190
        }
 
191
        if (len == 0)
 
192
                return g_strdup ("");
 
193
        if (slen > 0 && len > 0)
 
194
                len -= slen;
 
195
        len++;
 
196
        res = (char*)malloc (len);
 
197
        strcpy (res, str_array [0]);
 
198
        for (i = 1; str_array [i] != NULL; i++){
 
199
                if (separator != NULL)
 
200
                        strcat (res, separator);
 
201
                strcat (res, str_array [i]);
 
202
        }
 
203
        return res;
 
204
}