RPA Toolkit
Work on rmap_t - 2
[rpatk.git] / rlib / rstring.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <stdarg.h>
5
6 #include "rstring.h"
7 #include "rmem.h"
8
9
10 rint r_strcmp(const rchar *s1, const rchar *s2)
11 {
12         return strcmp(s1, s2);
13 }
14
15
16 rint r_strncmp(const rchar *s1, const rchar *s2, rsize_t n)
17 {
18         int ret = strncmp(s1, s2, (size_t)n);
19         return ret;
20 }
21
22
23 rboolean r_stringncmp(const rchar *str, const rchar *s2, rsize_t n)
24 {
25         if (r_strlen(str) == n && r_strncmp(str, s2, (size_t)n) == 0)
26                 return 1;
27         return 0;
28 }
29
30
31 rsize_t r_strlen(const rchar *s)
32 {
33         return s ? strlen(s) : 0;
34 }
35
36
37 rchar *r_strstr(const rchar *haystack, const rchar *needle)
38 {
39         return strstr(haystack, needle);
40 }
41
42
43 rchar *r_strchr(const rchar *s, rint c)
44 {
45         return strchr(s, c);
46 }
47
48
49 rchar *r_strtrimr(rchar *s, const char *chrs)
50 {
51         int i;
52         for (i = r_strlen(s) - 1; i >= 0 && r_strchr(chrs, s[i]) != NULL; i--)
53                 s[i] = '\0';
54         return s;
55 }
56
57
58 rchar *r_strcpy(rchar *dest, const rchar *src)
59 {
60         return (rchar*) strcpy(dest, src);
61 }
62
63
64 rchar *r_strncpy(rchar *dest, const rchar *src, rsize_t n)
65 {
66         return (rchar*) strncpy(dest, src, n);
67 }
68
69
70 rchar *r_strdup(const rchar *s)
71 {
72         rsize_t size = r_strlen(s);
73         rchar *dupstr = (rchar*)r_zmalloc(size + 1);
74
75         if (dupstr) {
76                 r_strcpy(dupstr, s);
77         }
78         return dupstr;
79 }
80
81
82 rchar *r_strndup(const rchar *s, rsize_t size)
83 {
84         rchar *dupstr = (rchar*)r_zmalloc(size + 1);
85
86         if (dupstr) {
87                 r_strncpy(dupstr, s, size);
88         }
89         return dupstr;
90 }
91
92
93 rstr_t *r_rstrdup(const rchar *s, ruint size)
94 {
95         rsize_t allocsize = sizeof(rstr_t) + size + sizeof(rchar);
96         rstr_t *d = (rstr_t*)r_malloc(allocsize);
97         if (d) {
98                 r_memset(d, 0, allocsize);
99                 d->size = size;
100                 d->str = (rchar*)&d[1];
101                 if (s)
102                         r_memcpy((rchar*)d->str, s, size);
103         }
104         return d;
105 }
106
107
108 rint r_vsnprintf(rchar *str, ruint size, const rchar *format, va_list ap)
109 {
110         return vsnprintf(str, size, format, ap);
111 }
112
113
114 rchar *r_strcat(rchar *dest, const rchar *src)
115 {
116         return strcat(dest, src);
117 }
118
119
120 rchar *r_strncat(rchar *dest, const rchar *src, ruint n)
121 {
122         return strncat(dest, src, n);
123 }
124
125
126 rint r_snprintf(rchar *str, ruint size, const rchar *format, ...)
127 {
128         va_list ap;
129         int ret;
130
131         va_start(ap, format);
132         ret = r_vsnprintf(str, size, format, ap);
133         va_end(ap);
134         return ret;
135 }
136
137
138 rint r_printf(const rchar *format, ...)
139 {
140         va_list ap;
141         int ret;
142
143         va_start(ap, format);
144         ret = vfprintf(stdout, format, ap);
145         va_end(ap);
146         return ret;
147 }
148
149
150 rulong r_strtoul(const rchar *nptr, rchar **endptr, rint base)
151 {
152         return strtoul(nptr, endptr,base);
153 }
154
155
156 rlong r_strtol(const rchar *s, rchar **endptr, rint base)
157 {
158         return strtol(s, endptr, base);
159 }
160
161
162 rdouble r_strtod(const rchar *s, rchar **endptr)
163 {
164         return strtod(s, endptr);
165 }
166
167
168 robject_t *r_string_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy)
169 {
170         rstring_t *string = (rstring_t*)obj;
171         r_object_init(obj, type, cleanup, copy);
172         r_memset(&string->s, 0, sizeof(string->s));
173         return obj;
174 }
175
176
177 void r_string_cleanup(robject_t *obj)
178 {
179         rstring_t *string = (rstring_t*)obj;
180         if (string) {
181                 r_free(string->s.str);
182                 r_memset(&string->s, 0, sizeof(string->s));
183         }
184         r_object_cleanup(obj);
185 }
186
187
188 rstring_t *r_string_create()
189 {
190         rstring_t *string;
191         string = (rstring_t*)r_object_create(sizeof(*string));
192         r_string_init(&string->obj, R_OBJECT_STRING, r_string_cleanup, r_string_copy);
193         return string;
194
195 }
196
197
198 void r_string_assign(rstring_t *string, const rstr_t *str)
199 {
200         if (str && str->size) {
201                 r_free(string->s.str);
202                 string->s.str = (rchar*)r_malloc(str->size + 1);
203                 if (!string->s.str)
204                         return;
205                 r_memset(string->s.str, 0, str->size + 1);
206                 r_memcpy(string->s.str, str->str, str->size);
207                 string->s.size = str->size;
208         } else {
209                 /*
210                  * Create empty string
211                  */
212                 r_free(string->s.str);
213                 string->s.str = (rchar*)r_malloc(1);
214                 if (!string->s.str)
215                         return;
216                 r_memset(string->s.str, 0, 1);
217
218         }
219 }
220
221
222 void r_string_cat(rstring_t *string, const rstr_t *str)
223 {
224         if (str && str->size) {
225                 string->s.str = r_realloc(string->s.str, string->s.size + str->size + 1);
226                 r_memset(string->s.str + string->s.size, 0, str->size + 1);
227                 r_strncpy(string->s.str + string->s.size, str->str, str->size);
228                 string->s.size += str->size;
229         }
230 }
231
232
233 robject_t *r_string_copy(const robject_t *obj)
234 {
235         const rstring_t *srcString = (const rstring_t *)obj;
236         return (robject_t*)r_string_create_from_rstr(&srcString->s);
237 }
238
239
240 rstring_t *r_string_create_from_rstr(const rstr_t *str)
241 {
242         rstring_t *string = r_string_create();
243         if (string)
244                 r_string_assign(string, str);
245         return string;
246 }
247
248
249 rstring_t *r_string_create_from_ansistr(const rchar *str)
250 {
251         rstr_t rstr;
252
253         r_memset(&rstr, 0, sizeof(rstr));
254         if (str) {
255                 rstr.str = (rchar*)str;
256                 rstr.size = r_strlen(str);
257         }
258         return r_string_create_from_rstr(&rstr);
259 }
260
261
262
263
264 rstring_t *r_string_create_from_double(rdouble d)
265 {
266         char temp[128];
267         rint size;
268
269         r_memset(temp, 0, sizeof(temp));
270         size = r_snprintf(temp, sizeof(temp) - 1, "%f", d);
271         if (size > 0 && size < sizeof(temp)) {
272                 r_strtrimr(temp, ".0");
273                 return r_string_create_strsize(temp, r_strlen(temp));
274         }
275         return NULL;
276 }
277
278
279 rstring_t *r_string_create_from_long(rlong l)
280 {
281         char temp[128];
282         rint size;
283
284         r_memset(temp, 0, sizeof(temp));
285         size = r_snprintf(temp, sizeof(temp) - 1, "%ld", l);
286         if (size > 0 && size < sizeof(temp)) {
287                 return r_string_create_strsize(temp, size);
288         }
289         return NULL;
290 }
291
292
293 rstring_t *r_string_create_strsize(const rchar *str, ruint size)
294 {
295         rstr_t rstr;
296
297         r_memset(&rstr, 0, sizeof(rstr));
298         if (str) {
299                 rstr.str = (rchar*)str;
300                 rstr.size = size;
301         }
302         return r_string_create_from_rstr(&rstr);
303 }
304
305
306 const char *r_string_ansi(const rstring_t *str)
307 {
308         if (!str)
309                 return NULL;
310         return str->s.str;
311 }