Diffstat (limited to 'libical/src/libical/icalparameter.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libical/src/libical/icalparameter.c | 382 |
1 files changed, 382 insertions, 0 deletions
diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c new file mode 100644 index 0000000..156ecdb --- a/dev/null +++ b/libical/src/libical/icalparameter.c | |||
@@ -0,0 +1,382 @@ | |||
1 | /* -*- Mode: C -*- | ||
2 | ====================================================================== | ||
3 | FILE: icalderivedparameters.{c,h} | ||
4 | CREATOR: eric 09 May 1999 | ||
5 | |||
6 | $Id$ | ||
7 | $Locker$ | ||
8 | |||
9 | |||
10 | (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org | ||
11 | |||
12 | This program is free software; you can redistribute it and/or modify | ||
13 | it under the terms of either: | ||
14 | |||
15 | The LGPL as published by the Free Software Foundation, version | ||
16 | 2.1, available at: http://www.fsf.org/copyleft/lesser.html | ||
17 | |||
18 | Or: | ||
19 | |||
20 | The Mozilla Public License Version 1.0. You may obtain a copy of | ||
21 | the License at http://www.mozilla.org/MPL/ | ||
22 | |||
23 | The original code is icalderivedparameters.{c,h} | ||
24 | |||
25 | Contributions from: | ||
26 | Graham Davison (g.m.davison@computer.org) | ||
27 | |||
28 | ======================================================================*/ | ||
29 | /*#line 29 "icalparameter.c.in"*/ | ||
30 | #ifdef HAVE_CONFIG_H | ||
31 | #include <config.h> | ||
32 | #endif | ||
33 | |||
34 | |||
35 | #include "icalparameter.h" | ||
36 | #include "icalproperty.h" | ||
37 | #include "icalerror.h" | ||
38 | #include "icalmemory.h" | ||
39 | #include "icalparameterimpl.h" | ||
40 | |||
41 | #include <stdlib.h> /* for malloc() */ | ||
42 | #include <errno.h> | ||
43 | #include <string.h> /* for memset() */ | ||
44 | |||
45 | /* In icalderivedparameter */ | ||
46 | icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const char* val); | ||
47 | |||
48 | |||
49 | struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind) | ||
50 | { | ||
51 | struct icalparameter_impl* v; | ||
52 | |||
53 | if ( ( v = (struct icalparameter_impl*) | ||
54 | malloc(sizeof(struct icalparameter_impl))) == 0) { | ||
55 | icalerror_set_errno(ICAL_NEWFAILED_ERROR); | ||
56 | return 0; | ||
57 | } | ||
58 | |||
59 | strcpy(v->id,"para"); | ||
60 | |||
61 | v->kind = kind; | ||
62 | v->size = 0; | ||
63 | v->string = 0; | ||
64 | v->x_name = 0; | ||
65 | v->parent = 0; | ||
66 | v->data = 0; | ||
67 | |||
68 | return v; | ||
69 | } | ||
70 | |||
71 | icalparameter* | ||
72 | icalparameter_new (icalparameter_kind kind) | ||
73 | { | ||
74 | struct icalparameter_impl* v = icalparameter_new_impl(kind); | ||
75 | |||
76 | return (icalparameter*) v; | ||
77 | |||
78 | } | ||
79 | |||
80 | void | ||
81 | icalparameter_free (icalparameter* parameter) | ||
82 | { | ||
83 | struct icalparameter_impl * impl; | ||
84 | |||
85 | impl = (struct icalparameter_impl*)parameter; | ||
86 | |||
87 | /* HACK. This always triggers, even when parameter is non-zero | ||
88 | icalerror_check_arg_rv((parameter==0),"parameter");*/ | ||
89 | |||
90 | |||
91 | #ifdef ICAL_FREE_ON_LIST_IS_ERROR | ||
92 | icalerror_assert( (impl->parent ==0),"Tried to free a parameter that is still attached to a component. "); | ||
93 | |||
94 | #else | ||
95 | if(impl->parent !=0){ | ||
96 | return; | ||
97 | } | ||
98 | #endif | ||
99 | |||
100 | |||
101 | if (impl->string != 0){ | ||
102 | free ((void*)impl->string); | ||
103 | } | ||
104 | |||
105 | if (impl->x_name != 0){ | ||
106 | free ((void*)impl->x_name); | ||
107 | } | ||
108 | |||
109 | memset(impl,0,sizeof(impl)); | ||
110 | |||
111 | impl->parent = 0; | ||
112 | impl->id[0] = 'X'; | ||
113 | free(impl); | ||
114 | } | ||
115 | |||
116 | |||
117 | |||
118 | icalparameter* | ||
119 | icalparameter_new_clone(icalparameter* param) | ||
120 | { | ||
121 | struct icalparameter_impl *old; | ||
122 | struct icalparameter_impl *new; | ||
123 | |||
124 | old = (struct icalparameter_impl *)param; | ||
125 | new = icalparameter_new_impl(old->kind); | ||
126 | |||
127 | icalerror_check_arg_rz((param!=0),"param"); | ||
128 | |||
129 | if (new == 0){ | ||
130 | return 0; | ||
131 | } | ||
132 | |||
133 | memcpy(new,old,sizeof(struct icalparameter_impl)); | ||
134 | |||
135 | if (old->string != 0){ | ||
136 | new->string = icalmemory_strdup(old->string); | ||
137 | if (new->string == 0){ | ||
138 | icalparameter_free(new); | ||
139 | return 0; | ||
140 | } | ||
141 | } | ||
142 | |||
143 | if (old->x_name != 0){ | ||
144 | new->x_name = icalmemory_strdup(old->x_name); | ||
145 | if (new->x_name == 0){ | ||
146 | icalparameter_free(new); | ||
147 | return 0; | ||
148 | } | ||
149 | } | ||
150 | |||
151 | return new; | ||
152 | } | ||
153 | |||
154 | icalparameter* icalparameter_new_from_string(const char *str) | ||
155 | { | ||
156 | char* eq; | ||
157 | char* cpy; | ||
158 | icalparameter_kind kind; | ||
159 | icalparameter *param; | ||
160 | |||
161 | icalerror_check_arg_rz(str != 0,"str"); | ||
162 | |||
163 | cpy = icalmemory_strdup(str); | ||
164 | |||
165 | if (cpy == 0){ | ||
166 | icalerror_set_errno(ICAL_NEWFAILED_ERROR); | ||
167 | return 0; | ||
168 | } | ||
169 | |||
170 | eq = strchr(cpy,'='); | ||
171 | |||
172 | if(eq == 0){ | ||
173 | icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); | ||
174 | return 0; | ||
175 | } | ||
176 | |||
177 | *eq = '\0'; | ||
178 | |||
179 | eq++; | ||
180 | |||
181 | kind = icalparameter_string_to_kind(cpy); | ||
182 | |||
183 | if(kind == ICAL_NO_PARAMETER){ | ||
184 | icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); | ||
185 | return 0; | ||
186 | } | ||
187 | |||
188 | param = icalparameter_new_from_value_string(kind,eq); | ||
189 | |||
190 | if(kind == ICAL_X_PARAMETER){ | ||
191 | icalparameter_set_xname(param,cpy); | ||
192 | } | ||
193 | |||
194 | free(cpy); | ||
195 | |||
196 | return param; | ||
197 | |||
198 | } | ||
199 | |||
200 | char* | ||
201 | icalparameter_as_ical_string (icalparameter* parameter) | ||
202 | { | ||
203 | struct icalparameter_impl* impl; | ||
204 | size_t buf_size = 1024; | ||
205 | char* buf; | ||
206 | char* buf_ptr; | ||
207 | char *out_buf; | ||
208 | const char *kind_string; | ||
209 | |||
210 | icalerror_check_arg_rz( (parameter!=0), "parameter"); | ||
211 | |||
212 | /* Create new buffer that we can append names, parameters and a | ||
213 | value to, and reallocate as needed. Later, this buffer will be | ||
214 | copied to a icalmemory_tmp_buffer, which is managed internally | ||
215 | by libical, so it can be given to the caller without fear of | ||
216 | the caller forgetting to free it */ | ||
217 | |||
218 | buf = icalmemory_new_buffer(buf_size); | ||
219 | buf_ptr = buf; | ||
220 | impl = (struct icalparameter_impl*)parameter; | ||
221 | |||
222 | if(impl->kind == ICAL_X_PARAMETER) { | ||
223 | |||
224 | icalmemory_append_string(&buf, &buf_ptr, &buf_size, | ||
225 | icalparameter_get_xname(impl)); | ||
226 | |||
227 | } else { | ||
228 | |||
229 | kind_string = icalparameter_kind_to_string(impl->kind); | ||
230 | |||
231 | if (impl->kind == ICAL_NO_PARAMETER || | ||
232 | impl->kind == ICAL_ANY_PARAMETER || | ||
233 | kind_string == 0) | ||
234 | { | ||
235 | icalerror_set_errno(ICAL_BADARG_ERROR); | ||
236 | return 0; | ||
237 | } | ||
238 | |||
239 | |||
240 | /* Put the parameter name into the string */ | ||
241 | icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string); | ||
242 | |||
243 | } | ||
244 | |||
245 | icalmemory_append_string(&buf, &buf_ptr, &buf_size, "="); | ||
246 | |||
247 | if(impl->string !=0){ | ||
248 | icalmemory_append_string(&buf, &buf_ptr, &buf_size, impl->string); | ||
249 | } else if (impl->data != 0){ | ||
250 | const char* str = icalparameter_enum_to_string(impl->data); | ||
251 | icalmemory_append_string(&buf, &buf_ptr, &buf_size, str); | ||
252 | } else { | ||
253 | icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR); | ||
254 | return 0; | ||
255 | } | ||
256 | |||
257 | /* Now, copy the buffer to a tmp_buffer, which is safe to give to | ||
258 | the caller without worring about de-allocating it. */ | ||
259 | |||
260 | out_buf = icalmemory_tmp_buffer(strlen(buf)); | ||
261 | strcpy(out_buf, buf); | ||
262 | |||
263 | icalmemory_free_buffer(buf); | ||
264 | |||
265 | return out_buf; | ||
266 | |||
267 | } | ||
268 | |||
269 | |||
270 | int | ||
271 | icalparameter_is_valid (icalparameter* parameter); | ||
272 | |||
273 | |||
274 | icalparameter_kind | ||
275 | icalparameter_isa (icalparameter* parameter) | ||
276 | { | ||
277 | if(parameter == 0){ | ||
278 | return ICAL_NO_PARAMETER; | ||
279 | } | ||
280 | |||
281 | return ((struct icalparameter_impl *)parameter)->kind; | ||
282 | } | ||
283 | |||
284 | |||
285 | int | ||
286 | icalparameter_isa_parameter (void* parameter) | ||
287 | { | ||
288 | struct icalparameter_impl *impl = (struct icalparameter_impl *)parameter; | ||
289 | |||
290 | if (parameter == 0){ | ||
291 | return 0; | ||
292 | } | ||
293 | |||
294 | if (strcmp(impl->id,"para") == 0) { | ||
295 | return 1; | ||
296 | } else { | ||
297 | return 0; | ||
298 | } | ||
299 | } | ||
300 | |||
301 | |||
302 | void | ||
303 | icalparameter_set_xname (icalparameter* param, const char* v) | ||
304 | { | ||
305 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
306 | icalerror_check_arg_rv( (param!=0),"param"); | ||
307 | icalerror_check_arg_rv( (v!=0),"v"); | ||
308 | |||
309 | if (impl->x_name != 0){ | ||
310 | free((void*)impl->x_name); | ||
311 | } | ||
312 | |||
313 | impl->x_name = icalmemory_strdup(v); | ||
314 | |||
315 | if (impl->x_name == 0){ | ||
316 | errno = ENOMEM; | ||
317 | } | ||
318 | |||
319 | } | ||
320 | |||
321 | const char* | ||
322 | icalparameter_get_xname (icalparameter* param) | ||
323 | { | ||
324 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
325 | icalerror_check_arg_rz( (param!=0),"param"); | ||
326 | |||
327 | return impl->x_name; | ||
328 | } | ||
329 | |||
330 | void | ||
331 | icalparameter_set_xvalue (icalparameter* param, const char* v) | ||
332 | { | ||
333 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
334 | |||
335 | icalerror_check_arg_rv( (param!=0),"param"); | ||
336 | icalerror_check_arg_rv( (v!=0),"v"); | ||
337 | |||
338 | if (impl->string != 0){ | ||
339 | free((void*)impl->string); | ||
340 | } | ||
341 | |||
342 | impl->string = icalmemory_strdup(v); | ||
343 | |||
344 | if (impl->string == 0){ | ||
345 | errno = ENOMEM; | ||
346 | } | ||
347 | |||
348 | } | ||
349 | |||
350 | const char* | ||
351 | icalparameter_get_xvalue (icalparameter* param) | ||
352 | { | ||
353 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
354 | |||
355 | icalerror_check_arg_rz( (param!=0),"param"); | ||
356 | |||
357 | return impl->string; | ||
358 | |||
359 | } | ||
360 | |||
361 | void icalparameter_set_parent(icalparameter* param, | ||
362 | icalproperty* property) | ||
363 | { | ||
364 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
365 | |||
366 | icalerror_check_arg_rv( (param!=0),"param"); | ||
367 | |||
368 | impl->parent = property; | ||
369 | } | ||
370 | |||
371 | icalproperty* icalparameter_get_parent(icalparameter* param) | ||
372 | { | ||
373 | struct icalparameter_impl *impl = (struct icalparameter_impl*)param; | ||
374 | |||
375 | icalerror_check_arg_rz( (param!=0),"param"); | ||
376 | |||
377 | return impl->parent; | ||
378 | } | ||
379 | |||
380 | |||
381 | /* Everything below this line is machine generated. Do not edit. */ | ||
382 | /* ALTREP */ | ||