RPA Toolkit
104dd2077fb16cf8192677472505c047a1a9cc5b
[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                 r_memcpy((rchar*)d->str, s, size);
102         }
103         return d;
104 }
105
106
107 rint r_vsnprintf(rchar *str, ruint size, const rchar *format, va_list ap)
108 {
109         return vsnprintf(str, size, format, ap);
110 }
111
112
113 rchar *r_strcat(rchar *dest, const rchar *src)
114 {
115         return strcat(dest, src);
116 }
117
118
119 rchar *r_strncat(rchar *dest, const rchar *src, ruint n)
120 {
121         return strncat(dest, src, n);
122 }
123
124
125 rint r_snprintf(rchar *str, ruint size, const rchar *format, ...)
126 {
127         va_list ap;
128         int ret;
129
130         va_start(ap, format);
131         ret = r_vsnprintf(str, size, format, ap);
132         va_end(ap);
133         return ret;
134 }
135
136
137 rint r_printf(const rchar *format, ...)
138 {
139         va_list ap;
140         int ret;
141
142         va_start(ap, format);
143         ret = vfprintf(stdout, format, ap);
144         va_end(ap);
145         return ret;
146 }
147
148
149 rulong r_strtoul(const rchar *nptr, rchar **endptr, rint base)
150 {
151         return strtoul(nptr, endptr,base);
152 }
153
154
155 rlong r_strtol(const rchar *s, rchar **endptr, rint base)
156 {
157         return strtol(s, endptr, base);
158 }
159
160
161 rdouble r_strtod(const rchar *s, rchar **endptr)
162 {
163         return strtod(s, endptr);
164 }
165
166
167 robject_t *r_string_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy)
168 {
169         rstring_t *string = (rstring_t*)obj;
170         r_object_init(obj, type, cleanup, copy);
171         r_memset(&string->s, 0, sizeof(string->s));
172         return obj;
173 }
174
175
176 void r_string_cleanup(robject_t *obj)
177 {
178         rstring_t *string = (rstring_t*)obj;
179         if (string) {
180                 r_free(string->s.str);
181                 r_memset(&string->s, 0, sizeof(string->s));
182         }
183         r_object_cleanup(obj);
184 }
185
186
187 rstring_t *r_string_create()
188 {
189         rstring_t *string;
190         string = (rstring_t*)r_object_create(sizeof(*string));
191         r_string_init(&string->obj, R_OBJECT_STRING, r_string_cleanup, r_string_copy);
192         return string;
193
194 }
195
196
197 void r_string_assign(rstring_t *string, const rstr_t *str)
198 {
199         if (str && str->size) {
200                 r_free(string->s.str);
201                 string->s.str = (rchar*)r_malloc(str->size + 1);
202                 if (!string->s.str)
203                         return;
204                 r_memset(string->s.str, 0, str->size + 1);
205                 r_memcpy(string->s.str, str->str, str->size);
206                 string->s.size = str->size;
207         } else {
208                 /*
209                  * Create empty string
210                  */
211                 r_free(string->s.str);
212                 string->s.str = (rchar*)r_malloc(1);
213                 if (!string->s.str)
214                         return;
215                 r_memset(string->s.str, 0, 1);
216
217         }
218 }
219
220
221 void r_string_cat(rstring_t *string, const rstr_t *str)
222 {
223         if (str && str->size) {
224                 string->s.str = r_realloc(string->s.str, string->s.size + str->size + 1);
225                 r_memset(string->s.str + string->s.size, 0, str->size + 1);
226                 r_strncpy(string->s.str + string->s.size, str->str, str->size);
227                 string->s.size += str->size;
228         }
229 }
230
231
232 robject_t *r_string_copy(const robject_t *obj)
233 {
234         const rstring_t *srcString = (const rstring_t *)obj;
235         return (robject_t*)r_string_create_from_rstr(&srcString->s);
236 }
237
238
239 rstring_t *r_string_create_from_rstr(const rstr_t *str)
240 {
241         rstring_t *string = r_string_create();
242         if (string)
243                 r_string_assign(string, str);
244         return string;
245 }
246
247
248 rstring_t *r_string_create_from_ansistr(const rchar *str)
249 {
250         rstr_t rstr;
251
252         r_memset(&rstr, 0, sizeof(rstr));
253         if (str) {
254                 rstr.str = (rchar*)str;
255                 rstr.size = r_strlen(str);
256         }
257         return r_string_create_from_rstr(&rstr);
258 }
259
260
261
262
263 rstring_t *r_string_create_from_double(rdouble d)
264 {
265         char temp[128];
266         rint size;
267
268         r_memset(temp, 0, sizeof(temp));
269         size = r_snprintf(temp, sizeof(temp) - 1, "%f", d);
270         if (size > 0 && size < sizeof(temp)) {
271                 r_strtrimr(temp, ".0");
272                 return r_string_create_strsize(temp, r_strlen(temp));
273         }
274         return NULL;
275 }
276
277
278 rstring_t *r_string_create_from_long(rlong l)
279 {
280         char temp[128];
281         rint size;
282
283         r_memset(temp, 0, sizeof(temp));
284         size = r_snprintf(temp, sizeof(temp) - 1, "%ld", l);
285         if (size > 0 && size < sizeof(temp)) {
286                 return r_string_create_strsize(temp, size);
287         }
288         return NULL;
289 }
290
291
292 rstring_t *r_string_create_strsize(const rchar *str, ruint size)
293 {
294         rstr_t rstr;
295
296         r_memset(&rstr, 0, sizeof(rstr));
297         if (str) {
298                 rstr.str = (rchar*)str;
299                 rstr.size = size;
300         }
301         return r_string_create_from_rstr(&rstr);
302 }
303
304
305 const char *r_string_ansi(const rstring_t *str)
306 {
307         if (!str)
308                 return NULL;
309         return str->s.str;
310 }