summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/chaos_calendar/README9
-rw-r--r--lib/chaos_calendar/chaos_calendar.c76
-rw-r--r--lib/chaos_calendar/chaos_calendar.gemspec44
-rw-r--r--lib/chaos_calendar/chaos_calendar.i6
-rw-r--r--lib/chaos_calendar/chaos_calendar_wrap.c1928
-rw-r--r--lib/chaos_calendar/extconf.rb3
-rwxr-xr-xlib/chaos_calendar/gen.sh6
-rw-r--r--lib/chaos_calendar/ical_occurrences.c76
-rw-r--r--lib/chaos_calendar/ical_occurrences.i6
9 files changed, 0 insertions, 2154 deletions
diff --git a/lib/chaos_calendar/README b/lib/chaos_calendar/README
deleted file mode 100644
index 9d99930..0000000
--- a/lib/chaos_calendar/README
+++ /dev/null
@@ -1,9 +0,0 @@
1install libical (/usr/ports/devel/libical)
2run gen.sh in this directory
3find chaos_calendar ruby extension in ./
4
5irb
6>> require 'chaos_calendar'
7occ_array = Chaos_calendar::occurrences( "20000101T230000", "20091231T230000", "FREQ=DAILY;COUNT=1200" )
8
9Be aware that the array is in UTC and will be converted to your local timezone before it is used.
diff --git a/lib/chaos_calendar/chaos_calendar.c b/lib/chaos_calendar/chaos_calendar.c
deleted file mode 100644
index e59c1ed..0000000
--- a/lib/chaos_calendar/chaos_calendar.c
+++ /dev/null
@@ -1,76 +0,0 @@
1#include <ruby.h>
2#include <ical.h>
3#include <time.h>
4
5//#define RRULE "FREQ=MONTHLY;BYMONTH=1,2,3,4,5,6,7,8,9,10,11;BYDAY=-1WE;UNTIL=20091105T220000"
6//#define RRULE "FREQ=DAILY;UNTIL=20991111T220000;VFOO"
7
8VALUE occurrences( VALUE dtstart, VALUE dtend, char *rrule ) {
9 struct icaltimetype start, end;
10 time_t tt;
11 VALUE tv_sec, occurr = rb_ary_new();
12
13 /* Get method ID for Time.tv_sec */
14 ID time_tv_sec = rb_intern( "tv_sec" );
15 ID time_to_time = rb_intern( "to_time" );
16
17 if( !rb_respond_to( dtstart, time_tv_sec ) ) {
18 if( rb_respond_to( dtstart, time_to_time ) )
19 dtstart = rb_funcall( dtstart, time_to_time, 0 );
20 else
21 rb_raise( rb_eTypeError, "Can't convert dtstart into a Time-like object." );
22 }
23
24 if( !rb_respond_to( dtend, time_tv_sec ) ) {
25 if( rb_respond_to( dtend, time_to_time ) )
26 dtend = rb_funcall( dtend, time_to_time, 0 );
27 else
28 rb_raise( rb_eTypeError, "Can't convert dtend into a Time-like object." );
29 }
30
31 /* Apply .tv_sec to our Time objects (if they are Times ...) */
32 tv_sec = rb_funcall( dtstart, time_tv_sec, 0 );
33 tt = NUM2INT( tv_sec );
34 start = icaltime_from_timet( tt, 0 );
35
36 tv_sec = rb_funcall( dtend, time_tv_sec, 0 );
37 tt = NUM2INT( tv_sec );
38 end = icaltime_from_timet( tt, 0 );
39
40 icalerror_clear_errno();
41 icalerror_set_error_state( ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL);
42
43 struct icalrecurrencetype recur = icalrecurrencetype_from_string( rrule );
44 if( icalerrno != ICAL_NO_ERROR ) {
45 rb_raise(rb_eArgError, "Malformed RRule");
46 return Qnil;
47 }
48
49 icalrecur_iterator* ritr = icalrecur_iterator_new( recur, start );
50
51 while(1) {
52 struct icaltimetype next = icalrecur_iterator_next(ritr);
53
54 if( icaltime_is_null_time(next) || ( icaltime_compare( next, end ) > 0 ) ) {
55 icalrecur_iterator_free(ritr);
56 return occurr;
57 }
58
59 rb_ary_push( occurr, rb_time_new( icaltime_as_timet( next ), 0 ) );
60 };
61
62 icalrecur_iterator_free(ritr);
63 return occurr;
64}
65
66VALUE duration_to_fixnum( char * duration ) {
67 icalerror_clear_errno();
68 icalerror_set_error_state( ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL);
69
70 struct icaldurationtype dur_struct = icaldurationtype_from_string( duration );
71
72 if( icaldurationtype_is_bad_duration( dur_struct ) )
73 rb_raise(rb_eArgError, "Malformed Duration");
74
75 return LONG2FIX(icaldurationtype_as_int( dur_struct ));
76}
diff --git a/lib/chaos_calendar/chaos_calendar.gemspec b/lib/chaos_calendar/chaos_calendar.gemspec
deleted file mode 100644
index 424d54f..0000000
--- a/lib/chaos_calendar/chaos_calendar.gemspec
+++ /dev/null
@@ -1,44 +0,0 @@
1--- !ruby/object:Gem::Specification
2name: chaos_calendar
3version: !ruby/object:Gem::Version
4 version: "0.1"
5platform: ruby
6authors: [erdgeist]
7
8autorequire: libical
9bindir:
10cert_chain:
11date: 2009-04-09 00:00:00 +02:00
12default_executable:
13dependencies:
14description:
15email: erdgeist@erdgeist.org
16executables: []
17
18extensions:
19- extconf.rb
20extra_rdoc_files:
21files:
22- extconf.rb
23- chaos_calendar.c
24- chaos_calendar_wrap.c
25has_rdoc: false
26homepage: http://www.ccc.de/
27post_install_message:
28rdoc_options:
29require_paths:
30- lib
31required_ruby_version: !ruby/object:Gem::Requirement
32 requirements:
33 - - ">"
34 - !ruby/object:Gem::Version
35 version: 0.0.0
36 version:
37required_rubygems_version:
38requirements:
39rubyforge_project:
40rubygems_version: 1.3.1
41signing_key:
42specification_version: 2
43summary: This gem provides a wrapper for two calls of libical
44test_files:
diff --git a/lib/chaos_calendar/chaos_calendar.i b/lib/chaos_calendar/chaos_calendar.i
deleted file mode 100644
index 88c35e1..0000000
--- a/lib/chaos_calendar/chaos_calendar.i
+++ /dev/null
@@ -1,6 +0,0 @@
1%module chaos_calendar
2
3%inline {
4 VALUE occurrences( VALUE dtstart, VALUE dtend, char * rrule );
5 VALUE duration_to_fixnum( char * duration );
6}
diff --git a/lib/chaos_calendar/chaos_calendar_wrap.c b/lib/chaos_calendar/chaos_calendar_wrap.c
deleted file mode 100644
index 434f53c..0000000
--- a/lib/chaos_calendar/chaos_calendar_wrap.c
+++ /dev/null
@@ -1,1928 +0,0 @@
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.31
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11#define SWIGRUBY
12/* -----------------------------------------------------------------------------
13 * This section contains generic SWIG labels for method/variable
14 * declarations/attributes, and other compiler dependent labels.
15 * ----------------------------------------------------------------------------- */
16
17/* template workaround for compilers that cannot correctly implement the C++ standard */
18#ifndef SWIGTEMPLATEDISAMBIGUATOR
19# if defined(__SUNPRO_CC)
20# if (__SUNPRO_CC <= 0x560)
21# define SWIGTEMPLATEDISAMBIGUATOR template
22# else
23# define SWIGTEMPLATEDISAMBIGUATOR
24# endif
25# else
26# define SWIGTEMPLATEDISAMBIGUATOR
27# endif
28#endif
29
30/* inline attribute */
31#ifndef SWIGINLINE
32# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
33# define SWIGINLINE inline
34# else
35# define SWIGINLINE
36# endif
37#endif
38
39/* attribute recognised by some compilers to avoid 'unused' warnings */
40#ifndef SWIGUNUSED
41# if defined(__GNUC__)
42# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
43# define SWIGUNUSED __attribute__ ((__unused__))
44# else
45# define SWIGUNUSED
46# endif
47# elif defined(__ICC)
48# define SWIGUNUSED __attribute__ ((__unused__))
49# else
50# define SWIGUNUSED
51# endif
52#endif
53
54#ifndef SWIGUNUSEDPARM
55# ifdef __cplusplus
56# define SWIGUNUSEDPARM(p)
57# else
58# define SWIGUNUSEDPARM(p) p SWIGUNUSED
59# endif
60#endif
61
62/* internal SWIG method */
63#ifndef SWIGINTERN
64# define SWIGINTERN static SWIGUNUSED
65#endif
66
67/* internal inline SWIG method */
68#ifndef SWIGINTERNINLINE
69# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
70#endif
71
72/* exporting methods */
73#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
74# ifndef GCC_HASCLASSVISIBILITY
75# define GCC_HASCLASSVISIBILITY
76# endif
77#endif
78
79#ifndef SWIGEXPORT
80# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
81# if defined(STATIC_LINKED)
82# define SWIGEXPORT
83# else
84# define SWIGEXPORT __declspec(dllexport)
85# endif
86# else
87# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
88# define SWIGEXPORT __attribute__ ((visibility("default")))
89# else
90# define SWIGEXPORT
91# endif
92# endif
93#endif
94
95/* calling conventions for Windows */
96#ifndef SWIGSTDCALL
97# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
98# define SWIGSTDCALL __stdcall
99# else
100# define SWIGSTDCALL
101# endif
102#endif
103
104/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
105#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
106# define _CRT_SECURE_NO_DEPRECATE
107#endif
108
109/* -----------------------------------------------------------------------------
110 * This section contains generic SWIG labels for method/variable
111 * declarations/attributes, and other compiler dependent labels.
112 * ----------------------------------------------------------------------------- */
113
114/* template workaround for compilers that cannot correctly implement the C++ standard */
115#ifndef SWIGTEMPLATEDISAMBIGUATOR
116# if defined(__SUNPRO_CC)
117# if (__SUNPRO_CC <= 0x560)
118# define SWIGTEMPLATEDISAMBIGUATOR template
119# else
120# define SWIGTEMPLATEDISAMBIGUATOR
121# endif
122# else
123# define SWIGTEMPLATEDISAMBIGUATOR
124# endif
125#endif
126
127/* inline attribute */
128#ifndef SWIGINLINE
129# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
130# define SWIGINLINE inline
131# else
132# define SWIGINLINE
133# endif
134#endif
135
136/* attribute recognised by some compilers to avoid 'unused' warnings */
137#ifndef SWIGUNUSED
138# if defined(__GNUC__)
139# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
140# define SWIGUNUSED __attribute__ ((__unused__))
141# else
142# define SWIGUNUSED
143# endif
144# elif defined(__ICC)
145# define SWIGUNUSED __attribute__ ((__unused__))
146# else
147# define SWIGUNUSED
148# endif
149#endif
150
151#ifndef SWIGUNUSEDPARM
152# ifdef __cplusplus
153# define SWIGUNUSEDPARM(p)
154# else
155# define SWIGUNUSEDPARM(p) p SWIGUNUSED
156# endif
157#endif
158
159/* internal SWIG method */
160#ifndef SWIGINTERN
161# define SWIGINTERN static SWIGUNUSED
162#endif
163
164/* internal inline SWIG method */
165#ifndef SWIGINTERNINLINE
166# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
167#endif
168
169/* exporting methods */
170#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
171# ifndef GCC_HASCLASSVISIBILITY
172# define GCC_HASCLASSVISIBILITY
173# endif
174#endif
175
176#ifndef SWIGEXPORT
177# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
178# if defined(STATIC_LINKED)
179# define SWIGEXPORT
180# else
181# define SWIGEXPORT __declspec(dllexport)
182# endif
183# else
184# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
185# define SWIGEXPORT __attribute__ ((visibility("default")))
186# else
187# define SWIGEXPORT
188# endif
189# endif
190#endif
191
192/* calling conventions for Windows */
193#ifndef SWIGSTDCALL
194# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
195# define SWIGSTDCALL __stdcall
196# else
197# define SWIGSTDCALL
198# endif
199#endif
200
201/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
202#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
203# define _CRT_SECURE_NO_DEPRECATE
204#endif
205
206/* -----------------------------------------------------------------------------
207 * swigrun.swg
208 *
209 * This file contains generic CAPI SWIG runtime support for pointer
210 * type checking.
211 * ----------------------------------------------------------------------------- */
212
213/* This should only be incremented when either the layout of swig_type_info changes,
214 or for whatever reason, the runtime changes incompatibly */
215#define SWIG_RUNTIME_VERSION "3"
216
217/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
218#ifdef SWIG_TYPE_TABLE
219# define SWIG_QUOTE_STRING(x) #x
220# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
221# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
222#else
223# define SWIG_TYPE_TABLE_NAME
224#endif
225
226/*
227 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
228 creating a static or dynamic library from the swig runtime code.
229 In 99.9% of the cases, swig just needs to declare them as 'static'.
230
231 But only do this if is strictly necessary, ie, if you have problems
232 with your compiler or so.
233*/
234
235#ifndef SWIGRUNTIME
236# define SWIGRUNTIME SWIGINTERN
237#endif
238
239#ifndef SWIGRUNTIMEINLINE
240# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
241#endif
242
243/* Generic buffer size */
244#ifndef SWIG_BUFFER_SIZE
245# define SWIG_BUFFER_SIZE 1024
246#endif
247
248/* Flags for pointer conversions */
249#define SWIG_POINTER_DISOWN 0x1
250
251/* Flags for new pointer objects */
252#define SWIG_POINTER_OWN 0x1
253
254
255/*
256 Flags/methods for returning states.
257
258 The swig conversion methods, as ConvertPtr, return and integer
259 that tells if the conversion was successful or not. And if not,
260 an error code can be returned (see swigerrors.swg for the codes).
261
262 Use the following macros/flags to set or process the returning
263 states.
264
265 In old swig versions, you usually write code as:
266
267 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
268 // success code
269 } else {
270 //fail code
271 }
272
273 Now you can be more explicit as:
274
275 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
276 if (SWIG_IsOK(res)) {
277 // success code
278 } else {
279 // fail code
280 }
281
282 that seems to be the same, but now you can also do
283
284 Type *ptr;
285 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
286 if (SWIG_IsOK(res)) {
287 // success code
288 if (SWIG_IsNewObj(res) {
289 ...
290 delete *ptr;
291 } else {
292 ...
293 }
294 } else {
295 // fail code
296 }
297
298 I.e., now SWIG_ConvertPtr can return new objects and you can
299 identify the case and take care of the deallocation. Of course that
300 requires also to SWIG_ConvertPtr to return new result values, as
301
302 int SWIG_ConvertPtr(obj, ptr,...) {
303 if (<obj is ok>) {
304 if (<need new object>) {
305 *ptr = <ptr to new allocated object>;
306 return SWIG_NEWOBJ;
307 } else {
308 *ptr = <ptr to old object>;
309 return SWIG_OLDOBJ;
310 }
311 } else {
312 return SWIG_BADOBJ;
313 }
314 }
315
316 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
317 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
318 swig errors code.
319
320 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
321 allows to return the 'cast rank', for example, if you have this
322
323 int food(double)
324 int fooi(int);
325
326 and you call
327
328 food(1) // cast rank '1' (1 -> 1.0)
329 fooi(1) // cast rank '0'
330
331 just use the SWIG_AddCast()/SWIG_CheckState()
332
333
334 */
335#define SWIG_OK (0)
336#define SWIG_ERROR (-1)
337#define SWIG_IsOK(r) (r >= 0)
338#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
339
340/* The CastRankLimit says how many bits are used for the cast rank */
341#define SWIG_CASTRANKLIMIT (1 << 8)
342/* The NewMask denotes the object was created (using new/malloc) */
343#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
344/* The TmpMask is for in/out typemaps that use temporal objects */
345#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
346/* Simple returning values */
347#define SWIG_BADOBJ (SWIG_ERROR)
348#define SWIG_OLDOBJ (SWIG_OK)
349#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
350#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
351/* Check, add and del mask methods */
352#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
353#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
354#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
355#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
356#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
357#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
358
359
360/* Cast-Rank Mode */
361#if defined(SWIG_CASTRANK_MODE)
362# ifndef SWIG_TypeRank
363# define SWIG_TypeRank unsigned long
364# endif
365# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
366# define SWIG_MAXCASTRANK (2)
367# endif
368# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
369# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
370SWIGINTERNINLINE int SWIG_AddCast(int r) {
371 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
372}
373SWIGINTERNINLINE int SWIG_CheckState(int r) {
374 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
375}
376#else /* no cast-rank mode */
377# define SWIG_AddCast
378# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
379#endif
380
381
382
383
384#include <string.h>
385
386#ifdef __cplusplus
387extern "C" {
388#endif
389
390typedef void *(*swig_converter_func)(void *);
391typedef struct swig_type_info *(*swig_dycast_func)(void **);
392
393/* Structure to store inforomation on one type */
394typedef struct swig_type_info {
395 const char *name; /* mangled name of this type */
396 const char *str; /* human readable name of this type */
397 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
398 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
399 void *clientdata; /* language specific type data */
400 int owndata; /* flag if the structure owns the clientdata */
401} swig_type_info;
402
403/* Structure to store a type and conversion function used for casting */
404typedef struct swig_cast_info {
405 swig_type_info *type; /* pointer to type that is equivalent to this type */
406 swig_converter_func converter; /* function to cast the void pointers */
407 struct swig_cast_info *next; /* pointer to next cast in linked list */
408 struct swig_cast_info *prev; /* pointer to the previous cast */
409} swig_cast_info;
410
411/* Structure used to store module information
412 * Each module generates one structure like this, and the runtime collects
413 * all of these structures and stores them in a circularly linked list.*/
414typedef struct swig_module_info {
415 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
416 size_t size; /* Number of types in this module */
417 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
418 swig_type_info **type_initial; /* Array of initially generated type structures */
419 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
420 void *clientdata; /* Language specific module data */
421} swig_module_info;
422
423/*
424 Compare two type names skipping the space characters, therefore
425 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
426
427 Return 0 when the two name types are equivalent, as in
428 strncmp, but skipping ' '.
429*/
430SWIGRUNTIME int
431SWIG_TypeNameComp(const char *f1, const char *l1,
432 const char *f2, const char *l2) {
433 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
434 while ((*f1 == ' ') && (f1 != l1)) ++f1;
435 while ((*f2 == ' ') && (f2 != l2)) ++f2;
436 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
437 }
438 return (l1 - f1) - (l2 - f2);
439}
440
441/*
442 Check type equivalence in a name list like <name1>|<name2>|...
443 Return 0 if not equal, 1 if equal
444*/
445SWIGRUNTIME int
446SWIG_TypeEquiv(const char *nb, const char *tb) {
447 int equiv = 0;
448 const char* te = tb + strlen(tb);
449 const char* ne = nb;
450 while (!equiv && *ne) {
451 for (nb = ne; *ne; ++ne) {
452 if (*ne == '|') break;
453 }
454 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
455 if (*ne) ++ne;
456 }
457 return equiv;
458}
459
460/*
461 Check type equivalence in a name list like <name1>|<name2>|...
462 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
463*/
464SWIGRUNTIME int
465SWIG_TypeCompare(const char *nb, const char *tb) {
466 int equiv = 0;
467 const char* te = tb + strlen(tb);
468 const char* ne = nb;
469 while (!equiv && *ne) {
470 for (nb = ne; *ne; ++ne) {
471 if (*ne == '|') break;
472 }
473 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
474 if (*ne) ++ne;
475 }
476 return equiv;
477}
478
479
480/* think of this as a c++ template<> or a scheme macro */
481#define SWIG_TypeCheck_Template(comparison, ty) \
482 if (ty) { \
483 swig_cast_info *iter = ty->cast; \
484 while (iter) { \
485 if (comparison) { \
486 if (iter == ty->cast) return iter; \
487 /* Move iter to the top of the linked list */ \
488 iter->prev->next = iter->next; \
489 if (iter->next) \
490 iter->next->prev = iter->prev; \
491 iter->next = ty->cast; \
492 iter->prev = 0; \
493 if (ty->cast) ty->cast->prev = iter; \
494 ty->cast = iter; \
495 return iter; \
496 } \
497 iter = iter->next; \
498 } \
499 } \
500 return 0
501
502/*
503 Check the typename
504*/
505SWIGRUNTIME swig_cast_info *
506SWIG_TypeCheck(const char *c, swig_type_info *ty) {
507 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
508}
509
510/* Same as previous function, except strcmp is replaced with a pointer comparison */
511SWIGRUNTIME swig_cast_info *
512SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
513 SWIG_TypeCheck_Template(iter->type == from, into);
514}
515
516/*
517 Cast a pointer up an inheritance hierarchy
518*/
519SWIGRUNTIMEINLINE void *
520SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
521 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
522}
523
524/*
525 Dynamic pointer casting. Down an inheritance hierarchy
526*/
527SWIGRUNTIME swig_type_info *
528SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
529 swig_type_info *lastty = ty;
530 if (!ty || !ty->dcast) return ty;
531 while (ty && (ty->dcast)) {
532 ty = (*ty->dcast)(ptr);
533 if (ty) lastty = ty;
534 }
535 return lastty;
536}
537
538/*
539 Return the name associated with this type
540*/
541SWIGRUNTIMEINLINE const char *
542SWIG_TypeName(const swig_type_info *ty) {
543 return ty->name;
544}
545
546/*
547 Return the pretty name associated with this type,
548 that is an unmangled type name in a form presentable to the user.
549*/
550SWIGRUNTIME const char *
551SWIG_TypePrettyName(const swig_type_info *type) {
552 /* The "str" field contains the equivalent pretty names of the
553 type, separated by vertical-bar characters. We choose
554 to print the last name, as it is often (?) the most
555 specific. */
556 if (!type) return NULL;
557 if (type->str != NULL) {
558 const char *last_name = type->str;
559 const char *s;
560 for (s = type->str; *s; s++)
561 if (*s == '|') last_name = s+1;
562 return last_name;
563 }
564 else
565 return type->name;
566}
567
568/*
569 Set the clientdata field for a type
570*/
571SWIGRUNTIME void
572SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
573 swig_cast_info *cast = ti->cast;
574 /* if (ti->clientdata == clientdata) return; */
575 ti->clientdata = clientdata;
576
577 while (cast) {
578 if (!cast->converter) {
579 swig_type_info *tc = cast->type;
580 if (!tc->clientdata) {
581 SWIG_TypeClientData(tc, clientdata);
582 }
583 }
584 cast = cast->next;
585 }
586}
587SWIGRUNTIME void
588SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
589 SWIG_TypeClientData(ti, clientdata);
590 ti->owndata = 1;
591}
592
593/*
594 Search for a swig_type_info structure only by mangled name
595 Search is a O(log #types)
596
597 We start searching at module start, and finish searching when start == end.
598 Note: if start == end at the beginning of the function, we go all the way around
599 the circular list.
600*/
601SWIGRUNTIME swig_type_info *
602SWIG_MangledTypeQueryModule(swig_module_info *start,
603 swig_module_info *end,
604 const char *name) {
605 swig_module_info *iter = start;
606 do {
607 if (iter->size) {
608 register size_t l = 0;
609 register size_t r = iter->size - 1;
610 do {
611 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
612 register size_t i = (l + r) >> 1;
613 const char *iname = iter->types[i]->name;
614 if (iname) {
615 register int compare = strcmp(name, iname);
616 if (compare == 0) {
617 return iter->types[i];
618 } else if (compare < 0) {
619 if (i) {
620 r = i - 1;
621 } else {
622 break;
623 }
624 } else if (compare > 0) {
625 l = i + 1;
626 }
627 } else {
628 break; /* should never happen */
629 }
630 } while (l <= r);
631 }
632 iter = iter->next;
633 } while (iter != end);
634 return 0;
635}
636
637/*
638 Search for a swig_type_info structure for either a mangled name or a human readable name.
639 It first searches the mangled names of the types, which is a O(log #types)
640 If a type is not found it then searches the human readable names, which is O(#types).
641
642 We start searching at module start, and finish searching when start == end.
643 Note: if start == end at the beginning of the function, we go all the way around
644 the circular list.
645*/
646SWIGRUNTIME swig_type_info *
647SWIG_TypeQueryModule(swig_module_info *start,
648 swig_module_info *end,
649 const char *name) {
650 /* STEP 1: Search the name field using binary search */
651 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
652 if (ret) {
653 return ret;
654 } else {
655 /* STEP 2: If the type hasn't been found, do a complete search
656 of the str field (the human readable name) */
657 swig_module_info *iter = start;
658 do {
659 register size_t i = 0;
660 for (; i < iter->size; ++i) {
661 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
662 return iter->types[i];
663 }
664 iter = iter->next;
665 } while (iter != end);
666 }
667
668 /* neither found a match */
669 return 0;
670}
671
672/*
673 Pack binary data into a string
674*/
675SWIGRUNTIME char *
676SWIG_PackData(char *c, void *ptr, size_t sz) {
677 static const char hex[17] = "0123456789abcdef";
678 register const unsigned char *u = (unsigned char *) ptr;
679 register const unsigned char *eu = u + sz;
680 for (; u != eu; ++u) {
681 register unsigned char uu = *u;
682 *(c++) = hex[(uu & 0xf0) >> 4];
683 *(c++) = hex[uu & 0xf];
684 }
685 return c;
686}
687
688/*
689 Unpack binary data from a string
690*/
691SWIGRUNTIME const char *
692SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
693 register unsigned char *u = (unsigned char *) ptr;
694 register const unsigned char *eu = u + sz;
695 for (; u != eu; ++u) {
696 register char d = *(c++);
697 register unsigned char uu;
698 if ((d >= '0') && (d <= '9'))
699 uu = ((d - '0') << 4);
700 else if ((d >= 'a') && (d <= 'f'))
701 uu = ((d - ('a'-10)) << 4);
702 else
703 return (char *) 0;
704 d = *(c++);
705 if ((d >= '0') && (d <= '9'))
706 uu |= (d - '0');
707 else if ((d >= 'a') && (d <= 'f'))
708 uu |= (d - ('a'-10));
709 else
710 return (char *) 0;
711 *u = uu;
712 }
713 return c;
714}
715
716/*
717 Pack 'void *' into a string buffer.
718*/
719SWIGRUNTIME char *
720SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
721 char *r = buff;
722 if ((2*sizeof(void *) + 2) > bsz) return 0;
723 *(r++) = '_';
724 r = SWIG_PackData(r,&ptr,sizeof(void *));
725 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
726 strcpy(r,name);
727 return buff;
728}
729
730SWIGRUNTIME const char *
731SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
732 if (*c != '_') {
733 if (strcmp(c,"NULL") == 0) {
734 *ptr = (void *) 0;
735 return name;
736 } else {
737 return 0;
738 }
739 }
740 return SWIG_UnpackData(++c,ptr,sizeof(void *));
741}
742
743SWIGRUNTIME char *
744SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
745 char *r = buff;
746 size_t lname = (name ? strlen(name) : 0);
747 if ((2*sz + 2 + lname) > bsz) return 0;
748 *(r++) = '_';
749 r = SWIG_PackData(r,ptr,sz);
750 if (lname) {
751 strncpy(r,name,lname+1);
752 } else {
753 *r = 0;
754 }
755 return buff;
756}
757
758SWIGRUNTIME const char *
759SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
760 if (*c != '_') {
761 if (strcmp(c,"NULL") == 0) {
762 memset(ptr,0,sz);
763 return name;
764 } else {
765 return 0;
766 }
767 }
768 return SWIG_UnpackData(++c,ptr,sz);
769}
770
771#ifdef __cplusplus
772}
773#endif
774
775/* Errors in SWIG */
776#define SWIG_UnknownError -1
777#define SWIG_IOError -2
778#define SWIG_RuntimeError -3
779#define SWIG_IndexError -4
780#define SWIG_TypeError -5
781#define SWIG_DivisionByZero -6
782#define SWIG_OverflowError -7
783#define SWIG_SyntaxError -8
784#define SWIG_ValueError -9
785#define SWIG_SystemError -10
786#define SWIG_AttributeError -11
787#define SWIG_MemoryError -12
788#define SWIG_NullReferenceError -13
789
790
791
792#include <ruby.h>
793
794/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
795#ifndef NUM2LL
796#define NUM2LL(x) NUM2LONG((x))
797#endif
798#ifndef LL2NUM
799#define LL2NUM(x) INT2NUM((long) (x))
800#endif
801#ifndef ULL2NUM
802#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
803#endif
804
805/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
806#ifndef NUM2ULL
807#ifdef HAVE_LONG_LONG
808#define NUM2ULL(x) rb_num2ull((x))
809#else
810#define NUM2ULL(x) NUM2ULONG(x)
811#endif
812#endif
813
814/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
815/* Define these for older versions so we can just write code the new way */
816#ifndef RSTRING_LEN
817# define RSTRING_LEN(x) RSTRING(x)->len
818#endif
819#ifndef RSTRING_PTR
820# define RSTRING_PTR(x) RSTRING(x)->ptr
821#endif
822#ifndef RARRAY_LEN
823# define RARRAY_LEN(x) RARRAY(x)->len
824#endif
825#ifndef RARRAY_PTR
826# define RARRAY_PTR(x) RARRAY(x)->ptr
827#endif
828
829/*
830 * Need to be very careful about how these macros are defined, especially
831 * when compiling C++ code or C code with an ANSI C compiler.
832 *
833 * VALUEFUNC(f) is a macro used to typecast a C function that implements
834 * a Ruby method so that it can be passed as an argument to API functions
835 * like rb_define_method() and rb_define_singleton_method().
836 *
837 * VOIDFUNC(f) is a macro used to typecast a C function that implements
838 * either the "mark" or "free" stuff for a Ruby Data object, so that it
839 * can be passed as an argument to API functions like Data_Wrap_Struct()
840 * and Data_Make_Struct().
841 */
842
843#ifdef __cplusplus
844# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
845# define PROTECTFUNC(f) ((VALUE (*)()) f)
846# define VALUEFUNC(f) ((VALUE (*)()) f)
847# define VOIDFUNC(f) ((void (*)()) f)
848# else
849# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
850# define PROTECTFUNC(f) ((VALUE (*)()) f)
851# define VALUEFUNC(f) ((VALUE (*)()) f)
852# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
853# else /* These definitions should work for Ruby 1.7+ */
854# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
855# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
856# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
857# endif
858# endif
859#else
860# define VALUEFUNC(f) (f)
861# define VOIDFUNC(f) (f)
862#endif
863
864/* Don't use for expressions have side effect */
865#ifndef RB_STRING_VALUE
866#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
867#endif
868#ifndef StringValue
869#define StringValue(s) RB_STRING_VALUE(s)
870#endif
871#ifndef StringValuePtr
872#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
873#endif
874#ifndef StringValueLen
875#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
876#endif
877#ifndef SafeStringValue
878#define SafeStringValue(v) do {\
879 StringValue(v);\
880 rb_check_safe_str(v);\
881} while (0)
882#endif
883
884#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
885#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
886#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
887#endif
888
889
890/* -----------------------------------------------------------------------------
891 * error manipulation
892 * ----------------------------------------------------------------------------- */
893
894
895/* Define some additional error types */
896#define SWIG_ObjectPreviouslyDeletedError -100
897
898
899/* Define custom exceptions for errors that do not map to existing Ruby
900 exceptions. Note this only works for C++ since a global cannot be
901 initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/
902
903SWIGINTERN VALUE
904getNullReferenceError(void) {
905 static int init = 0;
906 static VALUE rb_eNullReferenceError ;
907 if (!init) {
908 init = 1;
909 rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
910 }
911 return rb_eNullReferenceError;
912}
913
914SWIGINTERN VALUE
915getObjectPreviouslyDeletedError(void) {
916 static int init = 0;
917 static VALUE rb_eObjectPreviouslyDeleted ;
918 if (!init) {
919 init = 1;
920 rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
921 }
922 return rb_eObjectPreviouslyDeleted;
923}
924
925
926SWIGINTERN VALUE
927SWIG_Ruby_ErrorType(int SWIG_code) {
928 VALUE type;
929 switch (SWIG_code) {
930 case SWIG_MemoryError:
931 type = rb_eNoMemError;
932 break;
933 case SWIG_IOError:
934 type = rb_eIOError;
935 break;
936 case SWIG_RuntimeError:
937 type = rb_eRuntimeError;
938 break;
939 case SWIG_IndexError:
940 type = rb_eIndexError;
941 break;
942 case SWIG_TypeError:
943 type = rb_eTypeError;
944 break;
945 case SWIG_DivisionByZero:
946 type = rb_eZeroDivError;
947 break;
948 case SWIG_OverflowError:
949 type = rb_eRangeError;
950 break;
951 case SWIG_SyntaxError:
952 type = rb_eSyntaxError;
953 break;
954 case SWIG_ValueError:
955 type = rb_eArgError;
956 break;
957 case SWIG_SystemError:
958 type = rb_eFatal;
959 break;
960 case SWIG_AttributeError:
961 type = rb_eRuntimeError;
962 break;
963 case SWIG_NullReferenceError:
964 type = getNullReferenceError();
965 break;
966 case SWIG_ObjectPreviouslyDeletedError:
967 type = getObjectPreviouslyDeletedError();
968 break;
969 case SWIG_UnknownError:
970 type = rb_eRuntimeError;
971 break;
972 default:
973 type = rb_eRuntimeError;
974 }
975 return type;
976}
977
978
979
980
981/* -----------------------------------------------------------------------------
982 * See the LICENSE file for information on copyright, usage and redistribution
983 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
984 *
985 * rubytracking.swg
986 *
987 * This file contains support for tracking mappings from
988 * Ruby objects to C++ objects. This functionality is needed
989 * to implement mark functions for Ruby's mark and sweep
990 * garbage collector.
991 * ----------------------------------------------------------------------------- */
992
993#ifdef __cplusplus
994extern "C" {
995#endif
996
997
998/* Global Ruby hash table to store Trackings from C/C++
999 structs to Ruby Objects. */
1000static VALUE swig_ruby_trackings;
1001
1002/* Global variable that stores a reference to the ruby
1003 hash table delete function. */
1004static ID swig_ruby_hash_delete = 0;
1005
1006/* Setup a Ruby hash table to store Trackings */
1007SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1008 /* Create a ruby hash table to store Trackings from C++
1009 objects to Ruby objects. Also make sure to tell
1010 the garabage collector about the hash table. */
1011 swig_ruby_trackings = rb_hash_new();
1012 rb_gc_register_address(&swig_ruby_trackings);
1013
1014 /* Now store a reference to the hash table delete function
1015 so that we only have to look it up once.*/
1016 swig_ruby_hash_delete = rb_intern("delete");
1017}
1018
1019/* Get a Ruby number to reference a pointer */
1020SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1021 /* We cast the pointer to an unsigned long
1022 and then store a reference to it using
1023 a Ruby number object. */
1024
1025 /* Convert the pointer to a Ruby number */
1026 unsigned long value = (unsigned long) ptr;
1027 return LONG2NUM(value);
1028}
1029
1030/* Get a Ruby number to reference an object */
1031SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1032 /* We cast the object to an unsigned long
1033 and then store a reference to it using
1034 a Ruby number object. */
1035
1036 /* Convert the Object to a Ruby number */
1037 unsigned long value = (unsigned long) object;
1038 return LONG2NUM(value);
1039}
1040
1041/* Get a Ruby object from a previously stored reference */
1042SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1043 /* The provided Ruby number object is a reference
1044 to the Ruby object we want.*/
1045
1046 /* First convert the Ruby number to a C number */
1047 unsigned long value = NUM2LONG(reference);
1048 return (VALUE) value;
1049}
1050
1051/* Add a Tracking from a C/C++ struct to a Ruby object */
1052SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1053 /* In a Ruby hash table we store the pointer and
1054 the associated Ruby object. The trick here is
1055 that we cannot store the Ruby object directly - if
1056 we do then it cannot be garbage collected. So
1057 instead we typecast it as a unsigned long and
1058 convert it to a Ruby number object.*/
1059
1060 /* Get a reference to the pointer as a Ruby number */
1061 VALUE key = SWIG_RubyPtrToReference(ptr);
1062
1063 /* Get a reference to the Ruby object as a Ruby number */
1064 VALUE value = SWIG_RubyObjectToReference(object);
1065
1066 /* Store the mapping to the global hash table. */
1067 rb_hash_aset(swig_ruby_trackings, key, value);
1068}
1069
1070/* Get the Ruby object that owns the specified C/C++ struct */
1071SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1072 /* Get a reference to the pointer as a Ruby number */
1073 VALUE key = SWIG_RubyPtrToReference(ptr);
1074
1075 /* Now lookup the value stored in the global hash table */
1076 VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1077
1078 if (value == Qnil) {
1079 /* No object exists - return nil. */
1080 return Qnil;
1081 }
1082 else {
1083 /* Convert this value to Ruby object */
1084 return SWIG_RubyReferenceToObject(value);
1085 }
1086}
1087
1088/* Remove a Tracking from a C/C++ struct to a Ruby object. It
1089 is very important to remove objects once they are destroyed
1090 since the same memory address may be reused later to create
1091 a new object. */
1092SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1093 /* Get a reference to the pointer as a Ruby number */
1094 VALUE key = SWIG_RubyPtrToReference(ptr);
1095
1096 /* Delete the object from the hash table by calling Ruby's
1097 do this we need to call the Hash.delete method.*/
1098 rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1099}
1100
1101/* This is a helper method that unlinks a Ruby object from its
1102 underlying C++ object. This is needed if the lifetime of the
1103 Ruby object is longer than the C++ object */
1104SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1105 VALUE object = SWIG_RubyInstanceFor(ptr);
1106
1107 if (object != Qnil) {
1108 DATA_PTR(object) = 0;
1109 }
1110}
1111
1112
1113#ifdef __cplusplus
1114}
1115#endif
1116
1117/* -----------------------------------------------------------------------------
1118 * Ruby API portion that goes into the runtime
1119 * ----------------------------------------------------------------------------- */
1120
1121#ifdef __cplusplus
1122extern "C" {
1123#endif
1124
1125SWIGINTERN VALUE
1126SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1127 if (NIL_P(target)) {
1128 target = o;
1129 } else {
1130 if (TYPE(target) != T_ARRAY) {
1131 VALUE o2 = target;
1132 target = rb_ary_new();
1133 rb_ary_push(target, o2);
1134 }
1135 rb_ary_push(target, o);
1136 }
1137 return target;
1138}
1139
1140#ifdef __cplusplus
1141}
1142#endif
1143
1144
1145/* -----------------------------------------------------------------------------
1146 * See the LICENSE file for information on copyright, usage and redistribution
1147 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1148 *
1149 * rubyrun.swg
1150 *
1151 * This file contains the runtime support for Ruby modules
1152 * and includes code for managing global variables and pointer
1153 * type checking.
1154 * ----------------------------------------------------------------------------- */
1155
1156/* For backward compatibility only */
1157#define SWIG_POINTER_EXCEPTION 0
1158
1159/* for raw pointers */
1160#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1161#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1162#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1163#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1164#define swig_owntype ruby_owntype
1165
1166/* for raw packed data */
1167#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1168#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1169
1170/* for class or struct pointers */
1171#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1172#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1173
1174/* for C or C++ function pointers */
1175#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1176#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1177
1178/* for C++ member pointers, ie, member methods */
1179#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1180#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1181
1182
1183/* Runtime API */
1184
1185#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
1186#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1187
1188
1189/* Error manipulation */
1190
1191#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1192#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
1193#define SWIG_fail goto fail
1194
1195
1196/* Ruby-specific SWIG API */
1197
1198#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1199#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1200#define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1201#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1202#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1203
1204
1205/* -----------------------------------------------------------------------------
1206 * pointers/data manipulation
1207 * ----------------------------------------------------------------------------- */
1208
1209#ifdef __cplusplus
1210extern "C" {
1211#if 0
1212} /* cc-mode */
1213#endif
1214#endif
1215
1216typedef struct {
1217 VALUE klass;
1218 VALUE mImpl;
1219 void (*mark)(void *);
1220 void (*destroy)(void *);
1221 int trackObjects;
1222} swig_class;
1223
1224
1225static VALUE _mSWIG = Qnil;
1226static VALUE _cSWIG_Pointer = Qnil;
1227static VALUE swig_runtime_data_type_pointer = Qnil;
1228
1229SWIGRUNTIME VALUE
1230getExceptionClass(void) {
1231 static int init = 0;
1232 static VALUE rubyExceptionClass ;
1233 if (!init) {
1234 init = 1;
1235 rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1236 }
1237 return rubyExceptionClass;
1238}
1239
1240/* This code checks to see if the Ruby object being raised as part
1241 of an exception inherits from the Ruby class Exception. If so,
1242 the object is simply returned. If not, then a new Ruby exception
1243 object is created and that will be returned to Ruby.*/
1244SWIGRUNTIME VALUE
1245SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1246 VALUE exceptionClass = getExceptionClass();
1247 if (rb_obj_is_kind_of(obj, exceptionClass)) {
1248 return obj;
1249 } else {
1250 return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1251 }
1252}
1253
1254/* Initialize Ruby runtime support */
1255SWIGRUNTIME void
1256SWIG_Ruby_InitRuntime(void)
1257{
1258 if (_mSWIG == Qnil) {
1259 _mSWIG = rb_define_module("SWIG");
1260 }
1261}
1262
1263/* Define Ruby class for C type */
1264SWIGRUNTIME void
1265SWIG_Ruby_define_class(swig_type_info *type)
1266{
1267 VALUE klass;
1268 char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1269 sprintf(klass_name, "TYPE%s", type->name);
1270 if (NIL_P(_cSWIG_Pointer)) {
1271 _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1272 rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1273 }
1274 klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1275 free((void *) klass_name);
1276}
1277
1278/* Create a new pointer object */
1279SWIGRUNTIME VALUE
1280SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1281{
1282 int own = flags & SWIG_POINTER_OWN;
1283
1284 char *klass_name;
1285 swig_class *sklass;
1286 VALUE klass;
1287 VALUE obj;
1288
1289 if (!ptr)
1290 return Qnil;
1291
1292 if (type->clientdata) {
1293 sklass = (swig_class *) type->clientdata;
1294
1295 /* Are we tracking this class and have we already returned this Ruby object? */
1296 if (sklass->trackObjects) {
1297 obj = SWIG_RubyInstanceFor(ptr);
1298
1299 /* Check the object's type and make sure it has the correct type.
1300 It might not in cases where methods do things like
1301 downcast methods. */
1302 if (obj != Qnil) {
1303 VALUE value = rb_iv_get(obj, "__swigtype__");
1304 char* type_name = RSTRING_PTR(value);
1305
1306 if (strcmp(type->name, type_name) == 0) {
1307 return obj;
1308 }
1309 }
1310 }
1311
1312 /* Create a new Ruby object */
1313 obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
1314
1315 /* If tracking is on for this class then track this object. */
1316 if (sklass->trackObjects) {
1317 SWIG_RubyAddTracking(ptr, obj);
1318 }
1319 } else {
1320 klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1321 sprintf(klass_name, "TYPE%s", type->name);
1322 klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1323 free((void *) klass_name);
1324 obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1325 }
1326 rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1327
1328 return obj;
1329}
1330
1331/* Create a new class instance (always owned) */
1332SWIGRUNTIME VALUE
1333SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1334{
1335 VALUE obj;
1336 swig_class *sklass = (swig_class *) type->clientdata;
1337 obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1338 rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
1339 return obj;
1340}
1341
1342/* Get type mangle from class name */
1343SWIGRUNTIMEINLINE char *
1344SWIG_Ruby_MangleStr(VALUE obj)
1345{
1346 VALUE stype = rb_iv_get(obj, "__swigtype__");
1347 return StringValuePtr(stype);
1348}
1349
1350/* Acquire a pointer value */
1351typedef void (*ruby_owntype)(void*);
1352
1353SWIGRUNTIME ruby_owntype
1354SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1355 if (obj) {
1356 ruby_owntype oldown = RDATA(obj)->dfree;
1357 RDATA(obj)->dfree = own;
1358 return oldown;
1359 } else {
1360 return 0;
1361 }
1362}
1363
1364/* Convert a pointer value */
1365SWIGRUNTIME int
1366SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1367{
1368 char *c;
1369 swig_cast_info *tc;
1370 void *vptr = 0;
1371
1372 /* Grab the pointer */
1373 if (NIL_P(obj)) {
1374 *ptr = 0;
1375 return SWIG_OK;
1376 } else {
1377 if (TYPE(obj) != T_DATA) {
1378 return SWIG_ERROR;
1379 }
1380 Data_Get_Struct(obj, void, vptr);
1381 }
1382
1383 if (own) *own = RDATA(obj)->dfree;
1384
1385 /* Check to see if the input object is giving up ownership
1386 of the underlying C struct or C++ object. If so then we
1387 need to reset the destructor since the Ruby object no
1388 longer owns the underlying C++ object.*/
1389 if (flags & SWIG_POINTER_DISOWN) {
1390 /* Is tracking on for this class? */
1391 int track = 0;
1392 if (ty && ty->clientdata) {
1393 swig_class *sklass = (swig_class *) ty->clientdata;
1394 track = sklass->trackObjects;
1395 }
1396
1397 if (track) {
1398 /* We are tracking objects for this class. Thus we change the destructor
1399 * to SWIG_RubyRemoveTracking. This allows us to
1400 * remove the mapping from the C++ to Ruby object
1401 * when the Ruby object is garbage collected. If we don't
1402 * do this, then it is possible we will return a reference
1403 * to a Ruby object that no longer exists thereby crashing Ruby. */
1404 RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1405 } else {
1406 RDATA(obj)->dfree = 0;
1407 }
1408 }
1409
1410 /* Do type-checking if type info was provided */
1411 if (ty) {
1412 if (ty->clientdata) {
1413 if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1414 if (vptr == 0) {
1415 /* The object has already been deleted */
1416 return SWIG_ObjectPreviouslyDeletedError;
1417 }
1418 *ptr = vptr;
1419 return SWIG_OK;
1420 }
1421 }
1422 if ((c = SWIG_MangleStr(obj)) == NULL) {
1423 return SWIG_ERROR;
1424 }
1425 tc = SWIG_TypeCheck(c, ty);
1426 if (!tc) {
1427 return SWIG_ERROR;
1428 }
1429 *ptr = SWIG_TypeCast(tc, vptr);
1430 } else {
1431 *ptr = vptr;
1432 }
1433
1434 return SWIG_OK;
1435}
1436
1437/* Check convert */
1438SWIGRUNTIMEINLINE int
1439SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1440{
1441 char *c = SWIG_MangleStr(obj);
1442 if (!c) return 0;
1443 return SWIG_TypeCheck(c,ty) != 0;
1444}
1445
1446SWIGRUNTIME VALUE
1447SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1448 char result[1024];
1449 char *r = result;
1450 if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1451 *(r++) = '_';
1452 r = SWIG_PackData(r, ptr, sz);
1453 strcpy(r, type->name);
1454 return rb_str_new2(result);
1455}
1456
1457/* Convert a packed value value */
1458SWIGRUNTIME int
1459SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1460 swig_cast_info *tc;
1461 const char *c;
1462
1463 if (TYPE(obj) != T_STRING) goto type_error;
1464 c = StringValuePtr(obj);
1465 /* Pointer values must start with leading underscore */
1466 if (*c != '_') goto type_error;
1467 c++;
1468 c = SWIG_UnpackData(c, ptr, sz);
1469 if (ty) {
1470 tc = SWIG_TypeCheck(c, ty);
1471 if (!tc) goto type_error;
1472 }
1473 return SWIG_OK;
1474
1475 type_error:
1476 return SWIG_ERROR;
1477}
1478
1479SWIGRUNTIME swig_module_info *
1480SWIG_Ruby_GetModule(void)
1481{
1482 VALUE pointer;
1483 swig_module_info *ret = 0;
1484 VALUE verbose = rb_gv_get("VERBOSE");
1485
1486 /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1487 rb_gv_set("VERBOSE", Qfalse);
1488
1489 /* first check if pointer already created */
1490 pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1491 if (pointer != Qnil) {
1492 Data_Get_Struct(pointer, swig_module_info, ret);
1493 }
1494
1495 /* reinstate warnings */
1496 rb_gv_set("VERBOSE", verbose);
1497 return ret;
1498}
1499
1500SWIGRUNTIME void
1501SWIG_Ruby_SetModule(swig_module_info *pointer)
1502{
1503 /* register a new class */
1504 VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1505 /* create and store the structure pointer to a global variable */
1506 swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1507 rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1508}
1509
1510#ifdef __cplusplus
1511#if 0
1512{ /* cc-mode */
1513#endif
1514}
1515#endif
1516
1517
1518
1519#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1520
1521#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1522
1523
1524
1525/* -------- TYPES TABLE (BEGIN) -------- */
1526
1527#define SWIGTYPE_p_char swig_types[0]
1528static swig_type_info *swig_types[2];
1529static swig_module_info swig_module = {swig_types, 1, 0, 0, 0, 0};
1530#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1531#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1532
1533/* -------- TYPES TABLE (END) -------- */
1534
1535#define SWIG_init Init_chaos_calendar
1536#define SWIG_name "Chaos_calendar"
1537
1538static VALUE mChaos_calendar;
1539
1540#define SWIGVERSION 0x010331
1541#define SWIG_VERSION SWIGVERSION
1542
1543
1544#define SWIG_as_voidptr(a) (void *)((const void *)(a))
1545#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1546
1547
1548 VALUE occurrences( VALUE dtstart, VALUE dtend, char * rrule );
1549 VALUE duration_to_fixnum( char * duration );
1550
1551
1552SWIGINTERN swig_type_info*
1553SWIG_pchar_descriptor(void)
1554{
1555 static int init = 0;
1556 static swig_type_info* info = 0;
1557 if (!init) {
1558 info = SWIG_TypeQuery("_p_char");
1559 init = 1;
1560 }
1561 return info;
1562}
1563
1564
1565SWIGINTERN int
1566SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1567{
1568 if (TYPE(obj) == T_STRING) {
1569
1570
1571
1572 char *cstr = STR2CSTR(obj);
1573
1574 size_t size = RSTRING_LEN(obj) + 1;
1575 if (cptr) {
1576 if (alloc) {
1577 if (*alloc == SWIG_NEWOBJ) {
1578 *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1579 } else {
1580 *cptr = cstr;
1581 *alloc = SWIG_OLDOBJ;
1582 }
1583 }
1584 }
1585 if (psize) *psize = size;
1586 return SWIG_OK;
1587 } else {
1588 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1589 if (pchar_descriptor) {
1590 void* vptr = 0;
1591 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
1592 if (cptr) *cptr = (char *)vptr;
1593 if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
1594 if (alloc) *alloc = SWIG_OLDOBJ;
1595 return SWIG_OK;
1596 }
1597 }
1598 }
1599 return SWIG_TypeError;
1600}
1601
1602
1603
1604
1605SWIGINTERN VALUE
1606_wrap_occurrences(int argc, VALUE *argv, VALUE self) {
1607 VALUE arg1 = (VALUE) 0 ;
1608 VALUE arg2 = (VALUE) 0 ;
1609 char *arg3 = (char *) 0 ;
1610 VALUE result;
1611 int res3 ;
1612 char *buf3 = 0 ;
1613 int alloc3 = 0 ;
1614 VALUE vresult = Qnil;
1615
1616 if ((argc < 3) || (argc > 3)) {
1617 rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
1618 }
1619 arg1 = argv[0];
1620 arg2 = argv[1];
1621 res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
1622 if (!SWIG_IsOK(res3)) {
1623 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "occurrences" "', argument " "3"" of type '" "char *""'");
1624 }
1625 arg3 = (char *)(buf3);
1626 result = (VALUE)occurrences(arg1,arg2,arg3);
1627 vresult = result;
1628 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
1629 return vresult;
1630fail:
1631 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
1632 return Qnil;
1633}
1634
1635
1636SWIGINTERN VALUE
1637_wrap_duration_to_fixnum(int argc, VALUE *argv, VALUE self) {
1638 char *arg1 = (char *) 0 ;
1639 VALUE result;
1640 int res1 ;
1641 char *buf1 = 0 ;
1642 int alloc1 = 0 ;
1643 VALUE vresult = Qnil;
1644
1645 if ((argc < 1) || (argc > 1)) {
1646 rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
1647 }
1648 res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
1649 if (!SWIG_IsOK(res1)) {
1650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duration_to_fixnum" "', argument " "1"" of type '" "char *""'");
1651 }
1652 arg1 = (char *)(buf1);
1653 result = (VALUE)duration_to_fixnum(arg1);
1654 vresult = result;
1655 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1656 return vresult;
1657fail:
1658 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1659 return Qnil;
1660}
1661
1662
1663
1664/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
1665
1666static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
1667
1668static swig_type_info *swig_type_initial[] = {
1669 &_swigt__p_char,
1670};
1671
1672static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
1673
1674static swig_cast_info *swig_cast_initial[] = {
1675 _swigc__p_char,
1676};
1677
1678
1679/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
1680
1681/* -----------------------------------------------------------------------------
1682 * Type initialization:
1683 * This problem is tough by the requirement that no dynamic
1684 * memory is used. Also, since swig_type_info structures store pointers to
1685 * swig_cast_info structures and swig_cast_info structures store pointers back
1686 * to swig_type_info structures, we need some lookup code at initialization.
1687 * The idea is that swig generates all the structures that are needed.
1688 * The runtime then collects these partially filled structures.
1689 * The SWIG_InitializeModule function takes these initial arrays out of
1690 * swig_module, and does all the lookup, filling in the swig_module.types
1691 * array with the correct data and linking the correct swig_cast_info
1692 * structures together.
1693 *
1694 * The generated swig_type_info structures are assigned staticly to an initial
1695 * array. We just loop through that array, and handle each type individually.
1696 * First we lookup if this type has been already loaded, and if so, use the
1697 * loaded structure instead of the generated one. Then we have to fill in the
1698 * cast linked list. The cast data is initially stored in something like a
1699 * two-dimensional array. Each row corresponds to a type (there are the same
1700 * number of rows as there are in the swig_type_initial array). Each entry in
1701 * a column is one of the swig_cast_info structures for that type.
1702 * The cast_initial array is actually an array of arrays, because each row has
1703 * a variable number of columns. So to actually build the cast linked list,
1704 * we find the array of casts associated with the type, and loop through it
1705 * adding the casts to the list. The one last trick we need to do is making
1706 * sure the type pointer in the swig_cast_info struct is correct.
1707 *
1708 * First off, we lookup the cast->type name to see if it is already loaded.
1709 * There are three cases to handle:
1710 * 1) If the cast->type has already been loaded AND the type we are adding
1711 * casting info to has not been loaded (it is in this module), THEN we
1712 * replace the cast->type pointer with the type pointer that has already
1713 * been loaded.
1714 * 2) If BOTH types (the one we are adding casting info to, and the
1715 * cast->type) are loaded, THEN the cast info has already been loaded by
1716 * the previous module so we just ignore it.
1717 * 3) Finally, if cast->type has not already been loaded, then we add that
1718 * swig_cast_info to the linked list (because the cast->type) pointer will
1719 * be correct.
1720 * ----------------------------------------------------------------------------- */
1721
1722#ifdef __cplusplus
1723extern "C" {
1724#if 0
1725} /* c-mode */
1726#endif
1727#endif
1728
1729#if 0
1730#define SWIGRUNTIME_DEBUG
1731#endif
1732
1733
1734SWIGRUNTIME void
1735SWIG_InitializeModule(void *clientdata) {
1736 size_t i;
1737 swig_module_info *module_head, *iter;
1738 int found;
1739
1740 clientdata = clientdata;
1741
1742 /* check to see if the circular list has been setup, if not, set it up */
1743 if (swig_module.next==0) {
1744 /* Initialize the swig_module */
1745 swig_module.type_initial = swig_type_initial;
1746 swig_module.cast_initial = swig_cast_initial;
1747 swig_module.next = &swig_module;
1748 }
1749
1750 /* Try and load any already created modules */
1751 module_head = SWIG_GetModule(clientdata);
1752 if (!module_head) {
1753 /* This is the first module loaded for this interpreter */
1754 /* so set the swig module into the interpreter */
1755 SWIG_SetModule(clientdata, &swig_module);
1756 module_head = &swig_module;
1757 } else {
1758 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
1759 found=0;
1760 iter=module_head;
1761 do {
1762 if (iter==&swig_module) {
1763 found=1;
1764 break;
1765 }
1766 iter=iter->next;
1767 } while (iter!= module_head);
1768
1769 /* if the is found in the list, then all is done and we may leave */
1770 if (found) return;
1771 /* otherwise we must add out module into the list */
1772 swig_module.next = module_head->next;
1773 module_head->next = &swig_module;
1774 }
1775
1776 /* Now work on filling in swig_module.types */
1777#ifdef SWIGRUNTIME_DEBUG
1778 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
1779#endif
1780 for (i = 0; i < swig_module.size; ++i) {
1781 swig_type_info *type = 0;
1782 swig_type_info *ret;
1783 swig_cast_info *cast;
1784
1785#ifdef SWIGRUNTIME_DEBUG
1786 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
1787#endif
1788
1789 /* if there is another module already loaded */
1790 if (swig_module.next != &swig_module) {
1791 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
1792 }
1793 if (type) {
1794 /* Overwrite clientdata field */
1795#ifdef SWIGRUNTIME_DEBUG
1796 printf("SWIG_InitializeModule: found type %s\n", type->name);
1797#endif
1798 if (swig_module.type_initial[i]->clientdata) {
1799 type->clientdata = swig_module.type_initial[i]->clientdata;
1800#ifdef SWIGRUNTIME_DEBUG
1801 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
1802#endif
1803 }
1804 } else {
1805 type = swig_module.type_initial[i];
1806 }
1807
1808 /* Insert casting types */
1809 cast = swig_module.cast_initial[i];
1810 while (cast->type) {
1811
1812 /* Don't need to add information already in the list */
1813 ret = 0;
1814#ifdef SWIGRUNTIME_DEBUG
1815 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
1816#endif
1817 if (swig_module.next != &swig_module) {
1818 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
1819#ifdef SWIGRUNTIME_DEBUG
1820 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
1821#endif
1822 }
1823 if (ret) {
1824 if (type == swig_module.type_initial[i]) {
1825#ifdef SWIGRUNTIME_DEBUG
1826 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
1827#endif
1828 cast->type = ret;
1829 ret = 0;
1830 } else {
1831 /* Check for casting already in the list */
1832 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
1833#ifdef SWIGRUNTIME_DEBUG
1834 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
1835#endif
1836 if (!ocast) ret = 0;
1837 }
1838 }
1839
1840 if (!ret) {
1841#ifdef SWIGRUNTIME_DEBUG
1842 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
1843#endif
1844 if (type->cast) {
1845 type->cast->prev = cast;
1846 cast->next = type->cast;
1847 }
1848 type->cast = cast;
1849 }
1850 cast++;
1851 }
1852 /* Set entry in modules->types array equal to the type */
1853 swig_module.types[i] = type;
1854 }
1855 swig_module.types[i] = 0;
1856
1857#ifdef SWIGRUNTIME_DEBUG
1858 printf("**** SWIG_InitializeModule: Cast List ******\n");
1859 for (i = 0; i < swig_module.size; ++i) {
1860 int j = 0;
1861 swig_cast_info *cast = swig_module.cast_initial[i];
1862 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
1863 while (cast->type) {
1864 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
1865 cast++;
1866 ++j;
1867 }
1868 printf("---- Total casts: %d\n",j);
1869 }
1870 printf("**** SWIG_InitializeModule: Cast List ******\n");
1871#endif
1872}
1873
1874/* This function will propagate the clientdata field of type to
1875* any new swig_type_info structures that have been added into the list
1876* of equivalent types. It is like calling
1877* SWIG_TypeClientData(type, clientdata) a second time.
1878*/
1879SWIGRUNTIME void
1880SWIG_PropagateClientData(void) {
1881 size_t i;
1882 swig_cast_info *equiv;
1883 static int init_run = 0;
1884
1885 if (init_run) return;
1886 init_run = 1;
1887
1888 for (i = 0; i < swig_module.size; i++) {
1889 if (swig_module.types[i]->clientdata) {
1890 equiv = swig_module.types[i]->cast;
1891 while (equiv) {
1892 if (!equiv->converter) {
1893 if (equiv->type && !equiv->type->clientdata)
1894 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
1895 }
1896 equiv = equiv->next;
1897 }
1898 }
1899 }
1900}
1901
1902#ifdef __cplusplus
1903#if 0
1904{ /* c-mode */
1905#endif
1906}
1907#endif
1908
1909
1910#ifdef __cplusplus
1911extern "C"
1912#endif
1913SWIGEXPORT void Init_chaos_calendar(void) {
1914 size_t i;
1915
1916 SWIG_InitRuntime();
1917 mChaos_calendar = rb_define_module("Chaos_calendar");
1918
1919 SWIG_InitializeModule(0);
1920 for (i = 0; i < swig_module.size; i++) {
1921 SWIG_define_class(swig_module.types[i]);
1922 }
1923
1924 SWIG_RubyInitializeTrackings();
1925 rb_define_module_function(mChaos_calendar, "occurrences", _wrap_occurrences, -1);
1926 rb_define_module_function(mChaos_calendar, "duration_to_fixnum", _wrap_duration_to_fixnum, -1);
1927}
1928
diff --git a/lib/chaos_calendar/extconf.rb b/lib/chaos_calendar/extconf.rb
deleted file mode 100644
index 65fe2a0..0000000
--- a/lib/chaos_calendar/extconf.rb
+++ /dev/null
@@ -1,3 +0,0 @@
1require 'mkmf'
2have_library('ical')
3create_makefile('chaos_calendar')
diff --git a/lib/chaos_calendar/gen.sh b/lib/chaos_calendar/gen.sh
deleted file mode 100755
index f588af6..0000000
--- a/lib/chaos_calendar/gen.sh
+++ /dev/null
@@ -1,6 +0,0 @@
1#!/bin/sh
2
3rm -f Makefile *.o *wrap.c*
4swig -ruby chaos_calendar.i
5ruby extconf.rb
6make
diff --git a/lib/chaos_calendar/ical_occurrences.c b/lib/chaos_calendar/ical_occurrences.c
deleted file mode 100644
index 30a8d85..0000000
--- a/lib/chaos_calendar/ical_occurrences.c
+++ /dev/null
@@ -1,76 +0,0 @@
1#include <ruby.h>
2#include <libical/ical.h>
3#include <time.h>
4
5//#define RRULE "FREQ=MONTHLY;BYMONTH=1,2,3,4,5,6,7,8,9,10,11;BYDAY=-1WE;UNTIL=20091105T220000"
6//#define RRULE "FREQ=DAILY;UNTIL=20991111T220000;VFOO"
7
8VALUE occurrences( VALUE dtstart, VALUE dtend, char *rrule ) {
9 struct icaltimetype start, end;
10 time_t tt;
11 VALUE tv_sec, occurr = rb_ary_new();
12
13 /* Get method ID for Time.tv_sec */
14 ID time_tv_sec = rb_intern( "tv_sec" );
15 ID time_to_time = rb_intern( "to_time" );
16
17 if( !rb_respond_to( dtstart, time_tv_sec ) ) {
18 if( rb_respond_to( dtstart, time_to_time ) )
19 dtstart = rb_funcall( dtstart, time_to_time, 0 );
20 else
21 rb_raise( rb_eTypeError, "Can't convert dtstart into a Time-like object." );
22 }
23
24 if( !rb_respond_to( dtend, time_tv_sec ) ) {
25 if( rb_respond_to( dtend, time_to_time ) )
26 dtend = rb_funcall( dtend, time_to_time, 0 );
27 else
28 rb_raise( rb_eTypeError, "Can't convert dtend into a Time-like object." );
29 }
30
31 /* Apply .tv_sec to our Time objects (if they are Times ...) */
32 tv_sec = rb_funcall( dtstart, time_tv_sec, 0 );
33 tt = NUM2INT( tv_sec );
34 start = icaltime_from_timet( tt, 0 );
35
36 tv_sec = rb_funcall( dtend, time_tv_sec, 0 );
37 tt = NUM2INT( tv_sec );
38 end = icaltime_from_timet( tt, 0 );
39
40 icalerror_clear_errno();
41 icalerror_set_error_state( ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL);
42
43 struct icalrecurrencetype recur = icalrecurrencetype_from_string( rrule );
44 if( icalerrno != ICAL_NO_ERROR ) {
45 rb_raise(rb_eArgError, "Malformed RRule");
46 return Qnil;
47 }
48
49 icalrecur_iterator* ritr = icalrecur_iterator_new( recur, start );
50
51 while(1) {
52 struct icaltimetype next = icalrecur_iterator_next(ritr);
53
54 if( icaltime_is_null_time(next) || ( icaltime_compare( next, end ) > 0 ) ) {
55 icalrecur_iterator_free(ritr);
56 return occurr;
57 }
58
59 rb_ary_push( occurr, rb_time_new( icaltime_as_timet( next ), 0 ) );
60 };
61
62 icalrecur_iterator_free(ritr);
63 return occurr;
64}
65
66VALUE duration_to_fixnum( char * duration ) {
67 icalerror_clear_errno();
68 icalerror_set_error_state( ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL);
69
70 struct icaldurationtype dur_struct = icaldurationtype_from_string( duration );
71
72 if( icaldurationtype_is_bad_duration( dur_struct ) )
73 rb_raise(rb_eArgError, "Malformed Duration");
74
75 return LONG2FIX(icaldurationtype_as_int( dur_struct ));
76}
diff --git a/lib/chaos_calendar/ical_occurrences.i b/lib/chaos_calendar/ical_occurrences.i
deleted file mode 100644
index 1e91701..0000000
--- a/lib/chaos_calendar/ical_occurrences.i
+++ /dev/null
@@ -1,6 +0,0 @@
1%module ical_occurrences
2
3%inline {
4 VALUE occurrences( VALUE dtstart, VALUE dtend, char * rrule );
5 VALUE duration_to_fixnum( char * duration );
6}
generated by cgit v1.3 (git 2.53.0) at 2026-07-01 18:33:35 +0000