Revert "More fixes for parsing dates in vcalendar on Windows."
[claws.git] / src / plugins / vcalendar / libical / libical / icalduration.c
1 /* -*- Mode: C -*-
2   ======================================================================
3   FILE: icaltime.c
4   CREATOR: eric 02 June 2000
5   
6   $Id$
7   $Locker$
8     
9  (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
10
11  This program is free software; you can redistribute it and/or modify
12  it under the terms of either: 
13
14     The LGPL as published by the Free Software Foundation, version
15     2.1, available at: http://www.fsf.org/copyleft/lesser.html
16
17   Or:
18
19     The Mozilla Public License Version 1.0. You may obtain a copy of
20     the License at http://www.mozilla.org/MPL/
21
22  The Original Code is eric. The Initial Developer of the Original
23  Code is Eric Busboom
24
25
26  ======================================================================*/
27
28 #ifdef HAVE_CONFIG_H
29 #include <config.h>
30 #endif
31
32 #include "icalduration.h"
33
34 #include <assert.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <stdio.h>
38
39 #ifdef ICAL_NO_LIBICAL
40 #define icalerror_set_errno(x)
41 #define  icalerror_check_arg_rv(x,y)
42 #define  icalerror_check_arg_re(x,y,z)
43 #else
44 #include "icalerror.h"
45 #include "icalmemory.h"
46 #endif
47
48
49
50
51 /* From Seth Alves,  <alves@hungry.com>   */
52 struct icaldurationtype icaldurationtype_from_int(int t)
53 {
54         struct icaldurationtype dur;
55         int used = 0;
56
57         dur = icaldurationtype_null_duration();
58
59         if(t < 0){
60             dur.is_neg = 1;
61             t = -t;
62         }
63
64         dur.weeks = (t - used) / (60 * 60 * 24 * 7);
65         used += dur.weeks * (60 * 60 * 24 * 7);
66         dur.days = (t - used) / (60 * 60 * 24);
67         used += dur.days * (60 * 60 * 24);
68         dur.hours = (t - used) / (60 * 60);
69         used += dur.hours * (60 * 60);
70         dur.minutes = (t - used) / (60);
71         used += dur.minutes * (60);
72         dur.seconds = (t - used);
73  
74         return dur;
75 }
76
77 #ifndef ICAL_NO_LIBICAL
78 #include "icalvalue.h"
79 struct icaldurationtype icaldurationtype_from_string(const char* str)
80 {
81
82     int i;
83     int begin_flag = 0;
84     int time_flag = 0;
85     int date_flag = 0;
86     int week_flag = 0;
87     int digits=-1;
88     int scan_size = -1;
89     int size = strlen(str);
90     char p;
91     struct icaldurationtype d;
92
93     memset(&d, 0, sizeof(struct icaldurationtype));
94
95     for(i=0;i != size;i++){
96         p = str[i];
97         
98         switch(p) 
99             {
100             case '-': {
101                 if(i != 0 || begin_flag == 1) goto error;
102
103                 d.is_neg = 1;
104                 break;
105             }
106
107             case 'P': {
108                 if (i != 0 && i !=1 ) goto error;
109                 begin_flag = 1;
110                 break;
111             }
112
113             case 'T': {
114                 time_flag = 1;
115                 break;
116             }
117
118             case '0':
119             case '1':
120             case '2':
121             case '3':
122             case '4':
123             case '5':
124             case '6':
125             case '7':
126             case '8':
127             case '9':
128                 { 
129                     
130                     /* HACK. Skip any more digits if the l;ast one
131                        read has not been assigned */
132                     if(digits != -1){
133                         break;
134                     }
135
136                     if (begin_flag == 0) goto error;
137                     /* Get all of the digits, not one at a time */
138                     scan_size = sscanf((char*)(str+i),"%d",&digits);
139                     if(scan_size == 0) goto error;
140                     break;
141                 }
142
143             case 'H': { 
144                 if (time_flag == 0||week_flag == 1||d.hours !=0||digits ==-1) 
145                     goto error;
146                 d.hours = digits; digits = -1;
147                 break;
148             }
149             case 'M': {
150                 if (time_flag == 0||week_flag==1||d.minutes != 0||digits ==-1) 
151                     goto error;
152                 d.minutes = digits; digits = -1;            
153                 break;
154             }
155             case 'S': {
156                 if (time_flag == 0||week_flag==1||d.seconds!=0||digits ==-1) 
157                     goto error;
158                 d.seconds = digits; digits = -1;            
159                 break;
160             }
161             case 'W': {
162                 if (time_flag==1||date_flag==1||d.weeks!=0||digits ==-1) 
163                     goto error;
164                 week_flag = 1;  
165                 d.weeks = digits; digits = -1;      
166                 break;
167             }
168             case 'D': {
169                 if (time_flag==1||week_flag==1||d.days!=0||digits ==-1) 
170                     goto error;
171                 date_flag = 1;
172                 d.days = digits; digits = -1;       
173                 break;
174             }
175             default: {
176                 goto error;
177             }
178
179             }
180     }
181
182     return d;
183         
184
185  error:
186     icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
187     memset(&d, 0, sizeof(struct icaldurationtype));
188     return d;
189
190 }
191
192 #define TMP_BUF_SIZE 1024
193 void append_duration_segment(char** buf, char** buf_ptr, size_t* buf_size, 
194                              char* sep, unsigned int value) {
195
196     char temp[TMP_BUF_SIZE];
197
198     sprintf(temp,"%d",value);
199
200     icalmemory_append_string(buf, buf_ptr, buf_size, temp);
201     icalmemory_append_string(buf, buf_ptr, buf_size, sep);
202     
203 }
204
205 char* icaldurationtype_as_ical_string(struct icaldurationtype d) 
206 {
207
208     char *buf, *output_line;
209     size_t buf_size = 256;
210     char* buf_ptr = 0;
211     int seconds;
212
213     buf = (char*)icalmemory_new_buffer(buf_size);
214     buf_ptr = buf;
215     
216
217     seconds = icaldurationtype_as_int(d);
218
219     if(seconds !=0){
220         
221         if(d.is_neg == 1){
222             icalmemory_append_char(&buf, &buf_ptr, &buf_size, '-'); 
223         }
224
225         icalmemory_append_char(&buf, &buf_ptr, &buf_size, 'P');
226     
227         if (d.weeks != 0 ) {
228             append_duration_segment(&buf, &buf_ptr, &buf_size, "W", d.weeks);
229         }
230         
231         if (d.days != 0 ) {
232             append_duration_segment(&buf, &buf_ptr, &buf_size, "D", d.days);
233         }
234         
235         if (d.hours != 0 || d.minutes != 0 || d.seconds != 0) {
236             
237             icalmemory_append_string(&buf, &buf_ptr, &buf_size, "T");
238             
239             if (d.hours != 0 ) {
240                 append_duration_segment(&buf, &buf_ptr, &buf_size, "H", d.hours);
241             }
242             if (d.minutes != 0 ) {
243                 append_duration_segment(&buf, &buf_ptr, &buf_size, "M", 
244                                         d.minutes);
245             }
246             if (d.seconds != 0 ) {
247                 append_duration_segment(&buf, &buf_ptr, &buf_size, "S", 
248                                         d.seconds);
249             }
250             
251         }
252     } else {
253         icalmemory_append_string(&buf, &buf_ptr, &buf_size, "PTS0");
254     }
255  
256     output_line = icalmemory_tmp_copy(buf);
257     icalmemory_free_buffer(buf);
258
259     return output_line;
260     
261 }
262
263 #endif
264
265
266 /* From Russel Steinthal */
267 int icaldurationtype_as_int(struct icaldurationtype dur)
268 {
269     return (int)( (dur.seconds +
270                    (60 * dur.minutes) +
271                    (60 * 60 * dur.hours) +
272                    (60 * 60 * 24 * dur.days) +
273                    (60 * 60 * 24 * 7 * dur.weeks))
274                   * (dur.is_neg==1? -1 : 1) ) ;
275
276
277 struct icaldurationtype icaldurationtype_null_duration()
278 {
279     struct icaldurationtype d;
280     
281     memset(&d,0,sizeof(struct icaldurationtype));
282     
283     return d;
284 }
285
286 int icaldurationtype_is_null_duration(struct icaldurationtype d)
287 {
288     if(icaldurationtype_as_int(d) == 0){
289         return 1;
290     } else {
291         return 0;
292     }
293 }
294
295
296
297 struct icaltimetype  icaltime_add(struct icaltimetype t,
298                                   struct icaldurationtype  d)
299 {
300     int dt = icaldurationtype_as_int(d);
301     
302     t.second += dt;
303     
304     t = icaltime_normalize(t);
305     
306     return t;
307 }
308
309 struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
310                                            struct icaltimetype t2)
311 {
312
313     time_t t1t = icaltime_as_timet(t1);
314     time_t t2t = icaltime_as_timet(t2);
315
316     return icaldurationtype_from_int(t1t-t2t);
317
318
319 }
320