Implemented enough functionality to actually execute Python from within
[blender.git] / source / blender / python / api2_2x / Blender_wrap.c
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 1.3.10u-20030216-1639
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 SWIGPYTHON
12 /***********************************************************************
13  * common.swg
14  *
15  *     This file contains generic SWIG runtime support for pointer
16  *     type checking as well as a few commonly used macros to control
17  *     external linkage.
18  *
19  * Author : David Beazley (beazley@cs.uchicago.edu)
20  *
21  * Copyright (c) 1999-2000, The University of Chicago
22  * 
23  * This file may be freely redistributed without license or fee provided
24  * this copyright message remains intact.
25  ************************************************************************/
26
27 #include <string.h>
28
29 #if defined(_WIN32) || defined(__WIN32__)
30 #       if defined(_MSC_VER)
31 #               if defined(STATIC_LINKED)
32 #                       define SWIGEXPORT(a) a
33 #               else
34 #                       define SWIGEXPORT(a) __declspec(dllexport) a
35 #               endif
36 #       else
37 #               if defined(__BORLANDC__)
38 #                       define SWIGEXPORT(a) a _export
39 #               else
40 #                       define SWIGEXPORT(a) a
41 #       endif
42 #endif
43 #else
44 #       define SWIGEXPORT(a) a
45 #endif
46
47 #ifdef SWIG_GLOBAL
48 #define SWIGRUNTIME(a) SWIGEXPORT(a)
49 #else
50 #define SWIGRUNTIME(a) static a
51 #endif
52
53
54
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58
59 typedef void *(*swig_converter_func)(void *);
60
61 typedef struct swig_type_info {
62   const char             *name;                 
63   swig_converter_func     converter;
64   const char             *str;
65   struct swig_type_info  *next;
66   struct swig_type_info  *prev;
67   void                   *clientdata;   
68 } swig_type_info;
69
70 #ifdef SWIG_NOINCLUDE
71 SWIGEXPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
72 SWIGEXPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
73 SWIGEXPORT(void *) SWIG_TypeCast(swig_type_info *, void *);
74 SWIGEXPORT(swig_type_info *) SWIG_TypeQuery(const char *);
75 SWIGEXPORT(void) SWIG_TypeClientData(swig_type_info *, void *);
76 #else
77
78 static swig_type_info *swig_type_list = 0;
79
80 /* Register a type mapping with the type-checking */
81 SWIGRUNTIME(swig_type_info *)
82 SWIG_TypeRegister(swig_type_info *ti)
83 {
84   swig_type_info *tc, *head, *ret, *next;
85   /* Check to see if this type has already been registered */
86   tc = swig_type_list;
87   while (tc) {
88     if (strcmp(tc->name, ti->name) == 0) {
89       /* Already exists in the table.  Just add additional types to the list */
90       head = tc;
91       next = tc->next;
92       goto l1;
93     }
94     tc = tc->prev;
95   }
96   head = ti;
97   next = 0;
98
99   /* Place in list */
100   ti->prev = swig_type_list;
101   swig_type_list = ti;
102
103   /* Build linked lists */
104  l1:
105   ret = head;
106   tc = ti + 1;
107   /* Patch up the rest of the links */
108   while (tc->name) {
109     head->next = tc;
110     tc->prev = head;
111     head = tc;
112     tc++;
113   }
114   head->next = next;
115   return ret;
116 }
117
118 /* Check the typename */
119 SWIGRUNTIME(swig_type_info *) 
120 SWIG_TypeCheck(char *c, swig_type_info *ty)
121 {
122   swig_type_info *s;
123   if (!ty) return 0;        /* Void pointer */
124   s = ty->next;             /* First element always just a name */
125   while (s) {
126     if (strcmp(s->name,c) == 0) {
127       if (s == ty->next) return s;
128       /* Move s to the top of the linked list */
129       s->prev->next = s->next;
130       if (s->next) {
131         s->next->prev = s->prev;
132       }
133       /* Insert s as second element in the list */
134       s->next = ty->next;
135       if (ty->next) ty->next->prev = s;
136       ty->next = s;
137       return s;
138     }
139     s = s->next;
140   }
141   return 0;
142 }
143
144 /* Cast a pointer (needed for C++ inheritance */
145 SWIGRUNTIME(void *) 
146 SWIG_TypeCast(swig_type_info *ty, void *ptr) 
147 {
148   if ((!ty) || (!ty->converter)) return ptr;
149   return (*ty->converter)(ptr);
150 }
151
152 /* Search for a swig_type_info structure */
153 SWIGRUNTIME(swig_type_info *)
154 SWIG_TypeQuery(const char *name) {
155   swig_type_info *ty = swig_type_list;
156   while (ty) {
157     if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
158     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
159     ty = ty->prev;
160   }
161   return 0;
162 }
163
164 /* Set the clientdata field for a type */
165 SWIGRUNTIME(void)
166 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
167   swig_type_info *tc, *equiv;
168   if (ti->clientdata) return;
169   ti->clientdata = clientdata;
170   equiv = ti->next;
171   while (equiv) {
172     if (!equiv->converter) {
173       tc = swig_type_list;
174       while (tc) {
175         if ((strcmp(tc->name, equiv->name) == 0))
176           SWIG_TypeClientData(tc,clientdata);
177         tc = tc->prev;
178       }
179     }
180     equiv = equiv->next;
181   }
182 }
183 #endif
184
185 #ifdef __cplusplus
186 }
187 #endif
188
189
190
191
192 /***********************************************************************
193  * python.swg
194  *
195  *     This file contains the runtime support for Python modules
196  *     and includes code for managing global variables and pointer
197  *     type checking.
198  *
199  * Author : David Beazley (beazley@cs.uchicago.edu)
200  ************************************************************************/
201
202 #include <stdlib.h>
203 #include "Python.h"
204
205 #ifdef __cplusplus
206 extern "C" {
207 #endif
208
209 #define SWIG_PY_INT     1
210 #define SWIG_PY_FLOAT   2
211 #define SWIG_PY_STRING  3
212 #define SWIG_PY_POINTER 4
213 #define SWIG_PY_BINARY  5
214
215 /* Constant information structure */
216 typedef struct swig_const_info {
217     int type;
218     char *name;
219     long lvalue;
220     double dvalue;
221     void   *pvalue;
222     swig_type_info **ptype;
223 } swig_const_info;
224
225 #ifdef SWIG_NOINCLUDE
226
227 SWIGEXPORT(PyObject *)        SWIG_newvarlink();
228 SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
229 SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
230 SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
231 SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
232 SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
233 SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
234 SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
235 SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
236 SWIGEXPORT(PyObject *)        SWIG_MakeShadow(PyObject *robj, swig_type_info *type, int own);
237 #else
238
239 /* -----------------------------------------------------------------------------
240  * global variable support code.
241  * ----------------------------------------------------------------------------- */
242
243 typedef struct swig_globalvar {   
244   char       *name;                  /* Name of global variable */
245   PyObject *(*get_attr)(void);       /* Return the current value */
246   int       (*set_attr)(PyObject *); /* Set the value */
247   struct swig_globalvar *next;
248 } swig_globalvar;
249
250 typedef struct swig_varlinkobject {
251   PyObject_HEAD
252   swig_globalvar *vars;
253 } swig_varlinkobject;
254
255 static PyObject *
256 swig_varlink_repr(swig_varlinkobject *v) {
257   v = v;
258   return PyString_FromString("<Global variables>");
259 }
260
261 static int
262 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
263   swig_globalvar  *var;
264   flags = flags;
265   fprintf(fp,"Global variables { ");
266   for (var = v->vars; var; var=var->next) {
267     fprintf(fp,"%s", var->name);
268     if (var->next) fprintf(fp,", ");
269   }
270   fprintf(fp," }\n");
271   return 0;
272 }
273
274 static PyObject *
275 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
276   swig_globalvar *var = v->vars;
277   while (var) {
278     if (strcmp(var->name,n) == 0) {
279       return (*var->get_attr)();
280     }
281     var = var->next;
282   }
283   PyErr_SetString(PyExc_NameError,"Unknown C global variable");
284   return NULL;
285 }
286
287 static int
288 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
289   swig_globalvar *var = v->vars;
290   while (var) {
291     if (strcmp(var->name,n) == 0) {
292       return (*var->set_attr)(p);
293     }
294     var = var->next;
295   }
296   PyErr_SetString(PyExc_NameError,"Unknown C global variable");
297   return 1;
298 }
299
300 statichere PyTypeObject varlinktype = {
301   PyObject_HEAD_INIT(0)              
302   0,
303   (char *)"swigvarlink",                      /* Type name    */
304   sizeof(swig_varlinkobject),         /* Basic size   */
305   0,                                  /* Itemsize     */
306   0,                                  /* Deallocator  */ 
307   (printfunc) swig_varlink_print,     /* Print        */
308   (getattrfunc) swig_varlink_getattr, /* get attr     */
309   (setattrfunc) swig_varlink_setattr, /* Set attr     */
310   0,                                  /* tp_compare   */
311   (reprfunc) swig_varlink_repr,       /* tp_repr      */    
312   0,                                  /* tp_as_number */
313   0,                                  /* tp_as_mapping*/
314   0,                                  /* tp_hash      */
315 };
316
317 /* Create a variable linking object for use later */
318 SWIGRUNTIME(PyObject *)
319 SWIG_newvarlink(void) {
320   swig_varlinkobject *result = 0;
321   result = PyMem_NEW(swig_varlinkobject,1);
322   varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
323   result->ob_type = &varlinktype;
324   result->vars = 0;
325   result->ob_refcnt = 0;
326   Py_XINCREF((PyObject *) result);
327   return ((PyObject*) result);
328 }
329
330 SWIGRUNTIME(void)
331 SWIG_addvarlink(PyObject *p, char *name,
332            PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
333   swig_varlinkobject *v;
334   swig_globalvar *gv;
335   v= (swig_varlinkobject *) p;
336   gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
337   gv->name = (char *) malloc(strlen(name)+1);
338   strcpy(gv->name,name);
339   gv->get_attr = get_attr;
340   gv->set_attr = set_attr;
341   gv->next = v->vars;
342   v->vars = gv;
343 }
344
345 /* Pack binary data into a string */
346 SWIGRUNTIME(char *)
347 SWIG_PackData(char *c, void *ptr, int sz) {
348   static char hex[17] = "0123456789abcdef";
349   int i;
350   unsigned char *u = (unsigned char *) ptr;
351   register unsigned char uu;
352   for (i = 0; i < sz; i++,u++) {
353     uu = *u;
354     *(c++) = hex[(uu & 0xf0) >> 4];
355     *(c++) = hex[uu & 0xf];
356   }
357   return c;
358 }
359
360 /* Unpack binary data from a string */
361 SWIGRUNTIME(char *)
362 SWIG_UnpackData(char *c, void *ptr, int sz) {
363   register unsigned char uu;
364   register int d;
365   unsigned char *u = (unsigned char *) ptr;
366   int i;
367   for (i = 0; i < sz; i++, u++) {
368     d = *(c++);
369     if ((d >= '0') && (d <= '9'))
370       uu = ((d - '0') << 4);
371     else if ((d >= 'a') && (d <= 'f'))
372       uu = ((d - ('a'-10)) << 4);
373     d = *(c++);
374     if ((d >= '0') && (d <= '9'))
375       uu |= (d - '0');
376     else if ((d >= 'a') && (d <= 'f'))
377       uu |= (d - ('a'-10));
378     *u = uu;
379   }
380   return c;
381 }
382
383 /* Convert a pointer value */
384 SWIGRUNTIME(int)
385 SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
386   swig_type_info *tc;
387   char  *c;
388   static PyObject *SWIG_this = 0;
389   int    newref = 0;
390
391   if (!obj) return 0;
392   if (obj == Py_None) {
393     *ptr = 0;
394     return 0;
395   }
396 #ifdef SWIG_COBJECT_TYPES
397   if (!(PyCObject_Check(obj))) {
398     if (!SWIG_this)
399       SWIG_this = PyString_InternFromString("this");
400     obj = PyObject_GetAttr(obj,SWIG_this);
401     newref = 1;
402     if (!obj) goto type_error;
403     if (!PyCObject_Check(obj)) {
404       Py_DECREF(obj);
405       goto type_error;
406     }
407   } 
408   *ptr = PyCObject_AsVoidPtr(obj);
409   c = (char *) PyCObject_GetDesc(obj);
410   if (newref) Py_DECREF(obj);
411   goto cobject;
412 #else
413   if (!(PyString_Check(obj))) {
414     if (!SWIG_this)
415       SWIG_this = PyString_InternFromString("this");
416     obj = PyObject_GetAttr(obj,SWIG_this);
417     newref = 1;
418     if (!obj) goto type_error;
419     if (!PyString_Check(obj)) {
420       Py_DECREF(obj);
421       goto type_error;
422     }
423   } 
424   c = PyString_AsString(obj);
425   /* Pointer values must start with leading underscore */
426   if (*c != '_') {
427     *ptr = (void *) 0;
428     if (strcmp(c,"NULL") == 0) {
429       if (newref) Py_DECREF(obj);
430       return 0;
431     } else {
432       if (newref) Py_DECREF(obj);
433       goto type_error;
434     }
435   }
436   c++;
437   c = SWIG_UnpackData(c,ptr,sizeof(void *));
438   if (newref) Py_DECREF(obj);
439 #endif
440
441 #ifdef SWIG_COBJECT_TYPES
442 cobject:
443 #endif
444
445   if (ty) {
446     tc = SWIG_TypeCheck(c,ty);
447     if (!tc) goto type_error;
448     *ptr = SWIG_TypeCast(tc,(void*) *ptr);
449   }
450   return 0;
451
452 type_error:
453   if (flags) {
454     if (ty) {
455       char *temp = (char *) malloc(64+strlen(ty->name));
456       sprintf(temp,"Type error. Expected %s", ty->name);
457       PyErr_SetString(PyExc_TypeError, temp);
458       free((char *) temp);
459     } else {
460       PyErr_SetString(PyExc_TypeError,"Expected a pointer");
461     }
462   }
463   return -1;
464 }
465
466 /* Convert a packed value value */
467 SWIGRUNTIME(int)
468 SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
469   swig_type_info *tc;
470   char  *c;
471
472   if ((!obj) || (!PyString_Check(obj))) goto type_error;
473   c = PyString_AsString(obj);
474   /* Pointer values must start with leading underscore */
475   if (*c != '_') goto type_error;
476   c++;
477   c = SWIG_UnpackData(c,ptr,sz);
478   if (ty) {
479     tc = SWIG_TypeCheck(c,ty);
480     if (!tc) goto type_error;
481   }
482   return 0;
483
484 type_error:
485
486   if (flags) {
487     if (ty) {
488       char *temp = (char *) malloc(64+strlen(ty->name));
489       sprintf(temp,"Type error. Expected %s", ty->name);
490       PyErr_SetString(PyExc_TypeError, temp);
491       free((char *) temp);
492     } else {
493       PyErr_SetString(PyExc_TypeError,"Expected a pointer");
494     }
495   }
496   return -1;
497 }
498
499 /* Create a new pointer object */
500 SWIGRUNTIME(PyObject *)
501 SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
502   PyObject *robj;
503   if (!ptr) {
504     Py_INCREF(Py_None);
505     return Py_None;
506   }
507 #ifdef SWIG_COBJECT_TYPES
508   robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
509 #else
510   {
511     char result[512];
512     char *r = result;
513     *(r++) = '_';
514     r = SWIG_PackData(r,&ptr,sizeof(void *));
515     strcpy(r,type->name);
516     robj = PyString_FromString(result);
517   }
518 #endif
519   if (!robj || (robj == Py_None)) return robj;
520   if (type->clientdata) {
521     PyObject *inst;
522     PyObject *args = Py_BuildValue((char*)"(O)", robj);
523     Py_DECREF(robj);
524     inst = PyObject_CallObject((PyObject *) type->clientdata, args);
525     Py_DECREF(args);
526     if (own) {
527       PyObject *n = PyInt_FromLong(1);
528       PyObject_SetAttrString(inst,(char*)"thisown",n);
529       Py_DECREF(n);
530     }
531     robj = inst;
532   }
533   return robj;
534 }
535
536 SWIGRUNTIME(PyObject *)
537 SWIG_MakeShadow(PyObject *robj, swig_type_info *type, int own) {
538   if (!robj || (robj == Py_None)) return robj;
539   if (type->clientdata) {
540     PyInstanceObject *inst;
541     inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
542     if (!inst) return robj;
543     inst->in_dict = PyDict_New();
544     inst->in_class = (PyClassObject *) type->clientdata;
545     Py_INCREF(inst->in_class);
546     PyObject_SetAttrString((PyObject *)inst,(char*)"this",robj);
547     Py_DECREF(robj);
548     if (own) {
549       PyObject *n = PyInt_FromLong(1);
550       PyObject_SetAttrString((PyObject *)inst,(char*)"thisown",n);
551       Py_DECREF(n);
552     }
553     robj = (PyObject *) inst;
554     Py_INCREF(robj);
555   }
556   return robj;
557 }
558
559 SWIGRUNTIME(PyObject *)
560 SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
561   char result[1024];
562   char *r = result;
563   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
564   *(r++) = '_';
565   r = SWIG_PackData(r,ptr,sz);
566   strcpy(r,type->name);
567   return PyString_FromString(result);
568 }
569
570 /* Install Constants */
571 SWIGRUNTIME(void)
572 SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
573   int i;
574   PyObject *obj;
575   for (i = 0; constants[i].type; i++) {
576     switch(constants[i].type) {
577     case SWIG_PY_INT:
578       obj = PyInt_FromLong(constants[i].lvalue);
579       break;
580     case SWIG_PY_FLOAT:
581       obj = PyFloat_FromDouble(constants[i].dvalue);
582       break;
583     case SWIG_PY_STRING:
584       obj = PyString_FromString((char *) constants[i].pvalue);
585       break;
586     case SWIG_PY_POINTER:
587       obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
588       break;
589     case SWIG_PY_BINARY:
590       obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
591       break;
592     default:
593       obj = 0;
594       break;
595     }
596     if (obj) {
597       PyDict_SetItemString(d,constants[i].name,obj);
598       Py_DECREF(obj);
599     }
600   }
601 }
602
603 #endif
604
605 #ifdef __cplusplus
606 }
607 #endif
608
609
610
611
612
613
614
615
616 /* -------- TYPES TABLE (BEGIN) -------- */
617
618 static swig_type_info *swig_types[1];
619
620 /* -------- TYPES TABLE (END) -------- */
621
622 #define SWIG_init    initBlender
623
624 #define SWIG_name    "Blender"
625 #ifdef __cplusplus
626 extern "C" {
627 #endif
628 static PyObject *_wrap_copy(PyObject *self, PyObject *args) {
629     PyObject *resultobj;
630     
631     if(!PyArg_ParseTuple(args,(char *)":copy")) return NULL;
632     BlenderCopy();
633     
634     Py_INCREF(Py_None); resultobj = Py_None;
635     return resultobj;
636 }
637
638
639 static PyMethodDef SwigMethods[] = {
640          { (char *)"copy", _wrap_copy, METH_VARARGS },
641          { NULL, NULL }
642 };
643
644
645 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
646
647
648 static swig_type_info *swig_types_initial[] = {
649 0
650 };
651
652
653 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
654
655 static swig_const_info swig_const_table[] = {
656 {0}};
657
658 #ifdef __cplusplus
659 }
660 #endif
661
662 #ifdef __cplusplus
663 extern "C"
664 #endif
665 SWIGEXPORT(void) SWIG_init(void) {
666     static PyObject *SWIG_globals = 0;
667     PyObject *m, *d;
668     int       i;
669     SWIG_globals = SWIG_newvarlink();
670     m = Py_InitModule((char *) SWIG_name, SwigMethods);
671     d = PyModule_GetDict(m);
672         PyDict_SetItemString (d, "Object", initObject());
673     
674     for (i = 0; swig_types_initial[i]; i++) {
675         swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
676     }
677     SWIG_InstallConstants(d,swig_const_table);
678     
679 }
680