UI: Remove "Show Frame Indicator" option
[blender.git] / source / blender / makesrna / intern / makesrna.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <float.h>
22 #include <limits.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_utildefines.h"
31
32 #include "RNA_define.h"
33 #include "RNA_types.h"
34 #include "RNA_enum_types.h"
35
36 #include "rna_internal.h"
37
38 #ifdef _WIN32
39 #  ifndef snprintf
40 #    define snprintf _snprintf
41 #  endif
42 #endif
43
44 #include "CLG_log.h"
45
46 static CLG_LogRef LOG = {"makesrna"};
47
48 /**
49  * Variable to control debug output of makesrna.
50  * debugSRNA:
51  * - 0 = no output, except errors
52  * - 1 = detail actions
53  */
54 static int debugSRNA = 0;
55
56 /* stub for BLI_abort() */
57 #ifndef NDEBUG
58 void BLI_system_backtrace(FILE *fp)
59 {
60   (void)fp;
61 }
62 #endif
63
64 /* Replace if different */
65 #define TMP_EXT ".tmp"
66
67 /* copied from BLI_file_older */
68 #include <sys/stat.h>
69 static int file_older(const char *file1, const char *file2)
70 {
71   struct stat st1, st2;
72   if (debugSRNA > 0) {
73     printf("compare: %s %s\n", file1, file2);
74   }
75
76   if (stat(file1, &st1)) {
77     return 0;
78   }
79   if (stat(file2, &st2)) {
80     return 0;
81   }
82
83   return (st1.st_mtime < st2.st_mtime);
84 }
85 static const char *makesrna_path = NULL;
86
87 /* forward declarations */
88 static void rna_generate_static_parameter_prototypes(FILE *f,
89                                                      StructRNA *srna,
90                                                      FunctionDefRNA *dfunc,
91                                                      const char *name_override,
92                                                      int close_prototype);
93
94 /* helpers */
95 #define WRITE_COMMA \
96   { \
97     if (!first) \
98       fprintf(f, ", "); \
99     first = 0; \
100   } \
101   (void)0
102
103 #define WRITE_PARAM(param) \
104   { \
105     WRITE_COMMA; \
106     fprintf(f, param); \
107   } \
108   (void)0
109
110 static int replace_if_different(const char *tmpfile, const char *dep_files[])
111 {
112   /* return 0;  */ /* use for testing had edited rna */
113
114 #define REN_IF_DIFF \
115   { \
116     FILE *file_test = fopen(orgfile, "rb"); \
117     if (file_test) { \
118       fclose(file_test); \
119       if (fp_org) \
120         fclose(fp_org); \
121       if (fp_new) \
122         fclose(fp_new); \
123       if (remove(orgfile) != 0) { \
124         CLOG_ERROR(&LOG, "remove error (%s): \"%s\"", strerror(errno), orgfile); \
125         return -1; \
126       } \
127     } \
128   } \
129   if (rename(tmpfile, orgfile) != 0) { \
130     CLOG_ERROR(&LOG, "rename error (%s): \"%s\" -> \"%s\"", strerror(errno), tmpfile, orgfile); \
131     return -1; \
132   } \
133   remove(tmpfile); \
134   return 1
135
136   /* end REN_IF_DIFF */
137
138   FILE *fp_new = NULL, *fp_org = NULL;
139   int len_new, len_org;
140   char *arr_new, *arr_org;
141   int cmp;
142
143   char orgfile[4096];
144
145   strcpy(orgfile, tmpfile);
146   orgfile[strlen(orgfile) - strlen(TMP_EXT)] = '\0'; /* strip '.tmp' */
147
148   fp_org = fopen(orgfile, "rb");
149
150   if (fp_org == NULL) {
151     REN_IF_DIFF;
152   }
153
154   /* XXX, trick to work around dependency problem
155    * assumes dep_files is in the same dir as makesrna.c, which is true for now. */
156
157   if (1) {
158     /* first check if makesrna.c is newer then generated files
159      * for development on makesrna.c you may want to disable this */
160     if (file_older(orgfile, __FILE__)) {
161       REN_IF_DIFF;
162     }
163
164     if (file_older(orgfile, makesrna_path)) {
165       REN_IF_DIFF;
166     }
167
168     /* now check if any files we depend on are newer then any generated files */
169     if (dep_files) {
170       int pass;
171       for (pass = 0; dep_files[pass]; pass++) {
172         char from_path[4096] = __FILE__;
173         char *p1, *p2;
174
175         /* dir only */
176         p1 = strrchr(from_path, '/');
177         p2 = strrchr(from_path, '\\');
178         strcpy((p1 > p2 ? p1 : p2) + 1, dep_files[pass]);
179         /* account for build deps, if makesrna.c (this file) is newer */
180         if (file_older(orgfile, from_path)) {
181           REN_IF_DIFF;
182         }
183       }
184     }
185   }
186   /* XXX end dep trick */
187
188   fp_new = fopen(tmpfile, "rb");
189
190   if (fp_new == NULL) {
191     /* shouldn't happen, just to be safe */
192     CLOG_ERROR(&LOG, "open error: \"%s\"", tmpfile);
193     fclose(fp_org);
194     return -1;
195   }
196
197   fseek(fp_new, 0L, SEEK_END);
198   len_new = ftell(fp_new);
199   fseek(fp_new, 0L, SEEK_SET);
200   fseek(fp_org, 0L, SEEK_END);
201   len_org = ftell(fp_org);
202   fseek(fp_org, 0L, SEEK_SET);
203
204   if (len_new != len_org) {
205     fclose(fp_new);
206     fp_new = NULL;
207     fclose(fp_org);
208     fp_org = NULL;
209     REN_IF_DIFF;
210   }
211
212   /* now compare the files... */
213   arr_new = MEM_mallocN(sizeof(char) * len_new, "rna_cmp_file_new");
214   arr_org = MEM_mallocN(sizeof(char) * len_org, "rna_cmp_file_org");
215
216   if (fread(arr_new, sizeof(char), len_new, fp_new) != len_new) {
217     CLOG_ERROR(&LOG, "unable to read file %s for comparison.", tmpfile);
218   }
219   if (fread(arr_org, sizeof(char), len_org, fp_org) != len_org) {
220     CLOG_ERROR(&LOG, "unable to read file %s for comparison.", orgfile);
221   }
222
223   fclose(fp_new);
224   fp_new = NULL;
225   fclose(fp_org);
226   fp_org = NULL;
227
228   cmp = memcmp(arr_new, arr_org, len_new);
229
230   MEM_freeN(arr_new);
231   MEM_freeN(arr_org);
232
233   if (cmp) {
234     REN_IF_DIFF;
235   }
236   else {
237     remove(tmpfile);
238     return 0;
239   }
240
241 #undef REN_IF_DIFF
242 }
243
244 /* Helper to solve keyword problems with C/C++ */
245
246 static const char *rna_safe_id(const char *id)
247 {
248   if (STREQ(id, "default")) {
249     return "default_value";
250   }
251   else if (STREQ(id, "operator")) {
252     return "operator_value";
253   }
254   else if (STREQ(id, "new")) {
255     return "create";
256   }
257   else if (STREQ(id, "co_return")) {
258     /* MSVC2015, C++ uses for coroutines */
259     return "coord_return";
260   }
261
262   return id;
263 }
264
265 /* Sorting */
266
267 static int cmp_struct(const void *a, const void *b)
268 {
269   const StructRNA *structa = *(const StructRNA **)a;
270   const StructRNA *structb = *(const StructRNA **)b;
271
272   return strcmp(structa->identifier, structb->identifier);
273 }
274
275 static int cmp_property(const void *a, const void *b)
276 {
277   const PropertyRNA *propa = *(const PropertyRNA **)a;
278   const PropertyRNA *propb = *(const PropertyRNA **)b;
279
280   if (STREQ(propa->identifier, "rna_type")) {
281     return -1;
282   }
283   else if (STREQ(propb->identifier, "rna_type")) {
284     return 1;
285   }
286
287   if (STREQ(propa->identifier, "name")) {
288     return -1;
289   }
290   else if (STREQ(propb->identifier, "name")) {
291     return 1;
292   }
293
294   return strcmp(propa->name, propb->name);
295 }
296
297 static int cmp_def_struct(const void *a, const void *b)
298 {
299   const StructDefRNA *dsa = *(const StructDefRNA **)a;
300   const StructDefRNA *dsb = *(const StructDefRNA **)b;
301
302   return cmp_struct(&dsa->srna, &dsb->srna);
303 }
304
305 static int cmp_def_property(const void *a, const void *b)
306 {
307   const PropertyDefRNA *dpa = *(const PropertyDefRNA **)a;
308   const PropertyDefRNA *dpb = *(const PropertyDefRNA **)b;
309
310   return cmp_property(&dpa->prop, &dpb->prop);
311 }
312
313 static void rna_sortlist(ListBase *listbase, int (*cmp)(const void *, const void *))
314 {
315   Link *link;
316   void **array;
317   int a, size;
318
319   if (listbase->first == listbase->last) {
320     return;
321   }
322
323   for (size = 0, link = listbase->first; link; link = link->next) {
324     size++;
325   }
326
327   array = MEM_mallocN(sizeof(void *) * size, "rna_sortlist");
328   for (a = 0, link = listbase->first; link; link = link->next, a++) {
329     array[a] = link;
330   }
331
332   qsort(array, size, sizeof(void *), cmp);
333
334   listbase->first = listbase->last = NULL;
335   for (a = 0; a < size; a++) {
336     link = array[a];
337     link->next = link->prev = NULL;
338     rna_addtail(listbase, link);
339   }
340
341   MEM_freeN(array);
342 }
343
344 /* Preprocessing */
345
346 static void rna_print_c_string(FILE *f, const char *str)
347 {
348   static const char *escape[] = {
349       "\''", "\"\"", "\??", "\\\\", "\aa", "\bb", "\ff", "\nn", "\rr", "\tt", "\vv", NULL};
350   int i, j;
351
352   if (!str) {
353     fprintf(f, "NULL");
354     return;
355   }
356
357   fprintf(f, "\"");
358   for (i = 0; str[i]; i++) {
359     for (j = 0; escape[j]; j++) {
360       if (str[i] == escape[j][0]) {
361         break;
362       }
363     }
364
365     if (escape[j]) {
366       fprintf(f, "\\%c", escape[j][1]);
367     }
368     else {
369       fprintf(f, "%c", str[i]);
370     }
371   }
372   fprintf(f, "\"");
373 }
374
375 static void rna_print_data_get(FILE *f, PropertyDefRNA *dp)
376 {
377   if (dp->dnastructfromname && dp->dnastructfromprop) {
378     fprintf(f,
379             "    %s *data = (%s *)(((%s *)ptr->data)->%s);\n",
380             dp->dnastructname,
381             dp->dnastructname,
382             dp->dnastructfromname,
383             dp->dnastructfromprop);
384   }
385   else {
386     fprintf(f, "    %s *data = (%s *)(ptr->data);\n", dp->dnastructname, dp->dnastructname);
387   }
388 }
389
390 static void rna_print_id_get(FILE *f, PropertyDefRNA *UNUSED(dp))
391 {
392   fprintf(f, "    ID *id = ptr->id.data;\n");
393 }
394
395 static void rna_construct_function_name(
396     char *buffer, int size, const char *structname, const char *propname, const char *type)
397 {
398   snprintf(buffer, size, "%s_%s_%s", structname, propname, type);
399 }
400
401 static void rna_construct_wrapper_function_name(
402     char *buffer, int size, const char *structname, const char *propname, const char *type)
403 {
404   if (type == NULL || type[0] == '\0') {
405     snprintf(buffer, size, "%s_%s", structname, propname);
406   }
407   else {
408     snprintf(buffer, size, "%s_%s_%s", structname, propname, type);
409   }
410 }
411
412 static char *rna_alloc_function_name(const char *structname,
413                                      const char *propname,
414                                      const char *type)
415 {
416   AllocDefRNA *alloc;
417   char buffer[2048];
418   char *result;
419
420   rna_construct_function_name(buffer, sizeof(buffer), structname, propname, type);
421   result = MEM_callocN(sizeof(char) * strlen(buffer) + 1, "rna_alloc_function_name");
422   strcpy(result, buffer);
423
424   alloc = MEM_callocN(sizeof(AllocDefRNA), "AllocDefRNA");
425   alloc->mem = result;
426   rna_addtail(&DefRNA.allocs, alloc);
427
428   return result;
429 }
430
431 static StructRNA *rna_find_struct(const char *identifier)
432 {
433   StructDefRNA *ds;
434
435   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
436     if (STREQ(ds->srna->identifier, identifier)) {
437       return ds->srna;
438     }
439   }
440
441   return NULL;
442 }
443
444 static const char *rna_find_type(const char *type)
445 {
446   StructDefRNA *ds;
447
448   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
449     if (ds->dnaname && STREQ(ds->dnaname, type)) {
450       return ds->srna->identifier;
451     }
452   }
453
454   return NULL;
455 }
456
457 static const char *rna_find_dna_type(const char *type)
458 {
459   StructDefRNA *ds;
460
461   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
462     if (STREQ(ds->srna->identifier, type)) {
463       return ds->dnaname;
464     }
465   }
466
467   return NULL;
468 }
469
470 static const char *rna_type_type_name(PropertyRNA *prop)
471 {
472   switch (prop->type) {
473     case PROP_BOOLEAN:
474       return "bool";
475     case PROP_INT:
476     case PROP_ENUM:
477       return "int";
478     case PROP_FLOAT:
479       return "float";
480     case PROP_STRING:
481       if (prop->flag & PROP_THICK_WRAP) {
482         return "char *";
483       }
484       else {
485         return "const char *";
486       }
487     default:
488       return NULL;
489   }
490 }
491
492 static const char *rna_type_type(PropertyRNA *prop)
493 {
494   const char *type;
495
496   type = rna_type_type_name(prop);
497
498   if (type) {
499     return type;
500   }
501
502   return "PointerRNA";
503 }
504
505 static const char *rna_type_struct(PropertyRNA *prop)
506 {
507   const char *type;
508
509   type = rna_type_type_name(prop);
510
511   if (type) {
512     return "";
513   }
514
515   return "struct ";
516 }
517
518 static const char *rna_parameter_type_name(PropertyRNA *parm)
519 {
520   const char *type;
521
522   type = rna_type_type_name(parm);
523
524   if (type) {
525     return type;
526   }
527
528   switch (parm->type) {
529     case PROP_POINTER: {
530       PointerPropertyRNA *pparm = (PointerPropertyRNA *)parm;
531
532       if (parm->flag_parameter & PARM_RNAPTR) {
533         return "PointerRNA";
534       }
535       else {
536         return rna_find_dna_type((const char *)pparm->type);
537       }
538     }
539     case PROP_COLLECTION: {
540       return "CollectionListBase";
541     }
542     default:
543       return "<error, no type specified>";
544   }
545 }
546
547 static int rna_enum_bitmask(PropertyRNA *prop)
548 {
549   EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
550   int a, mask = 0;
551
552   if (eprop->item) {
553     for (a = 0; a < eprop->totitem; a++) {
554       if (eprop->item[a].identifier[0]) {
555         mask |= eprop->item[a].value;
556       }
557     }
558   }
559
560   return mask;
561 }
562
563 static int rna_color_quantize(PropertyRNA *prop, PropertyDefRNA *dp)
564 {
565   return ((prop->type == PROP_FLOAT) &&
566           (prop->subtype == PROP_COLOR || prop->subtype == PROP_COLOR_GAMMA) &&
567           (IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0));
568 }
569
570 static const char *rna_function_string(const void *func)
571 {
572   return (func) ? (const char *)func : "NULL";
573 }
574
575 static void rna_float_print(FILE *f, float num)
576 {
577   if (num == -FLT_MAX) {
578     fprintf(f, "-FLT_MAX");
579   }
580   else if (num == FLT_MAX) {
581     fprintf(f, "FLT_MAX");
582   }
583   else if ((ABS(num) < INT64_MAX) && ((int64_t)num == num)) {
584     fprintf(f, "%.1ff", num);
585   }
586   else {
587     fprintf(f, "%.10ff", num);
588   }
589 }
590
591 static void rna_int_print(FILE *f, int num)
592 {
593   if (num == INT_MIN) {
594     fprintf(f, "INT_MIN");
595   }
596   else if (num == INT_MAX) {
597     fprintf(f, "INT_MAX");
598   }
599   else {
600     fprintf(f, "%d", num);
601   }
602 }
603
604 static char *rna_def_property_get_func(
605     FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
606 {
607   char *func;
608
609   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
610     return NULL;
611   }
612
613   if (!manualfunc) {
614     if (!dp->dnastructname || !dp->dnaname) {
615       CLOG_ERROR(&LOG, "%s.%s has no valid dna info.", srna->identifier, prop->identifier);
616       DefRNA.error = 1;
617       return NULL;
618     }
619
620     /* typecheck,  */
621     if (dp->dnatype && *dp->dnatype) {
622
623       if (prop->type == PROP_FLOAT) {
624         if (IS_DNATYPE_FLOAT_COMPAT(dp->dnatype) == 0) {
625           if (prop->subtype !=
626               PROP_COLOR_GAMMA) { /* colors are an exception. these get translated */
627             CLOG_ERROR(&LOG,
628                        "%s.%s is a '%s' but wrapped as type '%s'.",
629                        srna->identifier,
630                        prop->identifier,
631                        dp->dnatype,
632                        RNA_property_typename(prop->type));
633             DefRNA.error = 1;
634             return NULL;
635           }
636         }
637       }
638       else if (prop->type == PROP_INT || prop->type == PROP_BOOLEAN || prop->type == PROP_ENUM) {
639         if (IS_DNATYPE_INT_COMPAT(dp->dnatype) == 0) {
640           CLOG_ERROR(&LOG,
641                      "%s.%s is a '%s' but wrapped as type '%s'.",
642                      srna->identifier,
643                      prop->identifier,
644                      dp->dnatype,
645                      RNA_property_typename(prop->type));
646           DefRNA.error = 1;
647           return NULL;
648         }
649       }
650     }
651   }
652
653   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get");
654
655   switch (prop->type) {
656     case PROP_STRING: {
657       StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
658       fprintf(f, "void %s(PointerRNA *ptr, char *value)\n", func);
659       fprintf(f, "{\n");
660       if (manualfunc) {
661         fprintf(f, "    %s(ptr, value);\n", manualfunc);
662       }
663       else {
664         const PropertySubType subtype = prop->subtype;
665         const char *string_copy_func = (subtype == PROP_FILEPATH || subtype == PROP_DIRPATH ||
666                                         subtype == PROP_FILENAME || subtype == PROP_BYTESTRING) ?
667                                            "BLI_strncpy" :
668                                            "BLI_strncpy_utf8";
669
670         rna_print_data_get(f, dp);
671
672         if (!(prop->flag & PROP_NEVER_NULL)) {
673           fprintf(f, "    if (data->%s == NULL) {\n", dp->dnaname);
674           fprintf(f, "        *value = '\\0';\n");
675           fprintf(f, "        return;\n");
676           fprintf(f, "    }\n");
677         }
678
679         if (sprop->maxlength) {
680           fprintf(f,
681                   "    %s(value, data->%s, %d);\n",
682                   string_copy_func,
683                   dp->dnaname,
684                   sprop->maxlength);
685         }
686         else {
687           fprintf(f,
688                   "    %s(value, data->%s, sizeof(data->%s));\n",
689                   string_copy_func,
690                   dp->dnaname,
691                   dp->dnaname);
692         }
693       }
694       fprintf(f, "}\n\n");
695       break;
696     }
697     case PROP_POINTER: {
698       fprintf(f, "PointerRNA %s(PointerRNA *ptr)\n", func);
699       fprintf(f, "{\n");
700       if (manualfunc) {
701         fprintf(f, "    return %s(ptr);\n", manualfunc);
702       }
703       else {
704         PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
705         rna_print_data_get(f, dp);
706         if (dp->dnapointerlevel == 0) {
707           fprintf(f,
708                   "    return rna_pointer_inherit_refine(ptr, &RNA_%s, &data->%s);\n",
709                   (const char *)pprop->type,
710                   dp->dnaname);
711         }
712         else {
713           fprintf(f,
714                   "    return rna_pointer_inherit_refine(ptr, &RNA_%s, data->%s);\n",
715                   (const char *)pprop->type,
716                   dp->dnaname);
717         }
718       }
719       fprintf(f, "}\n\n");
720       break;
721     }
722     case PROP_COLLECTION: {
723       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
724
725       fprintf(f, "static PointerRNA %s(CollectionPropertyIterator *iter)\n", func);
726       fprintf(f, "{\n");
727       if (manualfunc) {
728         if (STREQ(manualfunc, "rna_iterator_listbase_get") ||
729             STREQ(manualfunc, "rna_iterator_array_get") ||
730             STREQ(manualfunc, "rna_iterator_array_dereference_get")) {
731           fprintf(f,
732                   "    return rna_pointer_inherit_refine(&iter->parent, &RNA_%s, %s(iter));\n",
733                   (cprop->item_type) ? (const char *)cprop->item_type : "UnknownType",
734                   manualfunc);
735         }
736         else {
737           fprintf(f, "    return %s(iter);\n", manualfunc);
738         }
739       }
740       fprintf(f, "}\n\n");
741       break;
742     }
743     default:
744       if (prop->arraydimension) {
745         if (prop->flag & PROP_DYNAMIC) {
746           fprintf(f, "void %s(PointerRNA *ptr, %s values[])\n", func, rna_type_type(prop));
747         }
748         else {
749           fprintf(f,
750                   "void %s(PointerRNA *ptr, %s values[%u])\n",
751                   func,
752                   rna_type_type(prop),
753                   prop->totarraylength);
754         }
755         fprintf(f, "{\n");
756
757         if (manualfunc) {
758           fprintf(f, "    %s(ptr, values);\n", manualfunc);
759         }
760         else {
761           rna_print_data_get(f, dp);
762
763           if (prop->flag & PROP_DYNAMIC) {
764             char *lenfunc = rna_alloc_function_name(
765                 srna->identifier, rna_safe_id(prop->identifier), "get_length");
766             fprintf(f, "    unsigned int arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
767             fprintf(f, "    unsigned int i;\n");
768             fprintf(f, "    unsigned int len = %s(ptr, arraylen);\n\n", lenfunc);
769             fprintf(f, "    for (i = 0; i < len; i++) {\n");
770             MEM_freeN(lenfunc);
771           }
772           else {
773             fprintf(f, "    unsigned int i;\n\n");
774             fprintf(f, "    for (i = 0; i < %u; i++) {\n", prop->totarraylength);
775           }
776
777           if (dp->dnaarraylength == 1) {
778             if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
779               fprintf(f,
780                       "        values[i] = %s((data->%s & (%du << i)) != 0);\n",
781                       (dp->booleannegative) ? "!" : "",
782                       dp->dnaname,
783                       dp->booleanbit);
784             }
785             else {
786               fprintf(f,
787                       "        values[i] = (%s)%s((&data->%s)[i]);\n",
788                       rna_type_type(prop),
789                       (dp->booleannegative) ? "!" : "",
790                       dp->dnaname);
791             }
792           }
793           else {
794             if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
795               fprintf(f,
796                       "        values[i] = %s((data->%s[i] & ",
797                       (dp->booleannegative) ? "!" : "",
798                       dp->dnaname);
799               rna_int_print(f, dp->booleanbit);
800               fprintf(f, ") != 0);\n");
801             }
802             else if (rna_color_quantize(prop, dp)) {
803               fprintf(f,
804                       "        values[i] = (%s)(data->%s[i] * (1.0f / 255.0f));\n",
805                       rna_type_type(prop),
806                       dp->dnaname);
807             }
808             else if (dp->dnatype) {
809               fprintf(f,
810                       "        values[i] = (%s)%s(((%s *)data->%s)[i]);\n",
811                       rna_type_type(prop),
812                       (dp->booleannegative) ? "!" : "",
813                       dp->dnatype,
814                       dp->dnaname);
815             }
816             else {
817               fprintf(f,
818                       "        values[i] = (%s)%s((data->%s)[i]);\n",
819                       rna_type_type(prop),
820                       (dp->booleannegative) ? "!" : "",
821                       dp->dnaname);
822             }
823           }
824           fprintf(f, "    }\n");
825         }
826         fprintf(f, "}\n\n");
827       }
828       else {
829         fprintf(f, "%s %s(PointerRNA *ptr)\n", rna_type_type(prop), func);
830         fprintf(f, "{\n");
831
832         if (manualfunc) {
833           fprintf(f, "    return %s(ptr);\n", manualfunc);
834         }
835         else {
836           rna_print_data_get(f, dp);
837           if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
838             fprintf(
839                 f, "    return %s(((data->%s) & ", (dp->booleannegative) ? "!" : "", dp->dnaname);
840             rna_int_print(f, dp->booleanbit);
841             fprintf(f, ") != 0);\n");
842           }
843           else if (prop->type == PROP_ENUM && dp->enumbitflags) {
844             fprintf(f, "    return ((data->%s) & ", dp->dnaname);
845             rna_int_print(f, rna_enum_bitmask(prop));
846             fprintf(f, ");\n");
847           }
848           else {
849             fprintf(f,
850                     "    return (%s)%s(data->%s);\n",
851                     rna_type_type(prop),
852                     (dp->booleannegative) ? "!" : "",
853                     dp->dnaname);
854           }
855         }
856
857         fprintf(f, "}\n\n");
858       }
859       break;
860   }
861
862   return func;
863 }
864
865 /* defined min/max variables to be used by rna_clamp_value() */
866 static void rna_clamp_value_range(FILE *f, PropertyRNA *prop)
867 {
868   if (prop->type == PROP_FLOAT) {
869     FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
870     if (fprop->range) {
871       fprintf(f,
872               "    float prop_clamp_min = -FLT_MAX, prop_clamp_max = FLT_MAX, prop_soft_min, "
873               "prop_soft_max;\n");
874       fprintf(f,
875               "    %s(ptr, &prop_clamp_min, &prop_clamp_max, &prop_soft_min, &prop_soft_max);\n",
876               rna_function_string(fprop->range));
877     }
878   }
879   else if (prop->type == PROP_INT) {
880     IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
881     if (iprop->range) {
882       fprintf(f,
883               "    int prop_clamp_min = INT_MIN, prop_clamp_max = INT_MAX, prop_soft_min, "
884               "prop_soft_max;\n");
885       fprintf(f,
886               "    %s(ptr, &prop_clamp_min, &prop_clamp_max, &prop_soft_min, &prop_soft_max);\n",
887               rna_function_string(iprop->range));
888     }
889   }
890 }
891
892 #ifdef USE_RNA_RANGE_CHECK
893 static void rna_clamp_value_range_check(FILE *f,
894                                         PropertyRNA *prop,
895                                         const char *dnaname_prefix,
896                                         const char *dnaname)
897 {
898   if (prop->type == PROP_INT) {
899     IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
900     fprintf(f,
901             "    { BLI_STATIC_ASSERT("
902             "(TYPEOF_MAX(%s%s) >= %d) && "
903             "(TYPEOF_MIN(%s%s) <= %d), "
904             "\"invalid limits\"); }\n",
905             dnaname_prefix,
906             dnaname,
907             iprop->hardmax,
908             dnaname_prefix,
909             dnaname,
910             iprop->hardmin);
911   }
912 }
913 #endif /* USE_RNA_RANGE_CHECK */
914
915 static void rna_clamp_value(FILE *f, PropertyRNA *prop, int array)
916 {
917   if (prop->type == PROP_INT) {
918     IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
919
920     if (iprop->hardmin != INT_MIN || iprop->hardmax != INT_MAX || iprop->range) {
921       if (array) {
922         fprintf(f, "CLAMPIS(values[i], ");
923       }
924       else {
925         fprintf(f, "CLAMPIS(value, ");
926       }
927       if (iprop->range) {
928         fprintf(f, "prop_clamp_min, prop_clamp_max);");
929       }
930       else {
931         rna_int_print(f, iprop->hardmin);
932         fprintf(f, ", ");
933         rna_int_print(f, iprop->hardmax);
934         fprintf(f, ");\n");
935       }
936       return;
937     }
938   }
939   else if (prop->type == PROP_FLOAT) {
940     FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
941
942     if (fprop->hardmin != -FLT_MAX || fprop->hardmax != FLT_MAX || fprop->range) {
943       if (array) {
944         fprintf(f, "CLAMPIS(values[i], ");
945       }
946       else {
947         fprintf(f, "CLAMPIS(value, ");
948       }
949       if (fprop->range) {
950         fprintf(f, "prop_clamp_min, prop_clamp_max);");
951       }
952       else {
953         rna_float_print(f, fprop->hardmin);
954         fprintf(f, ", ");
955         rna_float_print(f, fprop->hardmax);
956         fprintf(f, ");\n");
957       }
958       return;
959     }
960   }
961
962   if (array) {
963     fprintf(f, "values[i];\n");
964   }
965   else {
966     fprintf(f, "value;\n");
967   }
968 }
969
970 static char *rna_def_property_set_func(
971     FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
972 {
973   char *func;
974
975   if (!(prop->flag & PROP_EDITABLE)) {
976     return NULL;
977   }
978   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
979     return NULL;
980   }
981
982   if (!manualfunc) {
983     if (!dp->dnastructname || !dp->dnaname) {
984       if (prop->flag & PROP_EDITABLE) {
985         CLOG_ERROR(&LOG, "%s.%s has no valid dna info.", srna->identifier, prop->identifier);
986         DefRNA.error = 1;
987       }
988       return NULL;
989     }
990   }
991
992   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "set");
993
994   switch (prop->type) {
995     case PROP_STRING: {
996       StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
997       fprintf(f, "void %s(PointerRNA *ptr, const char *value)\n", func);
998       fprintf(f, "{\n");
999       if (manualfunc) {
1000         fprintf(f, "    %s(ptr, value);\n", manualfunc);
1001       }
1002       else {
1003         const PropertySubType subtype = prop->subtype;
1004         const char *string_copy_func = (subtype == PROP_FILEPATH || subtype == PROP_DIRPATH ||
1005                                         subtype == PROP_FILENAME || subtype == PROP_BYTESTRING) ?
1006                                            "BLI_strncpy" :
1007                                            "BLI_strncpy_utf8";
1008
1009         rna_print_data_get(f, dp);
1010
1011         if (!(prop->flag & PROP_NEVER_NULL)) {
1012           fprintf(f, "    if (data->%s == NULL) {\n", dp->dnaname);
1013           fprintf(f, "        return;\n");
1014           fprintf(f, "    }\n");
1015         }
1016
1017         if (sprop->maxlength) {
1018           fprintf(f,
1019                   "    %s(data->%s, value, %d);\n",
1020                   string_copy_func,
1021                   dp->dnaname,
1022                   sprop->maxlength);
1023         }
1024         else {
1025           fprintf(f,
1026                   "    %s(data->%s, value, sizeof(data->%s));\n",
1027                   string_copy_func,
1028                   dp->dnaname,
1029                   dp->dnaname);
1030         }
1031       }
1032       fprintf(f, "}\n\n");
1033       break;
1034     }
1035     case PROP_POINTER: {
1036       fprintf(f, "void %s(PointerRNA *ptr, PointerRNA value, struct ReportList *reports)\n", func);
1037       fprintf(f, "{\n");
1038       if (manualfunc) {
1039         fprintf(f, "    %s(ptr, value, reports);\n", manualfunc);
1040       }
1041       else {
1042         rna_print_data_get(f, dp);
1043
1044         if (prop->flag & PROP_ID_SELF_CHECK) {
1045           rna_print_id_get(f, dp);
1046           fprintf(f, "    if (id == value.data) return;\n\n");
1047         }
1048
1049         if (prop->flag & PROP_ID_REFCOUNT) {
1050           fprintf(f, "\n    if (data->%s)\n", dp->dnaname);
1051           fprintf(f, "        id_us_min((ID *)data->%s);\n", dp->dnaname);
1052           fprintf(f, "    if (value.data)\n");
1053           fprintf(f, "        id_us_plus((ID *)value.data);\n\n");
1054         }
1055         else {
1056           PointerPropertyRNA *pprop = (PointerPropertyRNA *)dp->prop;
1057           StructRNA *type = (pprop->type) ? rna_find_struct((const char *)pprop->type) : NULL;
1058           if (type && (type->flag & STRUCT_ID)) {
1059             fprintf(f, "    if (value.data)\n");
1060             fprintf(f, "        id_lib_extern((ID *)value.data);\n\n");
1061           }
1062         }
1063
1064         fprintf(f, "    data->%s = value.data;\n", dp->dnaname);
1065       }
1066       fprintf(f, "}\n\n");
1067       break;
1068     }
1069     default:
1070       if (prop->arraydimension) {
1071         if (prop->flag & PROP_DYNAMIC) {
1072           fprintf(f, "void %s(PointerRNA *ptr, const %s values[])\n", func, rna_type_type(prop));
1073         }
1074         else {
1075           fprintf(f,
1076                   "void %s(PointerRNA *ptr, const %s values[%u])\n",
1077                   func,
1078                   rna_type_type(prop),
1079                   prop->totarraylength);
1080         }
1081         fprintf(f, "{\n");
1082
1083         if (manualfunc) {
1084           fprintf(f, "    %s(ptr, values);\n", manualfunc);
1085         }
1086         else {
1087           rna_print_data_get(f, dp);
1088
1089           if (prop->flag & PROP_DYNAMIC) {
1090             char *lenfunc = rna_alloc_function_name(
1091                 srna->identifier, rna_safe_id(prop->identifier), "set_length");
1092             fprintf(f, "    unsigned int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
1093             fprintf(f, "    unsigned int len = %s(ptr, arraylen);\n\n", lenfunc);
1094             rna_clamp_value_range(f, prop);
1095             fprintf(f, "    for (i = 0; i < len; i++) {\n");
1096             MEM_freeN(lenfunc);
1097           }
1098           else {
1099             fprintf(f, "    unsigned int i;\n\n");
1100             rna_clamp_value_range(f, prop);
1101             fprintf(f, "    for (i = 0; i < %u; i++) {\n", prop->totarraylength);
1102           }
1103
1104           if (dp->dnaarraylength == 1) {
1105             if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
1106               fprintf(f,
1107                       "        if (%svalues[i]) data->%s |= (%du << i);\n",
1108                       (dp->booleannegative) ? "!" : "",
1109                       dp->dnaname,
1110                       dp->booleanbit);
1111               fprintf(f, "        else data->%s &= ~(%du << i);\n", dp->dnaname, dp->booleanbit);
1112             }
1113             else {
1114               fprintf(
1115                   f, "        (&data->%s)[i] = %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
1116               rna_clamp_value(f, prop, 1);
1117             }
1118           }
1119           else {
1120             if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
1121               fprintf(f,
1122                       "        if (%svalues[i]) data->%s[i] |= ",
1123                       (dp->booleannegative) ? "!" : "",
1124                       dp->dnaname);
1125               rna_int_print(f, dp->booleanbit);
1126               fprintf(f, ";\n");
1127               fprintf(f, "        else data->%s[i] &= ~", dp->dnaname);
1128               rna_int_print(f, dp->booleanbit);
1129               fprintf(f, ";\n");
1130             }
1131             else if (rna_color_quantize(prop, dp)) {
1132               fprintf(
1133                   f, "        data->%s[i] = unit_float_to_uchar_clamp(values[i]);\n", dp->dnaname);
1134             }
1135             else {
1136               if (dp->dnatype) {
1137                 fprintf(f,
1138                         "        ((%s *)data->%s)[i] = %s",
1139                         dp->dnatype,
1140                         dp->dnaname,
1141                         (dp->booleannegative) ? "!" : "");
1142               }
1143               else {
1144                 fprintf(f,
1145                         "        (data->%s)[i] = %s",
1146                         dp->dnaname,
1147                         (dp->booleannegative) ? "!" : "");
1148               }
1149               rna_clamp_value(f, prop, 1);
1150             }
1151           }
1152           fprintf(f, "    }\n");
1153         }
1154
1155 #ifdef USE_RNA_RANGE_CHECK
1156         if (dp->dnaname && manualfunc == NULL) {
1157           if (dp->dnaarraylength == 1) {
1158             rna_clamp_value_range_check(f, prop, "data->", dp->dnaname);
1159           }
1160           else {
1161             rna_clamp_value_range_check(f, prop, "*data->", dp->dnaname);
1162           }
1163         }
1164 #endif
1165
1166         fprintf(f, "}\n\n");
1167       }
1168       else {
1169         fprintf(f, "void %s(PointerRNA *ptr, %s value)\n", func, rna_type_type(prop));
1170         fprintf(f, "{\n");
1171
1172         if (manualfunc) {
1173           fprintf(f, "    %s(ptr, value);\n", manualfunc);
1174         }
1175         else {
1176           rna_print_data_get(f, dp);
1177           if (prop->type == PROP_BOOLEAN && dp->booleanbit) {
1178             fprintf(
1179                 f, "    if (%svalue) data->%s |= ", (dp->booleannegative) ? "!" : "", dp->dnaname);
1180             rna_int_print(f, dp->booleanbit);
1181             fprintf(f, ";\n");
1182             fprintf(f, "    else data->%s &= ~", dp->dnaname);
1183             rna_int_print(f, dp->booleanbit);
1184             fprintf(f, ";\n");
1185           }
1186           else if (prop->type == PROP_ENUM && dp->enumbitflags) {
1187             fprintf(f, "    data->%s &= ~", dp->dnaname);
1188             rna_int_print(f, rna_enum_bitmask(prop));
1189             fprintf(f, ";\n");
1190             fprintf(f, "    data->%s |= value;\n", dp->dnaname);
1191           }
1192           else {
1193             rna_clamp_value_range(f, prop);
1194             fprintf(f, "    data->%s = %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
1195             rna_clamp_value(f, prop, 0);
1196           }
1197         }
1198
1199 #ifdef USE_RNA_RANGE_CHECK
1200         if (dp->dnaname && manualfunc == NULL) {
1201           rna_clamp_value_range_check(f, prop, "data->", dp->dnaname);
1202         }
1203 #endif
1204
1205         fprintf(f, "}\n\n");
1206       }
1207       break;
1208   }
1209
1210   return func;
1211 }
1212
1213 static char *rna_def_property_length_func(
1214     FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
1215 {
1216   char *func = NULL;
1217
1218   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1219     return NULL;
1220   }
1221
1222   if (prop->type == PROP_STRING) {
1223     if (!manualfunc) {
1224       if (!dp->dnastructname || !dp->dnaname) {
1225         CLOG_ERROR(&LOG, "%s.%s has no valid dna info.", srna->identifier, prop->identifier);
1226         DefRNA.error = 1;
1227         return NULL;
1228       }
1229     }
1230
1231     func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "length");
1232
1233     fprintf(f, "int %s(PointerRNA *ptr)\n", func);
1234     fprintf(f, "{\n");
1235     if (manualfunc) {
1236       fprintf(f, "    return %s(ptr);\n", manualfunc);
1237     }
1238     else {
1239       rna_print_data_get(f, dp);
1240       if (!(prop->flag & PROP_NEVER_NULL)) {
1241         fprintf(f, "    if (data->%s == NULL) return 0;\n", dp->dnaname);
1242       }
1243       fprintf(f, "    return strlen(data->%s);\n", dp->dnaname);
1244     }
1245     fprintf(f, "}\n\n");
1246   }
1247   else if (prop->type == PROP_COLLECTION) {
1248     if (!manualfunc) {
1249       if (prop->type == PROP_COLLECTION &&
1250           (!(dp->dnalengthname || dp->dnalengthfixed) || !dp->dnaname)) {
1251         CLOG_ERROR(&LOG, "%s.%s has no valid dna info.", srna->identifier, prop->identifier);
1252         DefRNA.error = 1;
1253         return NULL;
1254       }
1255     }
1256
1257     func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "length");
1258
1259     fprintf(f, "int %s(PointerRNA *ptr)\n", func);
1260     fprintf(f, "{\n");
1261     if (manualfunc) {
1262       fprintf(f, "    return %s(ptr);\n", manualfunc);
1263     }
1264     else {
1265       if (dp->dnaarraylength <= 1 || dp->dnalengthname) {
1266         rna_print_data_get(f, dp);
1267       }
1268
1269       if (dp->dnaarraylength > 1) {
1270         fprintf(f, "    return ");
1271       }
1272       else {
1273         fprintf(f, "    return (data->%s == NULL) ? 0 : ", dp->dnaname);
1274       }
1275
1276       if (dp->dnalengthname) {
1277         fprintf(f, "data->%s;\n", dp->dnalengthname);
1278       }
1279       else {
1280         fprintf(f, "%d;\n", dp->dnalengthfixed);
1281       }
1282     }
1283     fprintf(f, "}\n\n");
1284   }
1285
1286   return func;
1287 }
1288
1289 static char *rna_def_property_begin_func(
1290     FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
1291 {
1292   char *func, *getfunc;
1293
1294   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1295     return NULL;
1296   }
1297
1298   if (!manualfunc) {
1299     if (!dp->dnastructname || !dp->dnaname) {
1300       CLOG_ERROR(&LOG, "%s.%s has no valid dna info.", srna->identifier, prop->identifier);
1301       DefRNA.error = 1;
1302       return NULL;
1303     }
1304   }
1305
1306   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "begin");
1307
1308   fprintf(f, "void %s(CollectionPropertyIterator *iter, PointerRNA *ptr)\n", func);
1309   fprintf(f, "{\n");
1310
1311   if (!manualfunc) {
1312     rna_print_data_get(f, dp);
1313   }
1314
1315   fprintf(f, "\n    memset(iter, 0, sizeof(*iter));\n");
1316   fprintf(f, "    iter->parent = *ptr;\n");
1317   fprintf(f, "    iter->prop = (PropertyRNA *)&rna_%s_%s;\n", srna->identifier, prop->identifier);
1318
1319   if (dp->dnalengthname || dp->dnalengthfixed) {
1320     if (manualfunc) {
1321       fprintf(f, "\n    %s(iter, ptr);\n", manualfunc);
1322     }
1323     else {
1324       if (dp->dnalengthname) {
1325         fprintf(f,
1326                 "\n    rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), data->%s, 0, "
1327                 "NULL);\n",
1328                 dp->dnaname,
1329                 dp->dnaname,
1330                 dp->dnalengthname);
1331       }
1332       else {
1333         fprintf(
1334             f,
1335             "\n    rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), %d, 0, NULL);\n",
1336             dp->dnaname,
1337             dp->dnaname,
1338             dp->dnalengthfixed);
1339       }
1340     }
1341   }
1342   else {
1343     if (manualfunc) {
1344       fprintf(f, "\n    %s(iter, ptr);\n", manualfunc);
1345     }
1346     else if (dp->dnapointerlevel == 0) {
1347       fprintf(f, "\n    rna_iterator_listbase_begin(iter, &data->%s, NULL);\n", dp->dnaname);
1348     }
1349     else {
1350       fprintf(f, "\n    rna_iterator_listbase_begin(iter, data->%s, NULL);\n", dp->dnaname);
1351     }
1352   }
1353
1354   getfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get");
1355
1356   fprintf(f, "\n    if (iter->valid)\n");
1357   fprintf(f, "        iter->ptr = %s(iter);\n", getfunc);
1358
1359   fprintf(f, "}\n\n");
1360
1361   return func;
1362 }
1363
1364 static char *rna_def_property_lookup_int_func(FILE *f,
1365                                               StructRNA *srna,
1366                                               PropertyRNA *prop,
1367                                               PropertyDefRNA *dp,
1368                                               const char *manualfunc,
1369                                               const char *nextfunc)
1370 {
1371   /* note on indices, this is for external functions and ignores skipped values.
1372    * so the index can only be checked against the length when there is no 'skip' function. */
1373   char *func;
1374
1375   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1376     return NULL;
1377   }
1378
1379   if (!manualfunc) {
1380     if (!dp->dnastructname || !dp->dnaname) {
1381       return NULL;
1382     }
1383
1384     /* only supported in case of standard next functions */
1385     if (STREQ(nextfunc, "rna_iterator_array_next")) {
1386     }
1387     else if (STREQ(nextfunc, "rna_iterator_listbase_next")) {
1388     }
1389     else {
1390       return NULL;
1391     }
1392   }
1393
1394   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "lookup_int");
1395
1396   fprintf(f, "int %s(PointerRNA *ptr, int index, PointerRNA *r_ptr)\n", func);
1397   fprintf(f, "{\n");
1398
1399   if (manualfunc) {
1400     fprintf(f, "\n    return %s(ptr, index, r_ptr);\n", manualfunc);
1401     fprintf(f, "}\n\n");
1402     return func;
1403   }
1404
1405   fprintf(f, "    int found = 0;\n");
1406   fprintf(f, "    CollectionPropertyIterator iter;\n\n");
1407
1408   fprintf(f, "    %s_%s_begin(&iter, ptr);\n\n", srna->identifier, rna_safe_id(prop->identifier));
1409   fprintf(f, "    if (iter.valid) {\n");
1410
1411   if (STREQ(nextfunc, "rna_iterator_array_next")) {
1412     fprintf(f, "        ArrayIterator *internal = &iter.internal.array;\n");
1413     fprintf(f, "        if (index < 0 || index >= internal->length) {\n");
1414     fprintf(f, "#ifdef __GNUC__\n");
1415     fprintf(f,
1416             "            printf(\"Array iterator out of range: %%s (index %%d)\\n\", __func__, "
1417             "index);\n");
1418     fprintf(f, "#else\n");
1419     fprintf(f, "            printf(\"Array iterator out of range: (index %%d)\\n\", index);\n");
1420     fprintf(f, "#endif\n");
1421     fprintf(f, "        }\n");
1422     fprintf(f, "        else if (internal->skip) {\n");
1423     fprintf(f, "            while (index-- > 0 && iter.valid) {\n");
1424     fprintf(f, "                rna_iterator_array_next(&iter);\n");
1425     fprintf(f, "            }\n");
1426     fprintf(f, "            found = (index == -1 && iter.valid);\n");
1427     fprintf(f, "        }\n");
1428     fprintf(f, "        else {\n");
1429     fprintf(f, "            internal->ptr += internal->itemsize * index;\n");
1430     fprintf(f, "            found = 1;\n");
1431     fprintf(f, "        }\n");
1432   }
1433   else if (STREQ(nextfunc, "rna_iterator_listbase_next")) {
1434     fprintf(f, "        ListBaseIterator *internal = &iter.internal.listbase;\n");
1435     fprintf(f, "        if (internal->skip) {\n");
1436     fprintf(f, "            while (index-- > 0 && iter.valid) {\n");
1437     fprintf(f, "                rna_iterator_listbase_next(&iter);\n");
1438     fprintf(f, "            }\n");
1439     fprintf(f, "            found = (index == -1 && iter.valid);\n");
1440     fprintf(f, "        }\n");
1441     fprintf(f, "        else {\n");
1442     fprintf(f, "            while (index-- > 0 && internal->link)\n");
1443     fprintf(f, "                internal->link = internal->link->next;\n");
1444     fprintf(f, "            found = (index == -1 && internal->link);\n");
1445     fprintf(f, "        }\n");
1446   }
1447
1448   fprintf(f,
1449           "        if (found) *r_ptr = %s_%s_get(&iter);\n",
1450           srna->identifier,
1451           rna_safe_id(prop->identifier));
1452   fprintf(f, "    }\n\n");
1453   fprintf(f, "    %s_%s_end(&iter);\n\n", srna->identifier, rna_safe_id(prop->identifier));
1454
1455   fprintf(f, "    return found;\n");
1456
1457 #if 0
1458   rna_print_data_get(f, dp);
1459   item_type = (cprop->item_type) ? (const char *)cprop->item_type : "UnknownType";
1460
1461   if (dp->dnalengthname || dp->dnalengthfixed) {
1462     if (dp->dnalengthname) {
1463       fprintf(f,
1464               "\n    rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), data->%s, "
1465               "index);\n",
1466               item_type,
1467               dp->dnaname,
1468               dp->dnaname,
1469               dp->dnalengthname);
1470     }
1471     else {
1472       fprintf(
1473           f,
1474           "\n    rna_array_lookup_int(ptr, &RNA_%s, data->%s, sizeof(data->%s[0]), %d, index);\n",
1475           item_type,
1476           dp->dnaname,
1477           dp->dnaname,
1478           dp->dnalengthfixed);
1479     }
1480   }
1481   else {
1482     if (dp->dnapointerlevel == 0) {
1483       fprintf(f,
1484               "\n    return rna_listbase_lookup_int(ptr, &RNA_%s, &data->%s, index);\n",
1485               item_type,
1486               dp->dnaname);
1487     }
1488     else {
1489       fprintf(f,
1490               "\n    return rna_listbase_lookup_int(ptr, &RNA_%s, data->%s, index);\n",
1491               item_type,
1492               dp->dnaname);
1493     }
1494   }
1495 #endif
1496
1497   fprintf(f, "}\n\n");
1498
1499   return func;
1500 }
1501
1502 static char *rna_def_property_lookup_string_func(FILE *f,
1503                                                  StructRNA *srna,
1504                                                  PropertyRNA *prop,
1505                                                  PropertyDefRNA *dp,
1506                                                  const char *manualfunc,
1507                                                  const char *item_type)
1508 {
1509   char *func;
1510   StructRNA *item_srna, *item_name_base;
1511   PropertyRNA *item_name_prop;
1512   const int namebuflen = 1024;
1513
1514   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1515     return NULL;
1516   }
1517
1518   if (!manualfunc) {
1519     if (!dp->dnastructname || !dp->dnaname) {
1520       return NULL;
1521     }
1522
1523     /* only supported for collection items with name properties */
1524     item_srna = rna_find_struct(item_type);
1525     if (item_srna && item_srna->nameproperty) {
1526       item_name_prop = item_srna->nameproperty;
1527       item_name_base = item_srna;
1528       while (item_name_base->base && item_name_base->base->nameproperty == item_name_prop) {
1529         item_name_base = item_name_base->base;
1530       }
1531     }
1532     else {
1533       return NULL;
1534     }
1535   }
1536
1537   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "lookup_string");
1538
1539   fprintf(f, "int %s(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)\n", func);
1540   fprintf(f, "{\n");
1541
1542   if (manualfunc) {
1543     fprintf(f, "    return %s(ptr, key, r_ptr);\n", manualfunc);
1544     fprintf(f, "}\n\n");
1545     return func;
1546   }
1547
1548   /* XXX extern declaration could be avoid by including RNA_blender.h, but this has lots of unknown
1549    * DNA types in functions, leading to conflicting function signatures.
1550    */
1551   fprintf(f,
1552           "    extern int %s_%s_length(PointerRNA *);\n",
1553           item_name_base->identifier,
1554           rna_safe_id(item_name_prop->identifier));
1555   fprintf(f,
1556           "    extern void %s_%s_get(PointerRNA *, char *);\n\n",
1557           item_name_base->identifier,
1558           rna_safe_id(item_name_prop->identifier));
1559
1560   fprintf(f, "    bool found = false;\n");
1561   fprintf(f, "    CollectionPropertyIterator iter;\n");
1562   fprintf(f, "    char namebuf[%d];\n", namebuflen);
1563   fprintf(f, "    char *name;\n\n");
1564
1565   fprintf(f, "    %s_%s_begin(&iter, ptr);\n\n", srna->identifier, rna_safe_id(prop->identifier));
1566
1567   fprintf(f, "    while (iter.valid) {\n");
1568   fprintf(f, "        if (iter.ptr.data) {\n");
1569   fprintf(f,
1570           "            int namelen = %s_%s_length(&iter.ptr);\n",
1571           item_name_base->identifier,
1572           rna_safe_id(item_name_prop->identifier));
1573   fprintf(f, "            if (namelen < %d) {\n", namebuflen);
1574   fprintf(f,
1575           "                %s_%s_get(&iter.ptr, namebuf);\n",
1576           item_name_base->identifier,
1577           rna_safe_id(item_name_prop->identifier));
1578   fprintf(f, "                if (strcmp(namebuf, key) == 0) {\n");
1579   fprintf(f, "                    found = true;\n");
1580   fprintf(f, "                    *r_ptr = iter.ptr;\n");
1581   fprintf(f, "                    break;\n");
1582   fprintf(f, "                }\n");
1583   fprintf(f, "            }\n");
1584   fprintf(f, "            else {\n");
1585   fprintf(f, "                name = MEM_mallocN(namelen+1, \"name string\");\n");
1586   fprintf(f,
1587           "                %s_%s_get(&iter.ptr, name);\n",
1588           item_name_base->identifier,
1589           rna_safe_id(item_name_prop->identifier));
1590   fprintf(f, "                if (strcmp(name, key) == 0) {\n");
1591   fprintf(f, "                    MEM_freeN(name);\n\n");
1592   fprintf(f, "                    found = true;\n");
1593   fprintf(f, "                    *r_ptr = iter.ptr;\n");
1594   fprintf(f, "                    break;\n");
1595   fprintf(f, "                }\n");
1596   fprintf(f, "                else {\n");
1597   fprintf(f, "                    MEM_freeN(name);\n");
1598   fprintf(f, "                }\n");
1599   fprintf(f, "            }\n");
1600   fprintf(f, "        }\n");
1601   fprintf(f, "        %s_%s_next(&iter);\n", srna->identifier, rna_safe_id(prop->identifier));
1602   fprintf(f, "    }\n");
1603   fprintf(f, "    %s_%s_end(&iter);\n\n", srna->identifier, rna_safe_id(prop->identifier));
1604
1605   fprintf(f, "    return found;\n");
1606   fprintf(f, "}\n\n");
1607
1608   return func;
1609 }
1610
1611 static char *rna_def_property_next_func(FILE *f,
1612                                         StructRNA *srna,
1613                                         PropertyRNA *prop,
1614                                         PropertyDefRNA *UNUSED(dp),
1615                                         const char *manualfunc)
1616 {
1617   char *func, *getfunc;
1618
1619   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1620     return NULL;
1621   }
1622
1623   if (!manualfunc) {
1624     return NULL;
1625   }
1626
1627   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "next");
1628
1629   fprintf(f, "void %s(CollectionPropertyIterator *iter)\n", func);
1630   fprintf(f, "{\n");
1631   fprintf(f, "    %s(iter);\n", manualfunc);
1632
1633   getfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get");
1634
1635   fprintf(f, "\n    if (iter->valid)\n");
1636   fprintf(f, "        iter->ptr = %s(iter);\n", getfunc);
1637
1638   fprintf(f, "}\n\n");
1639
1640   return func;
1641 }
1642
1643 static char *rna_def_property_end_func(FILE *f,
1644                                        StructRNA *srna,
1645                                        PropertyRNA *prop,
1646                                        PropertyDefRNA *UNUSED(dp),
1647                                        const char *manualfunc)
1648 {
1649   char *func;
1650
1651   if (prop->flag & PROP_IDPROPERTY && manualfunc == NULL) {
1652     return NULL;
1653   }
1654
1655   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "end");
1656
1657   fprintf(f, "void %s(CollectionPropertyIterator *iter)\n", func);
1658   fprintf(f, "{\n");
1659   if (manualfunc) {
1660     fprintf(f, "    %s(iter);\n", manualfunc);
1661   }
1662   fprintf(f, "}\n\n");
1663
1664   return func;
1665 }
1666
1667 static void rna_set_raw_property(PropertyDefRNA *dp, PropertyRNA *prop)
1668 {
1669   if (dp->dnapointerlevel != 0) {
1670     return;
1671   }
1672   if (!dp->dnatype || !dp->dnaname || !dp->dnastructname) {
1673     return;
1674   }
1675
1676   if (STREQ(dp->dnatype, "char")) {
1677     prop->rawtype = PROP_RAW_CHAR;
1678     prop->flag_internal |= PROP_INTERN_RAW_ACCESS;
1679   }
1680   else if (STREQ(dp->dnatype, "short")) {
1681     prop->rawtype = PROP_RAW_SHORT;
1682     prop->flag_internal |= PROP_INTERN_RAW_ACCESS;
1683   }
1684   else if (STREQ(dp->dnatype, "int")) {
1685     prop->rawtype = PROP_RAW_INT;
1686     prop->flag_internal |= PROP_INTERN_RAW_ACCESS;
1687   }
1688   else if (STREQ(dp->dnatype, "float")) {
1689     prop->rawtype = PROP_RAW_FLOAT;
1690     prop->flag_internal |= PROP_INTERN_RAW_ACCESS;
1691   }
1692   else if (STREQ(dp->dnatype, "double")) {
1693     prop->rawtype = PROP_RAW_DOUBLE;
1694     prop->flag_internal |= PROP_INTERN_RAW_ACCESS;
1695   }
1696 }
1697
1698 static void rna_set_raw_offset(FILE *f, StructRNA *srna, PropertyRNA *prop)
1699 {
1700   PropertyDefRNA *dp = rna_find_struct_property_def(srna, prop);
1701
1702   fprintf(f, "\toffsetof(%s, %s), %d", dp->dnastructname, dp->dnaname, prop->rawtype);
1703 }
1704
1705 static void rna_def_property_funcs(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
1706 {
1707   PropertyRNA *prop;
1708
1709   prop = dp->prop;
1710
1711   switch (prop->type) {
1712     case PROP_BOOLEAN: {
1713       BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
1714
1715       if (!prop->arraydimension) {
1716         if (!bprop->get && !bprop->set && !dp->booleanbit) {
1717           rna_set_raw_property(dp, prop);
1718         }
1719
1720         bprop->get = (void *)rna_def_property_get_func(
1721             f, srna, prop, dp, (const char *)bprop->get);
1722         bprop->set = (void *)rna_def_property_set_func(
1723             f, srna, prop, dp, (const char *)bprop->set);
1724       }
1725       else {
1726         bprop->getarray = (void *)rna_def_property_get_func(
1727             f, srna, prop, dp, (const char *)bprop->getarray);
1728         bprop->setarray = (void *)rna_def_property_set_func(
1729             f, srna, prop, dp, (const char *)bprop->setarray);
1730       }
1731       break;
1732     }
1733     case PROP_INT: {
1734       IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
1735
1736       if (!prop->arraydimension) {
1737         if (!iprop->get && !iprop->set) {
1738           rna_set_raw_property(dp, prop);
1739         }
1740
1741         iprop->get = (void *)rna_def_property_get_func(
1742             f, srna, prop, dp, (const char *)iprop->get);
1743         iprop->set = (void *)rna_def_property_set_func(
1744             f, srna, prop, dp, (const char *)iprop->set);
1745       }
1746       else {
1747         if (!iprop->getarray && !iprop->setarray) {
1748           rna_set_raw_property(dp, prop);
1749         }
1750
1751         iprop->getarray = (void *)rna_def_property_get_func(
1752             f, srna, prop, dp, (const char *)iprop->getarray);
1753         iprop->setarray = (void *)rna_def_property_set_func(
1754             f, srna, prop, dp, (const char *)iprop->setarray);
1755       }
1756       break;
1757     }
1758     case PROP_FLOAT: {
1759       FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
1760
1761       if (!prop->arraydimension) {
1762         if (!fprop->get && !fprop->set) {
1763           rna_set_raw_property(dp, prop);
1764         }
1765
1766         fprop->get = (void *)rna_def_property_get_func(
1767             f, srna, prop, dp, (const char *)fprop->get);
1768         fprop->set = (void *)rna_def_property_set_func(
1769             f, srna, prop, dp, (const char *)fprop->set);
1770       }
1771       else {
1772         if (!fprop->getarray && !fprop->setarray) {
1773           rna_set_raw_property(dp, prop);
1774         }
1775
1776         fprop->getarray = (void *)rna_def_property_get_func(
1777             f, srna, prop, dp, (const char *)fprop->getarray);
1778         fprop->setarray = (void *)rna_def_property_set_func(
1779             f, srna, prop, dp, (const char *)fprop->setarray);
1780       }
1781       break;
1782     }
1783     case PROP_ENUM: {
1784       EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1785
1786       eprop->get = (void *)rna_def_property_get_func(f, srna, prop, dp, (const char *)eprop->get);
1787       eprop->set = (void *)rna_def_property_set_func(f, srna, prop, dp, (const char *)eprop->set);
1788       break;
1789     }
1790     case PROP_STRING: {
1791       StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1792
1793       sprop->get = (void *)rna_def_property_get_func(f, srna, prop, dp, (const char *)sprop->get);
1794       sprop->length = (void *)rna_def_property_length_func(
1795           f, srna, prop, dp, (const char *)sprop->length);
1796       sprop->set = (void *)rna_def_property_set_func(f, srna, prop, dp, (const char *)sprop->set);
1797       break;
1798     }
1799     case PROP_POINTER: {
1800       PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
1801
1802       pprop->get = (void *)rna_def_property_get_func(f, srna, prop, dp, (const char *)pprop->get);
1803       pprop->set = (void *)rna_def_property_set_func(f, srna, prop, dp, (const char *)pprop->set);
1804       if (!pprop->type) {
1805         CLOG_ERROR(
1806             &LOG, "%s.%s, pointer must have a struct type.", srna->identifier, prop->identifier);
1807         DefRNA.error = 1;
1808       }
1809       break;
1810     }
1811     case PROP_COLLECTION: {
1812       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1813       const char *nextfunc = (const char *)cprop->next;
1814       const char *item_type = (const char *)cprop->item_type;
1815
1816       if (cprop->length) {
1817         /* always generate if we have a manual implementation */
1818         cprop->length = (void *)rna_def_property_length_func(
1819             f, srna, prop, dp, (const char *)cprop->length);
1820       }
1821       else if (dp->dnatype && STREQ(dp->dnatype, "ListBase")) {
1822         /* pass */
1823       }
1824       else if (dp->dnalengthname || dp->dnalengthfixed) {
1825         cprop->length = (void *)rna_def_property_length_func(
1826             f, srna, prop, dp, (const char *)cprop->length);
1827       }
1828
1829       /* test if we can allow raw array access, if it is using our standard
1830        * array get/next function, we can be sure it is an actual array */
1831       if (cprop->next && cprop->get) {
1832         if (STREQ((const char *)cprop->next, "rna_iterator_array_next") &&
1833             STREQ((const char *)cprop->get, "rna_iterator_array_get")) {
1834           prop->flag_internal |= PROP_INTERN_RAW_ARRAY;
1835         }
1836       }
1837
1838       cprop->get = (void *)rna_def_property_get_func(f, srna, prop, dp, (const char *)cprop->get);
1839       cprop->begin = (void *)rna_def_property_begin_func(
1840           f, srna, prop, dp, (const char *)cprop->begin);
1841       cprop->next = (void *)rna_def_property_next_func(
1842           f, srna, prop, dp, (const char *)cprop->next);
1843       cprop->end = (void *)rna_def_property_end_func(f, srna, prop, dp, (const char *)cprop->end);
1844       cprop->lookupint = (void *)rna_def_property_lookup_int_func(
1845           f, srna, prop, dp, (const char *)cprop->lookupint, nextfunc);
1846       cprop->lookupstring = (void *)rna_def_property_lookup_string_func(
1847           f, srna, prop, dp, (const char *)cprop->lookupstring, item_type);
1848
1849       if (!(prop->flag & PROP_IDPROPERTY)) {
1850         if (!cprop->begin) {
1851           CLOG_ERROR(&LOG,
1852                      "%s.%s, collection must have a begin function.",
1853                      srna->identifier,
1854                      prop->identifier);
1855           DefRNA.error = 1;
1856         }
1857         if (!cprop->next) {
1858           CLOG_ERROR(&LOG,
1859                      "%s.%s, collection must have a next function.",
1860                      srna->identifier,
1861                      prop->identifier);
1862           DefRNA.error = 1;
1863         }
1864         if (!cprop->get) {
1865           CLOG_ERROR(&LOG,
1866                      "%s.%s, collection must have a get function.",
1867                      srna->identifier,
1868                      prop->identifier);
1869           DefRNA.error = 1;
1870         }
1871       }
1872       if (!cprop->item_type) {
1873         CLOG_ERROR(&LOG,
1874                    "%s.%s, collection must have a struct type.",
1875                    srna->identifier,
1876                    prop->identifier);
1877         DefRNA.error = 1;
1878       }
1879       break;
1880     }
1881   }
1882 }
1883
1884 static void rna_def_property_funcs_header(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
1885 {
1886   PropertyRNA *prop;
1887   const char *func;
1888
1889   prop = dp->prop;
1890
1891   if (prop->flag & PROP_IDPROPERTY || prop->flag_internal & PROP_INTERN_BUILTIN) {
1892     return;
1893   }
1894
1895   func = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "");
1896
1897   switch (prop->type) {
1898     case PROP_BOOLEAN: {
1899       if (!prop->arraydimension) {
1900         fprintf(f, "bool %sget(PointerRNA *ptr);\n", func);
1901         fprintf(f, "void %sset(PointerRNA *ptr, bool value);\n", func);
1902       }
1903       else if (prop->arraydimension && prop->totarraylength) {
1904         fprintf(f, "void %sget(PointerRNA *ptr, bool values[%u]);\n", func, prop->totarraylength);
1905         fprintf(f,
1906                 "void %sset(PointerRNA *ptr, const bool values[%u]);\n",
1907                 func,
1908                 prop->totarraylength);
1909       }
1910       else {
1911         fprintf(f, "void %sget(PointerRNA *ptr, bool values[]);\n", func);
1912         fprintf(f, "void %sset(PointerRNA *ptr, const bool values[]);\n", func);
1913       }
1914       break;
1915     }
1916     case PROP_INT: {
1917       if (!prop->arraydimension) {
1918         fprintf(f, "int %sget(PointerRNA *ptr);\n", func);
1919         fprintf(f, "void %sset(PointerRNA *ptr, int value);\n", func);
1920       }
1921       else if (prop->arraydimension && prop->totarraylength) {
1922         fprintf(f, "void %sget(PointerRNA *ptr, int values[%u]);\n", func, prop->totarraylength);
1923         fprintf(
1924             f, "void %sset(PointerRNA *ptr, const int values[%u]);\n", func, prop->totarraylength);
1925       }
1926       else {
1927         fprintf(f, "void %sget(PointerRNA *ptr, int values[]);\n", func);
1928         fprintf(f, "void %sset(PointerRNA *ptr, const int values[]);\n", func);
1929       }
1930       break;
1931     }
1932     case PROP_FLOAT: {
1933       if (!prop->arraydimension) {
1934         fprintf(f, "float %sget(PointerRNA *ptr);\n", func);
1935         fprintf(f, "void %sset(PointerRNA *ptr, float value);\n", func);
1936       }
1937       else if (prop->arraydimension && prop->totarraylength) {
1938         fprintf(f, "void %sget(PointerRNA *ptr, float values[%u]);\n", func, prop->totarraylength);
1939         fprintf(f,
1940                 "void %sset(PointerRNA *ptr, const float values[%u]);\n",
1941                 func,
1942                 prop->totarraylength);
1943       }
1944       else {
1945         fprintf(f, "void %sget(PointerRNA *ptr, float values[]);\n", func);
1946         fprintf(f, "void %sset(PointerRNA *ptr, const float values[]);", func);
1947       }
1948       break;
1949     }
1950     case PROP_ENUM: {
1951       EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
1952       int i;
1953
1954       if (eprop->item && eprop->totitem) {
1955         fprintf(f, "enum {\n");
1956
1957         for (i = 0; i < eprop->totitem; i++) {
1958           if (eprop->item[i].identifier[0]) {
1959             fprintf(f,
1960                     "\t%s_%s_%s = %d,\n",
1961                     srna->identifier,
1962                     prop->identifier,
1963                     eprop->item[i].identifier,
1964                     eprop->item[i].value);
1965           }
1966         }
1967
1968         fprintf(f, "};\n\n");
1969       }
1970
1971       fprintf(f, "int %sget(PointerRNA *ptr);\n", func);
1972       fprintf(f, "void %sset(PointerRNA *ptr, int value);\n", func);
1973
1974       break;
1975     }
1976     case PROP_STRING: {
1977       StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
1978
1979       if (sprop->maxlength) {
1980         fprintf(
1981             f, "#define %s_%s_MAX %d\n\n", srna->identifier, prop->identifier, sprop->maxlength);
1982       }
1983
1984       fprintf(f, "void %sget(PointerRNA *ptr, char *value);\n", func);
1985       fprintf(f, "int %slength(PointerRNA *ptr);\n", func);
1986       fprintf(f, "void %sset(PointerRNA *ptr, const char *value);\n", func);
1987
1988       break;
1989     }
1990     case PROP_POINTER: {
1991       fprintf(f, "PointerRNA %sget(PointerRNA *ptr);\n", func);
1992       /*fprintf(f, "void %sset(PointerRNA *ptr, PointerRNA value);\n", func); */
1993       break;
1994     }
1995     case PROP_COLLECTION: {
1996       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
1997       fprintf(f, "void %sbegin(CollectionPropertyIterator *iter, PointerRNA *ptr);\n", func);
1998       fprintf(f, "void %snext(CollectionPropertyIterator *iter);\n", func);
1999       fprintf(f, "void %send(CollectionPropertyIterator *iter);\n", func);
2000       if (cprop->length) {
2001         fprintf(f, "int %slength(PointerRNA *ptr);\n", func);
2002       }
2003       if (cprop->lookupint) {
2004         fprintf(f, "int %slookup_int(PointerRNA *ptr, int key, PointerRNA *r_ptr);\n", func);
2005       }
2006       if (cprop->lookupstring) {
2007         fprintf(f,
2008                 "int %slookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr);\n",
2009                 func);
2010       }
2011       break;
2012     }
2013   }
2014
2015   if (prop->getlength) {
2016     char funcname[2048];
2017     rna_construct_wrapper_function_name(
2018         funcname, sizeof(funcname), srna->identifier, prop->identifier, "get_length");
2019     fprintf(f, "int %s(PointerRNA *ptr, int *arraylen);\n", funcname);
2020   }
2021
2022   fprintf(f, "\n");
2023 }
2024
2025 static void rna_def_function_funcs_header(FILE *f, StructRNA *srna, FunctionDefRNA *dfunc)
2026 {
2027   FunctionRNA *func = dfunc->func;
2028   char funcname[2048];
2029
2030   rna_construct_wrapper_function_name(
2031       funcname, sizeof(funcname), srna->identifier, func->identifier, "func");
2032   rna_generate_static_parameter_prototypes(f, srna, dfunc, funcname, 1);
2033 }
2034
2035 static void rna_def_property_funcs_header_cpp(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
2036 {
2037   PropertyRNA *prop;
2038
2039   prop = dp->prop;
2040
2041   if (prop->flag & PROP_IDPROPERTY || prop->flag_internal & PROP_INTERN_BUILTIN) {
2042     return;
2043   }
2044
2045   /* disabled for now to avoid msvc compiler error due to large file size */
2046 #if 0
2047   if (prop->name && prop->description && prop->description[0] != '\0') {
2048     fprintf(f, "\t/* %s: %s */\n", prop->name, prop->description);
2049   }
2050   else if (prop->name) {
2051     fprintf(f, "\t/* %s */\n", prop->name);
2052   }
2053   else {
2054     fprintf(f, "\t/* */\n");
2055   }
2056 #endif
2057
2058   switch (prop->type) {
2059     case PROP_BOOLEAN: {
2060       if (!prop->arraydimension) {
2061         fprintf(f, "\tinline bool %s(void);\n", rna_safe_id(prop->identifier));
2062         fprintf(f, "\tinline void %s(bool value);", rna_safe_id(prop->identifier));
2063       }
2064       else if (prop->totarraylength) {
2065         fprintf(f,
2066                 "\tinline Array<bool, %u> %s(void);\n",
2067                 prop->totarraylength,
2068                 rna_safe_id(prop->identifier));
2069         fprintf(f,
2070                 "\tinline void %s(bool values[%u]);",
2071                 rna_safe_id(prop->identifier),
2072                 prop->totarraylength);
2073       }
2074       else if (prop->getlength) {
2075         fprintf(f, "\tinline DynamicArray<bool> %s(void);\n", rna_safe_id(prop->identifier));
2076         fprintf(f, "\tinline void %s(bool values[]);", rna_safe_id(prop->identifier));
2077       }
2078       break;
2079     }
2080     case PROP_INT: {
2081       if (!prop->arraydimension) {
2082         fprintf(f, "\tinline int %s(void);\n", rna_safe_id(prop->identifier));
2083         fprintf(f, "\tinline void %s(int value);", rna_safe_id(prop->identifier));
2084       }
2085       else if (prop->totarraylength) {
2086         fprintf(f,
2087                 "\tinline Array<int, %u> %s(void);\n",
2088                 prop->totarraylength,
2089                 rna_safe_id(prop->identifier));
2090         fprintf(f,
2091                 "\tinline void %s(int values[%u]);",
2092                 rna_safe_id(prop->identifier),
2093                 prop->totarraylength);
2094       }
2095       else if (prop->getlength) {
2096         fprintf(f, "\tinline DynamicArray<int> %s(void);\n", rna_safe_id(prop->identifier));
2097         fprintf(f, "\tinline void %s(int values[]);", rna_safe_id(prop->identifier));
2098       }
2099       break;
2100     }
2101     case PROP_FLOAT: {
2102       if (!prop->arraydimension) {
2103         fprintf(f, "\tinline float %s(void);\n", rna_safe_id(prop->identifier));
2104         fprintf(f, "\tinline void %s(float value);", rna_safe_id(prop->identifier));
2105       }
2106       else if (prop->totarraylength) {
2107         fprintf(f,
2108                 "\tinline Array<float, %u> %s(void);\n",
2109                 prop->totarraylength,
2110                 rna_safe_id(prop->identifier));
2111         fprintf(f,
2112                 "\tinline void %s(float values[%u]);",
2113                 rna_safe_id(prop->identifier),
2114                 prop->totarraylength);
2115       }
2116       else if (prop->getlength) {
2117         fprintf(f, "\tinline DynamicArray<float> %s(void);\n", rna_safe_id(prop->identifier));
2118         fprintf(f, "\tinline void %s(float values[]);", rna_safe_id(prop->identifier));
2119       }
2120       break;
2121     }
2122     case PROP_ENUM: {
2123       EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
2124       int i;
2125
2126       if (eprop->item) {
2127         fprintf(f, "\tenum %s_enum {\n", rna_safe_id(prop->identifier));
2128
2129         for (i = 0; i < eprop->totitem; i++) {
2130           if (eprop->item[i].identifier[0]) {
2131             fprintf(f,
2132                     "\t\t%s_%s = %d,\n",
2133                     rna_safe_id(prop->identifier),
2134                     eprop->item[i].identifier,
2135                     eprop->item[i].value);
2136           }
2137         }
2138
2139         fprintf(f, "\t};\n");
2140       }
2141
2142       fprintf(f,
2143               "\tinline %s_enum %s(void);\n",
2144               rna_safe_id(prop->identifier),
2145               rna_safe_id(prop->identifier));
2146       fprintf(f,
2147               "\tinline void %s(%s_enum value);",
2148               rna_safe_id(prop->identifier),
2149               rna_safe_id(prop->identifier));
2150       break;
2151     }
2152     case PROP_STRING: {
2153       fprintf(f, "\tinline std::string %s(void);\n", rna_safe_id(prop->identifier));
2154       fprintf(f, "\tinline void %s(const std::string& value);", rna_safe_id(prop->identifier));
2155       break;
2156     }
2157     case PROP_POINTER: {
2158       PointerPropertyRNA *pprop = (PointerPropertyRNA *)dp->prop;
2159
2160       if (pprop->type) {
2161         fprintf(
2162             f, "\tinline %s %s(void);", (const char *)pprop->type, rna_safe_id(prop->identifier));
2163       }
2164       else {
2165         fprintf(f, "\tinline %s %s(void);", "UnknownType", rna_safe_id(prop->identifier));
2166       }
2167       break;
2168     }
2169     case PROP_COLLECTION: {
2170       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)dp->prop;
2171       const char *collection_funcs = "DefaultCollectionFunctions";
2172
2173       if (!(dp->prop->flag & PROP_IDPROPERTY || dp->prop->flag_internal & PROP_INTERN_BUILTIN) &&
2174           cprop->property.srna) {
2175         collection_funcs = (char *)cprop->property.srna;
2176       }
2177
2178       if (cprop->item_type) {
2179         fprintf(f,
2180                 "\tCOLLECTION_PROPERTY(%s, %s, %s, %s, %s, %s, %s)",
2181                 collection_funcs,
2182                 (const char *)cprop->item_type,
2183                 srna->identifier,
2184                 rna_safe_id(prop->identifier),
2185                 (cprop->length ? "true" : "false"),
2186                 (cprop->lookupint ? "true" : "false"),
2187                 (cprop->lookupstring ? "true" : "false"));
2188       }
2189       else {
2190         fprintf(f,
2191                 "\tCOLLECTION_PROPERTY(%s, %s, %s, %s, %s, %s, %s)",
2192                 collection_funcs,
2193                 "UnknownType",
2194                 srna->identifier,
2195                 rna_safe_id(prop->identifier),
2196                 (cprop->length ? "true" : "false"),
2197                 (cprop->lookupint ? "true" : "false"),
2198                 (cprop->lookupstring ? "true" : "false"));
2199       }
2200       break;
2201     }
2202   }
2203
2204   fprintf(f, "\n");
2205 }
2206
2207 static const char *rna_parameter_type_cpp_name(PropertyRNA *prop)
2208 {
2209   if (prop->type == PROP_POINTER) {
2210     /* for cpp api we need to use RNA structures names for pointers */
2211     PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
2212
2213     return (const char *)pprop->type;
2214   }
2215   else {
2216     return rna_parameter_type_name(prop);
2217   }
2218 }
2219
2220 static void rna_def_struct_function_prototype_cpp(FILE *f,
2221                                                   StructRNA *UNUSED(srna),
2222                                                   FunctionDefRNA *dfunc,
2223                                                   const char *namespace,
2224                                                   int close_prototype)
2225 {
2226   PropertyDefRNA *dp;
2227   FunctionRNA *func = dfunc->func;
2228
2229   int first = 1;
2230   const char *retval_type = "void";
2231
2232   if (func->c_ret) {
2233     dp = rna_find_parameter_def(func->c_ret);
2234     retval_type = rna_parameter_type_cpp_name(dp->prop);
2235   }
2236
2237   if (namespace && namespace[0]) {
2238     fprintf(f, "\tinline %s %s::%s(", retval_type, namespace, rna_safe_id(func->identifier));
2239   }
2240   else {
2241     fprintf(f, "\tinline %s %s(", retval_type, rna_safe_id(func->identifier));
2242   }
2243
2244   if (func->flag & FUNC_USE_MAIN) {
2245     WRITE_PARAM("void *main");
2246   }
2247
2248   if (func->flag & FUNC_USE_CONTEXT) {
2249     WRITE_PARAM("Context C");
2250   }
2251
2252   for (dp = dfunc->cont.properties.first; dp; dp = dp->next) {
2253     int type, flag, flag_parameter, pout;
2254     const char *ptrstr;
2255
2256     if (dp->prop == func->c_ret) {
2257       continue;
2258     }
2259
2260     type = dp->prop->type;
2261     flag = dp->prop->flag;
2262     flag_parameter = dp->prop->flag_parameter;
2263     pout = (flag_parameter & PARM_OUTPUT);
2264
2265     if (flag & PROP_DYNAMIC) {
2266       ptrstr = pout ? "**" : "*";
2267     }
2268     else if (type == PROP_POINTER) {
2269       ptrstr = pout ? "*" : "";
2270     }
2271     else if (dp->prop->arraydimension) {
2272       ptrstr = "*";
2273     }
2274     else if (type == PROP_STRING && (flag & PROP_THICK_WRAP)) {
2275       ptrstr = "";
2276     }
2277     else {
2278       ptrstr = pout ? "*" : "";
2279     }
2280
2281     WRITE_COMMA;
2282
2283     if (flag & PROP_DYNAMIC) {
2284       fprintf(
2285           f, "int %s%s_len, ", (flag_parameter & PARM_OUTPUT) ? "*" : "", dp->prop->identifier);
2286     }
2287
2288     if (!(flag & PROP_DYNAMIC) && dp->prop->arraydimension) {
2289       fprintf(f,
2290               "%s %s[%u]",
2291               rna_parameter_type_cpp_name(dp->prop),
2292               rna_safe_id(dp->prop->identifier),
2293               dp->prop->totarraylength);
2294     }
2295     else {
2296       fprintf(f,
2297               "%s%s%s%s",
2298               rna_parameter_type_cpp_name(dp->prop),
2299               (dp->prop->type == PROP_POINTER && ptrstr[0] == '\0') ? "& " : " ",
2300               ptrstr,
2301               rna_safe_id(dp->prop->identifier));
2302     }
2303   }
2304
2305   fprintf(f, ")");
2306   if (close_prototype) {
2307     fprintf(f, ";\n");
2308   }
2309 }
2310
2311 static void rna_def_struct_function_header_cpp(FILE *f, StructRNA *srna, FunctionDefRNA *dfunc)
2312 {
2313   if (dfunc->call) {
2314     /* disabled for now to avoid msvc compiler error due to large file size */
2315 #if 0
2316     FunctionRNA *func = dfunc->func;
2317     fprintf(f, "\n\t/* %s */\n", func->description);
2318 #endif
2319
2320     rna_def_struct_function_prototype_cpp(f, srna, dfunc, NULL, 1);
2321   }
2322 }
2323
2324 static void rna_def_property_funcs_impl_cpp(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
2325 {
2326   PropertyRNA *prop;
2327
2328   prop = dp->prop;
2329
2330   if (prop->flag & PROP_IDPROPERTY || prop->flag_internal & PROP_INTERN_BUILTIN) {
2331     return;
2332   }
2333
2334   switch (prop->type) {
2335     case PROP_BOOLEAN: {
2336       if (!prop->arraydimension) {
2337         fprintf(f, "\tBOOLEAN_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
2338       }
2339       else if (prop->totarraylength) {
2340         fprintf(f,
2341                 "\tBOOLEAN_ARRAY_PROPERTY(%s, %u, %s)",
2342                 srna->identifier,
2343                 prop->totarraylength,
2344                 rna_safe_id(prop->identifier));
2345       }
2346       else if (prop->getlength) {
2347         fprintf(f,
2348                 "\tBOOLEAN_DYNAMIC_ARRAY_PROPERTY(%s, %s)",
2349                 srna->identifier,
2350                 rna_safe_id(prop->identifier));
2351       }
2352       break;
2353     }
2354     case PROP_INT: {
2355       if (!prop->arraydimension) {
2356         fprintf(f, "\tINT_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
2357       }
2358       else if (prop->totarraylength) {
2359         fprintf(f,
2360                 "\tINT_ARRAY_PROPERTY(%s, %u, %s)",
2361                 srna->identifier,
2362                 prop->totarraylength,
2363                 rna_safe_id(prop->identifier));
2364       }
2365       else if (prop->getlength) {
2366         fprintf(f,
2367                 "\tINT_DYNAMIC_ARRAY_PROPERTY(%s, %s)",
2368                 srna->identifier,
2369                 rna_safe_id(prop->identifier));
2370       }
2371       break;
2372     }
2373     case PROP_FLOAT: {
2374       if (!prop->arraydimension) {
2375         fprintf(f, "\tFLOAT_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
2376       }
2377       else if (prop->totarraylength) {
2378         fprintf(f,
2379                 "\tFLOAT_ARRAY_PROPERTY(%s, %u, %s)",
2380                 srna->identifier,
2381                 prop->totarraylength,
2382                 rna_safe_id(prop->identifier));
2383       }
2384       else if (prop->getlength) {
2385         fprintf(f,
2386                 "\tFLOAT_DYNAMIC_ARRAY_PROPERTY(%s, %s)",
2387                 srna->identifier,
2388                 rna_safe_id(prop->identifier));
2389       }
2390       break;
2391     }
2392     case PROP_ENUM: {
2393       fprintf(f,
2394               "\tENUM_PROPERTY(%s_enum, %s, %s)",
2395               rna_safe_id(prop->identifier),
2396               srna->identifier,
2397               rna_safe_id(prop->identifier));
2398
2399       break;
2400     }
2401     case PROP_STRING: {
2402       fprintf(f, "\tSTRING_PROPERTY(%s, %s)", srna->identifier, rna_safe_id(prop->identifier));
2403       break;
2404     }
2405     case PROP_POINTER: {
2406       PointerPropertyRNA *pprop = (PointerPropertyRNA *)dp->prop;
2407
2408       if (pprop->type) {
2409         fprintf(f,
2410                 "\tPOINTER_PROPERTY(%s, %s, %s)",
2411                 (const char *)pprop->type,
2412                 srna->identifier,
2413                 rna_safe_id(prop->identifier));
2414       }
2415       else {
2416         fprintf(f,
2417                 "\tPOINTER_PROPERTY(%s, %s, %s)",
2418                 "UnknownType",
2419                 srna->identifier,
2420                 rna_safe_id(prop->identifier));
2421       }
2422       break;
2423     }
2424     case PROP_COLLECTION: {
2425 #if 0
2426       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)dp->prop;
2427
2428       if (cprop->type) {
2429         fprintf(f,
2430                 "\tCOLLECTION_PROPERTY(%s, %s, %s, %s, %s, %s)",
2431                 (const char *)cprop->type,
2432                 srna->identifier,
2433                 prop->identifier,
2434                 (cprop->length ? "true" : "false"),
2435                 (cprop->lookupint ? "true" : "false"),
2436                 (cprop->lookupstring ? "true" : "false"));
2437       }
2438       else {
2439         fprintf(f,
2440                 "\tCOLLECTION_PROPERTY(%s, %s, %s, %s, %s, %s)",
2441                 "UnknownType",
2442                 srna->identifier,
2443                 prop->identifier,
2444                 (cprop->length ? "true" : "false"),
2445                 (cprop->lookupint ? "true" : "false"),
2446                 (cprop->lookupstring ? "true" : "false"));
2447       }
2448 #endif
2449       break;
2450     }
2451   }
2452
2453   fprintf(f, "\n");
2454 }
2455
2456 static void rna_def_struct_function_call_impl_cpp(FILE *f, StructRNA *srna, FunctionDefRNA *dfunc)
2457 {
2458   PropertyDefRNA *dp;
2459   StructDefRNA *dsrna;
2460   FunctionRNA *func = dfunc->func;
2461   char funcname[2048];
2462
2463   int first = 1;
2464
2465   rna_construct_wrapper_function_name(
2466       funcname, sizeof(funcname), srna->identifier, func->identifier, "func");
2467
2468   fprintf(f, "%s(", funcname);
2469
2470   dsrna = rna_find_struct_def(srna);
2471
2472   if (func->flag & FUNC_USE_SELF_ID) {
2473     WRITE_PARAM("(::ID *) ptr.id.data");
2474   }
2475
2476   if ((func->flag & FUNC_NO_SELF) == 0) {
2477     WRITE_COMMA;
2478     if (dsrna->dnafromprop) {
2479       fprintf(f, "(::%s *) this->ptr.data", dsrna->dnafromname);
2480     }
2481     else if (dsrna->dnaname) {
2482       fprintf(f, "(::%s *) this->ptr.data", dsrna->dnaname);
2483     }
2484     else {
2485       fprintf(f, "(::%s *) this->ptr.data", srna->identifier);
2486     }
2487   }
2488   else if (func->flag & FUNC_USE_SELF_TYPE) {
2489     WRITE_COMMA;
2490     fprintf(f, "this->ptr.type");
2491   }
2492
2493   if (func->flag & FUNC_USE_MAIN) {
2494     WRITE_PARAM("(::Main *) main");
2495   }
2496
2497   if (func->flag & FUNC_USE_CONTEXT) {
2498     WRITE_PARAM("(::bContext *) C.ptr.data");
2499   }
2500
2501   if (func->flag & FUNC_USE_REPORTS) {
2502     WRITE_PARAM("NULL");
2503   }
2504
2505   dp = dfunc->cont.properties.first;
2506   for (; dp; dp = dp->next) {
2507     if (dp->prop == func->c_ret) {
2508       continue;
2509     }
2510
2511     WRITE_COMMA;
2512
2513     if (dp->prop->flag & PROP_DYNAMIC) {
2514       fprintf(f, "%s_len, ", dp->prop->identifier);
2515     }
2516
2517     if (dp->prop->type == PROP_POINTER) {
2518       if ((dp->prop->flag_parameter & PARM_RNAPTR) && !(dp->prop->flag & PROP_THICK_WRAP)) {
2519         fprintf(f,
2520                 "(::%s *) &%s.ptr",
2521                 rna_parameter_type_name(dp->prop),
2522                 rna_safe_id(dp->prop->identifier));
2523       }
2524       else if (dp->prop->flag_parameter & PARM_OUTPUT) {
2525         if (dp->prop->flag_parameter & PARM_RNAPTR) {
2526           fprintf(f, "&%s->ptr", rna_safe_id(dp->prop->identifier));
2527         }
2528         else {
2529           fprintf(f,
2530                   "(::%s **) &%s->ptr.data",
2531                   rna_parameter_type_name(dp->prop),
2532                   rna_safe_id(dp->prop->identifier));
2533         }
2534       }
2535       else {
2536         fprintf(f,
2537                 "(::%s *) %s.ptr.data",
2538                 rna_parameter_type_name(dp->prop),
2539                 rna_safe_id(dp->prop->identifier));
2540       }
2541     }
2542     else {
2543       fprintf(f, "%s", rna_safe_id(dp->prop->identifier));
2544     }
2545   }
2546
2547   fprintf(f, ");\n");
2548 }
2549
2550 static void rna_def_struct_function_impl_cpp(FILE *f, StructRNA *srna, FunctionDefRNA *dfunc)
2551 {
2552   PropertyDefRNA *dp;
2553   PointerPropertyRNA *pprop;
2554
2555   FunctionRNA *func = dfunc->func;
2556
2557   if (!dfunc->call) {
2558     return;
2559   }
2560
2561   rna_def_struct_function_prototype_cpp(f, srna, dfunc, srna->identifier, 0);
2562
2563   fprintf(f, " {\n");
2564
2565   if (func->c_ret) {
2566     dp = rna_find_parameter_def(func->c_ret);
2567
2568     if (dp->prop->type == PROP_POINTER) {
2569       pprop = (PointerPropertyRNA *)dp->prop;
2570
2571       fprintf(f, "\t\tPointerRNA result;\n");
2572
2573       if ((dp->prop->flag_parameter & PARM_RNAPTR) == 0) {
2574         StructRNA *ret_srna = rna_find_struct((const char *)pprop->type);
2575         fprintf(f, "\t\t::%s *retdata = ", rna_parameter_type_name(dp->prop));
2576         rna_def_struct_function_call_impl_cpp(f, srna, dfunc);
2577         if (ret_srna->flag & STRUCT_ID) {
2578           fprintf(f, "\t\tRNA_id_pointer_create((::ID *) retdata, &result);\n");
2579         }
2580         else {
2581           fprintf(f,
2582                   "\t\tRNA_pointer_create((::ID *) ptr.id.data, &RNA_%s, retdata, &result);\n",
2583                   (const char *)pprop->type);
2584         }
2585       }
2586       else {
2587         fprintf(f, "\t\tresult = ");
2588         rna_def_struct_function_call_impl_cpp(f, srna, dfunc);
2589       }
2590
2591       fprintf(f, "\t\treturn %s(result);\n", (const char *)pprop->type);
2592     }
2593     else {
2594       fprintf(f, "\t\treturn ");
2595       rna_def_struct_function_call_impl_cpp(f, srna, dfunc);
2596     }
2597   }
2598   else {
2599     fprintf(f, "\t\t");
2600     rna_def_struct_function_call_impl_cpp(f, srna, dfunc);
2601   }
2602
2603   fprintf(f, "\t}\n\n");
2604 }
2605
2606 static void rna_def_property_wrapper_funcs(FILE *f, StructDefRNA *dsrna, PropertyDefRNA *dp)
2607 {
2608   if (dp->prop->getlength) {
2609     char funcname[2048];
2610     rna_construct_wrapper_function_name(
2611         funcname, sizeof(funcname), dsrna->srna->identifier, dp->prop->identifier, "get_length");
2612     fprintf(f, "int %s(PointerRNA *ptr, int *arraylen)\n", funcname);
2613     fprintf(f, "{\n");
2614     fprintf(f, "\treturn %s(ptr, arraylen);\n", rna_function_string(dp->prop->getlength));
2615     fprintf(f, "}\n\n");
2616   }
2617 }
2618
2619 static void rna_def_function_wrapper_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA *dfunc)
2620 {
2621   StructRNA *srna = dsrna->srna;
2622   FunctionRNA *func = dfunc->func;
2623   PropertyDefRNA *dparm;
2624
2625   int first;
2626   char funcname[2048];
2627
2628   if (!dfunc->call) {
2629     return;
2630   }
2631
2632   rna_construct_wrapper_function_name(
2633       funcname, sizeof(funcname), srna->identifier, func->identifier, "func");
2634
2635   rna_generate_static_parameter_prototypes(f, srna, dfunc, funcname, 0);
2636
2637   fprintf(f, "\n{\n");
2638
2639   if (func->c_ret) {
2640     fprintf(f, "\treturn %s(", dfunc->call);
2641   }
2642   else {
2643     fprintf(f, "\t%s(", dfunc->call);
2644   }
2645
2646   first = 1;
2647
2648   if (func->flag & FUNC_USE_SELF_ID) {
2649     WRITE_PARAM("_selfid");
2650   }
2651
2652   if ((func->flag & FUNC_NO_SELF) == 0) {
2653     WRITE_PARAM("_self");
2654   }
2655   else if (func->flag & FUNC_USE_SELF_TYPE) {
2656     WRITE_PARAM("_type");
2657   }
2658
2659   if (func->flag & FUNC_USE_MAIN) {
2660     WRITE_PARAM("bmain");
2661   }
2662
2663   if (func->flag & FUNC_USE_CONTEXT) {
2664     WRITE_PARAM("C");
2665   }
2666
2667   if (func->flag & FUNC_USE_REPORTS) {
2668     WRITE_PARAM("reports");
2669   }
2670
2671   dparm = dfunc->cont.properties.first;
2672   for (; dparm; dparm = dparm->next) {
2673     if (dparm->prop == func->c_ret) {
2674       continue;
2675     }
2676
2677     WRITE_COMMA;
2678
2679     if (dparm->prop->flag & PROP_DYNAMIC) {
2680       fprintf(f, "%s_len, %s", dparm->prop->identifier, dparm->prop->identifier);
2681     }
2682     else {
2683       fprintf(f, "%s", rna_safe_id(dparm->prop->identifier));
2684     }
2685   }
2686
2687   fprintf(f, ");\n");
2688   fprintf(f, "}\n\n");
2689 }
2690
2691 static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA *dfunc)
2692 {
2693   StructRNA *srna;
2694   FunctionRNA *func;
2695   PropertyDefRNA *dparm;
2696   PropertyType type;
2697   const char *funcname, *valstr;
2698   const char *ptrstr;
2699   const bool has_data = (dfunc->cont.properties.first != NULL);
2700   int flag, flag_parameter, pout, cptr, first;
2701
2702   srna = dsrna->srna;
2703   func = dfunc->func;
2704
2705   if (!dfunc->call) {
2706     return;
2707   }
2708
2709   funcname = rna_alloc_function_name(srna->identifier, func->identifier, "call");
2710
2711   /* function definition */
2712   fprintf(f,
2713           "void %s(bContext *C, ReportList *reports, PointerRNA *_ptr, ParameterList *_parms)",
2714           funcname);
2715   fprintf(f, "\n{\n");
2716
2717   /* variable definitions */
2718
2719   if (func->flag & FUNC_USE_SELF_ID) {
2720     fprintf(f, "\tstruct ID *_selfid;\n");
2721   }
2722
2723   if ((func->flag & FUNC_NO_SELF) == 0) {
2724     if (dsrna->dnafromprop) {
2725       fprintf(f, "\tstruct %s *_self;\n", dsrna->dnafromname);
2726     }
2727     else if (dsrna->dnaname) {
2728       fprintf(f, "\tstruct %s *_self;\n", dsrna->dnaname);
2729     }
2730     else {
2731       fprintf(f, "\tstruct %s *_self;\n", srna->identifier);
2732     }
2733   }
2734   else if (func->flag & FUNC_USE_SELF_TYPE) {
2735     fprintf(f, "\tstruct StructRNA *_type;\n");
2736   }
2737
2738   dparm = dfunc->cont.properties.first;
2739   for (; dparm; dparm = dparm->next) {
2740     type = dparm->prop->type;
2741     flag = dparm->prop->flag;
2742     flag_parameter = dparm->prop->flag_parameter;
2743     pout = (flag_parameter & PARM_OUTPUT);
2744     cptr = ((type == PROP_POINTER) && !(flag_parameter & PARM_RNAPTR));
2745
2746     if (dparm->prop == func->c_ret) {
2747       ptrstr = cptr || dparm->prop->arraydimension ? "*" : "";
2748       /* XXX only arrays and strings are allowed to be dynamic, is this checked anywhere? */
2749     }
2750     else if (cptr || (flag & PROP_DYNAMIC)) {
2751       ptrstr = pout ? "**" : "*";
2752       /* Fixed size arrays and RNA pointers are pre-allocated on the ParameterList stack,
2753        * pass a pointer to it. */
2754     }
2755     else if (type == PROP_POINTER || dparm->prop->arraydimension) {
2756       ptrstr = "*";
2757     }
2758     else if ((type == PROP_POINTER) && (flag_parameter & PARM_RNAPTR) &&
2759              !(flag & PROP_THICK_WRAP)) {
2760       ptrstr = "*";
2761       /* PROP_THICK_WRAP strings are pre-allocated on the ParameterList stack,
2762        * but type name for string props is already (char *), so leave empty */
2763     }
2764     else if (type == PROP_STRING && (flag & PROP_THICK_WRAP)) {
2765       ptrstr = "";
2766     }
2767     else {
2768       ptrstr = pout ? "*" : "";
2769     }
2770
2771     /* for dynamic parameters we pass an additional int for the length of the parameter */
2772     if (flag & PROP_DYNAMIC) {
2773       fprintf(f, "\tint %s%s_len;\n", pout ? "*" : "", dparm->prop->identifier);
2774     }
2775
2776     fprintf(f,
2777             "\t%s%s %s%s;\n",
2778             rna_type_struct(dparm->prop),
2779             rna_parameter_type_name(dparm->prop),
2780             ptrstr,
2781             dparm->prop->identifier);
2782   }
2783
2784   if (has_data) {
2785     fprintf(f, "\tchar *_data");
2786     if (func->c_ret) {
2787       fprintf(f, ", *_retdata");
2788     }
2789     fprintf(f, ";\n");
2790     fprintf(f, "\t\n");
2791   }
2792
2793   /* assign self */
2794   if (func->flag & FUNC_USE_SELF_ID) {
2795     fprintf(f, "\t_selfid = (struct ID *)_ptr->id.data;\n");
2796   }
2797
2798   if ((func->flag & FUNC_NO_SELF) == 0) {
2799     if (dsrna->dnafromprop) {
2800       fprintf(f, "\t_self = (struct %s *)_ptr->data;\n", dsrna->dnafromname);
2801     }
2802     else if (dsrna->dnaname) {
2803       fprintf(f, "\t_self = (struct %s *)_ptr->data;\n", dsrna->dnaname);
2804     }
2805     else {
2806       fprintf(f, "\t_self = (struct %s *)_ptr->data;\n", srna->identifier);
2807     }
2808   }
2809   else if (func->flag & FUNC_USE_SELF_TYPE) {
2810     fprintf(f, "\t_type = _ptr->type;\n");
2811   }
2812
2813   if (has_data) {
2814     fprintf(f, "\t_data = (char *)_parms->data;\n");
2815   }
2816
2817   dparm = dfunc->cont.properties.first;
2818   for (; dparm; dparm = dparm->next) {
2819     type = dparm->prop->type;
2820     flag = dparm->prop->flag;
2821     flag_parameter = dparm->prop->flag_parameter;
2822     pout = (flag_parameter & PARM_OUTPUT);
2823     cptr = ((type == PROP_POINTER) && !(flag_parameter & PARM_RNAPTR));
2824
2825     if (dparm->prop == func->c_ret) {
2826       fprintf(f, "\t_retdata = _data;\n");
2827     }
2828     else {
2829       const char *data_str;
2830       if (cptr || (flag & PROP_DYNAMIC)) {
2831         ptrstr = "**";
2832         valstr = "*";
2833       }
2834       else if ((type == PROP_POINTER) && !(flag & PROP_THICK_WRAP)) {
2835         ptrstr = "**";
2836         valstr = "*";
2837       }
2838       else if (type == PROP_POINTER || dparm->prop->arraydimension) {
2839         ptrstr = "*";
2840         valstr = "";
2841       }
2842       else if (type == PROP_STRING && (flag & PROP_THICK_WRAP)) {
2843         ptrstr = "";
2844         valstr = "";
2845       }
2846       else {
2847         ptrstr = "*";
2848         valstr = "*";
2849       }
2850
2851       /* This must be kept in sync with RNA_parameter_dynamic_length_get_data and
2852        * RNA_parameter_get, we could just call the function directly, but this is faster. */
2853       if (flag & PROP_DYNAMIC) {
2854         fprintf(f,
2855                 "\t%s_len = %s((ParameterDynAlloc *)_data)->array_tot;\n",
2856                 dparm->prop->identifier,
2857                 pout ? "(int *)&" : "(int)");
2858         data_str = "(&(((ParameterDynAlloc *)_data)->array))";
2859       }
2860       else {
2861         data_str = "_data";
2862       }
2863       fprintf(f, "\t%s = ", dparm->prop->identifier);
2864
2865       if (!pout) {
2866         fprintf(f, "%s", valstr);
2867       }
2868
2869       fprintf(f,
2870               "((%s%s %s)%s);\n",
2871               rna_type_struct(dparm->prop),
2872               rna_parameter_type_name(dparm->prop),
2873               ptrstr,
2874               data_str);
2875     }
2876
2877     if (dparm->next) {
2878       fprintf(f, "\t_data += %d;\n", rna_parameter_size(dparm->prop));
2879     }
2880   }
2881
2882   if (dfunc->call) {
2883     fprintf(f, "\t\n");
2884     fprintf(f, "\t");
2885     if (func->c_ret) {
2886       fprintf(f, "%s = ", func->c_ret->identifier);
2887     }
2888     fprintf(f, "%s(", dfunc->call);
2889
2890     first = 1;
2891
2892     if (func->flag & FUNC_USE_SELF_ID) {
2893       fprintf(f, "_selfid");
2894       first = 0;
2895     }
2896
2897     if ((func->flag & FUNC_NO_SELF) == 0) {
2898       if (!first) {
2899         fprintf(f, ", ");
2900       }
2901       fprintf(f, "_self");
2902       first = 0;
2903     }
2904     else if (func->flag & FUNC_USE_SELF_TYPE) {
2905       if (!first) {
2906         fprintf(f, ", ");
2907       }
2908       fprintf(f, "_type");
2909       first = 0;
2910     }
2911
2912     if (func->flag & FUNC_USE_MAIN) {
2913       if (!first) {
2914         fprintf(f, ", ");
2915       }
2916       first = 0;
2917       fprintf(f, "CTX_data_main(C)"); /* may have direct access later */
2918     }
2919
2920     if (func->flag & FUNC_USE_CONTEXT) {
2921       if (!first) {
2922         fprintf(f, ", ");
2923       }
2924       first = 0;
2925       fprintf(f, "C");
2926     }
2927
2928     if (func->flag & FUNC_USE_REPORTS) {
2929       if (!first) {
2930         fprintf(f, ", ");
2931       }
2932       first = 0;
2933       fprintf(f, "reports");
2934     }
2935
2936     dparm = dfunc->cont.properties.first;
2937     for (; dparm; dparm = dparm->next) {
2938       if (dparm->prop == func->c_ret) {
2939         continue;
2940       }
2941
2942       if (!first) {
2943         fprintf(f, ", ");
2944       }
2945       first = 0;
2946
2947       if (dparm->prop->flag & PROP_DYNAMIC) {
2948         fprintf(f, "%s_len, %s", dparm->prop->identifier, dparm->prop->identifier);
2949       }
2950       else {
2951         fprintf(f, "%s", dparm->prop->identifier);
2952       }
2953     }
2954
2955     fprintf(f, ");\n");
2956
2957     if (func->c_ret) {
2958       dparm = rna_find_parameter_def(func->c_ret);
2959       ptrstr = (((dparm->prop->type == PROP_POINTER) &&
2960                  !(dparm->prop->flag_parameter & PARM_RNAPTR)) ||
2961                 (dparm->prop->arraydimension)) ?
2962                    "*" :
2963                    "";
2964       fprintf(f,
2965               "\t*((%s%s %s*)_retdata) = %s;\n",
2966               rna_type_struct(dparm->prop),
2967               rna_parameter_type_name(dparm->prop),
2968               ptrstr,
2969               func->c_ret->identifier);
2970     }
2971   }
2972
2973   fprintf(f, "}\n\n");
2974
2975   dfunc->gencall = funcname;
2976 }
2977
2978 static void rna_auto_types(void)
2979 {
2980   StructDefRNA *ds;
2981   PropertyDefRNA *dp;
2982
2983   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
2984     /* DNA name for Screen is patched in 2.5, we do the reverse here .. */
2985     if (ds->dnaname) {
2986       if (STREQ(ds->dnaname, "Screen")) {
2987         ds->dnaname = "bScreen";
2988       }
2989       if (STREQ(ds->dnaname, "Group")) {
2990         ds->dnaname = "Collection";
2991       }
2992       if (STREQ(ds->dnaname, "GroupObject")) {
2993         ds->dnaname = "CollectionObject";
2994       }
2995     }
2996
2997     for (dp = ds->cont.properties.first; dp; dp = dp->next) {
2998       if (dp->dnastructname) {
2999         if (STREQ(dp->dnastructname, "Screen")) {
3000           dp->dnastructname = "bScreen";
3001         }
3002         if (STREQ(dp->dnastructname, "Group")) {
3003           dp->dnastructname = "Collection";
3004         }
3005         if (STREQ(dp->dnastructname, "GroupObject")) {
3006           dp->dnastructname = "CollectionObject";
3007         }
3008       }
3009
3010       if (dp->dnatype) {
3011         if (dp->prop->type == PROP_POINTER) {
3012           PointerPropertyRNA *pprop = (PointerPropertyRNA *)dp->prop;
3013           StructRNA *type;
3014
3015           if (!pprop->type && !pprop->get) {
3016             pprop->type = (StructRNA *)rna_find_type(dp->dnatype);
3017           }
3018
3019           if (pprop->type) {
3020             type = rna_find_struct((const char *)pprop->type);
3021             if (type && (type->flag & STRUCT_ID_REFCOUNT)) {
3022               pprop->property.flag |= PROP_ID_REFCOUNT;
3023             }
3024           }
3025         }
3026         else if (dp->prop->type == PROP_COLLECTION) {
3027           CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)dp->prop;
3028
3029           if (!cprop->item_type && !cprop->get && STREQ(dp->dnatype, "ListBase")) {
3030             cprop->item_type = (StructRNA *)rna_find_type(dp->dnatype);
3031           }
3032         }
3033       }
3034     }
3035   }
3036 }
3037
3038 static void rna_sort(BlenderRNA *brna)
3039 {
3040   StructDefRNA *ds;
3041   StructRNA *srna;
3042
3043   rna_sortlist(&brna->structs, cmp_struct);
3044   rna_sortlist(&DefRNA.structs, cmp_def_struct);
3045
3046   for (srna = brna->structs.first; srna; srna = srna->cont.next) {
3047     rna_sortlist(&srna->cont.properties, cmp_property);
3048   }
3049
3050   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
3051     rna_sortlist(&ds->cont.properties, cmp_def_property);
3052   }
3053 }
3054
3055 static const char *rna_property_structname(PropertyType type)
3056 {
3057   switch (type) {
3058     case PROP_BOOLEAN:
3059       return "BoolPropertyRNA";
3060     case PROP_INT:
3061       return "IntPropertyRNA";
3062     case PROP_FLOAT:
3063       return "FloatPropertyRNA";
3064     case PROP_STRING:
3065       return "StringPropertyRNA";
3066     case PROP_ENUM:
3067       return "EnumPropertyRNA";
3068     case PROP_POINTER:
3069       return "PointerPropertyRNA";
3070     case PROP_COLLECTION:
3071       return "CollectionPropertyRNA";
3072     default:
3073       return "UnknownPropertyRNA";
3074   }
3075 }
3076
3077 static const char *rna_property_subtypename(PropertySubType type)
3078 {
3079   switch (type) {
3080     case PROP_NONE:
3081       return "PROP_NONE";
3082     case PROP_FILEPATH:
3083       return "PROP_FILEPATH";
3084     case PROP_FILENAME:
3085       return "PROP_FILENAME";
3086     case PROP_DIRPATH:
3087       return "PROP_DIRPATH";
3088     case PROP_PIXEL:
3089       return "PROP_PIXEL";
3090     case PROP_BYTESTRING:
3091       return "PROP_BYTESTRING";
3092     case PROP_UNSIGNED:
3093       return "PROP_UNSIGNED";
3094     case PROP_PERCENTAGE:
3095       return "PROP_PERCENTAGE";
3096     case PROP_FACTOR:
3097       return "PROP_FACTOR";
3098     case PROP_ANGLE:
3099       return "PROP_ANGLE";
3100     case PROP_TIME:
3101       return "PROP_TIME";
3102     case PROP_DISTANCE:
3103       return "PROP_DISTANCE";
3104     case PROP_DISTANCE_CAMERA:
3105       return "PROP_DISTANCE_CAMERA";
3106     case PROP_COLOR:
3107       return "PROP_COLOR";
3108     case PROP_TRANSLATION:
3109       return "PROP_TRANSLATION";
3110     case PROP_DIRECTION:
3111       return "PROP_DIRECTION";
3112     case PROP_MATRIX:
3113       return "PROP_MATRIX";
3114     case PROP_EULER:
3115       return "PROP_EULER";
3116     case PROP_QUATERNION:
3117       return "PROP_QUATERNION";
3118     case PROP_AXISANGLE:
3119       return "PROP_AXISANGLE";
3120     case PROP_VELOCITY:
3121       return "PROP_VELOCITY";
3122     case PROP_ACCELERATION:
3123       return "PROP_ACCELERATION";
3124     case PROP_XYZ:
3125       return "PROP_XYZ";
3126     case PROP_COLOR_GAMMA:
3127       return "PROP_COLOR_GAMMA";
3128     case PROP_COORDS:
3129       return "PROP_COORDS";
3130     case PROP_LAYER:
3131       return "PROP_LAYER";
3132     case PROP_LAYER_MEMBER:
3133       return "PROP_LAYER_MEMBER";
3134     case PROP_PASSWORD:
3135       return "PROP_PASSWORD";
3136     case PROP_POWER:
3137       return "PROP_POWER";
3138     default: {
3139       /* in case we don't have a type preset that includes the subtype */
3140       if (RNA_SUBTYPE_UNIT(type)) {
3141         return rna_property_subtypename(type & ~RNA_SUBTYPE_UNIT(type));
3142       }
3143       else {
3144         return "PROP_SUBTYPE_UNKNOWN";
3145       }
3146     }
3147   }
3148 }
3149
3150 static const char *rna_property_subtype_unit(PropertySubType type)
3151 {
3152   switch (RNA_SUBTYPE_UNIT(type)) {
3153     case PROP_UNIT_NONE:
3154       return "PROP_UNIT_NONE";
3155     case PROP_UNIT_LENGTH:
3156       return "PROP_UNIT_LENGTH";
3157     case PROP_UNIT_AREA:
3158       return "PROP_UNIT_AREA";
3159     case PROP_UNIT_VOLUME:
3160       return "PROP_UNIT_VOLUME";
3161     case PROP_UNIT_MASS:
3162       return "PROP_UNIT_MASS";
3163     case PROP_UNIT_ROTATION:
3164       return "PROP_UNIT_ROTATION";
3165     case PROP_UNIT_TIME:
3166       return "PROP_UNIT_TIME";
3167     case PROP_UNIT_VELOCITY:
3168       return "PROP_UNIT_VELOCITY";
3169     case PROP_UNIT_ACCELERATION:
3170       return "PROP_UNIT_ACCELERATION";
3171     case PROP_UNIT_CAMERA:
3172       return "PROP_UNIT_CAMERA";
3173     case PROP_UNIT_POWER:
3174       return "PROP_UNIT_POWER";
3175     default:
3176       return "PROP_UNIT_UNKNOWN";
3177   }
3178 }
3179
3180 static void rna_generate_prototypes(BlenderRNA *brna, FILE *f)
3181 {
3182   StructRNA *srna;
3183
3184   for (srna = brna->structs.first; srna; srna = srna->cont.next) {
3185     fprintf(f, "extern StructRNA RNA_%s;\n", srna->identifier);
3186   }
3187   fprintf(f, "\n");
3188 }
3189
3190 static void rna_generate_blender(BlenderRNA *brna, FILE *f)
3191 {
3192   StructRNA *srna;
3193
3194   fprintf(f,
3195           "BlenderRNA BLENDER_RNA = {\n"
3196           "\t.structs = {");
3197   srna = brna->structs.first;
3198   if (srna) {
3199     fprintf(f, "&RNA_%s, ", srna->identifier);
3200   }
3201   else {
3202     fprintf(f, "NULL, ");
3203   }
3204
3205   srna = brna->structs.last;
3206   if (srna) {
3207     fprintf(f, "&RNA_%s},\n", srna->identifier);
3208   }
3209   else {
3210     fprintf(f, "NULL},\n");
3211   }
3212
3213   fprintf(f,
3214           "\t.structs_map = NULL,\n"
3215           "\t.structs_len = 0,\n"
3216           "};\n\n");
3217 }
3218
3219 static void rna_generate_property_prototypes(BlenderRNA *UNUSED(brna), StructRNA *srna, FILE *f)
3220 {
3221   PropertyRNA *prop;
3222   StructRNA *base;
3223
3224   base = srna->base;
3225   while (base) {
3226     fprintf(f, "\n");
3227     for (prop = base->cont.properties.first; prop; prop = prop->next) {
3228       fprintf(f,
3229               "%s%s rna_%s_%s;\n",
3230               "extern ",
3231               rna_property_structname(prop->type),
3232               base->identifier,
3233               prop->identifier);
3234     }
3235     base = base->base;
3236   }
3237
3238   if (srna->cont.properties.first) {
3239     fprintf(f, "\n");
3240   }
3241
3242   for (prop = srna->cont.properties.first; prop; prop = prop->next) {
3243     fprintf(f,
3244             "%s rna_%s_%s;\n",
3245             rna_property_structname(prop->type),
3246             srna->identifier,
3247             prop->identifier);
3248   }
3249   fprintf(f, "\n");
3250 }
3251
3252 static void rna_generate_parameter_prototypes(BlenderRNA *UNUSED(brna),
3253                                               StructRNA *srna,
3254                                               FunctionRNA *func,
3255                                               FILE *f)
3256 {
3257   PropertyRNA *parm;
3258
3259   for (parm = func->cont.properties.first; parm; parm = parm->next) {
3260     fprintf(f,
3261             "%s%s rna_%s_%s_%s;\n",
3262             "extern ",
3263             rna_property_structname(parm->type),
3264             srna->identifier,
3265             func->identifier,
3266             parm->identifier);
3267   }
3268
3269   if (func->cont.properties.first) {
3270     fprintf(f, "\n");
3271   }
3272 }
3273
3274 static void rna_generate_function_prototypes(BlenderRNA *brna, StructRNA *srna, FILE *f)
3275 {
3276   FunctionRNA *func;
3277   StructRNA *base;
3278
3279   base = srna->base;
3280   while (base) {
3281     for (func = base->functions.first; func; func = func->cont.next) {
3282       fprintf(f,
3283               "%s%s rna_%s_%s_func;\n",
3284               "extern ",
3285               "FunctionRNA",
3286               base->identifier,
3287               func->identifier);
3288       rna_generate_parameter_prototypes(brna, base, func, f);
3289     }
3290
3291     if (base->functions.first) {
3292       fprintf(f, "\n");
3293     }
3294
3295     base = base->base;
3296   }
3297
3298   for (func = srna->functions.first; func; func = func->cont.next) {
3299     fprintf(
3300         f, "%s%s rna_%s_%s_func;\n", "extern ", "FunctionRNA", srna->identifier, func->identifier);
3301     rna_generate_parameter_prototypes(brna, srna, func, f);
3302   }
3303
3304   if (srna->functions.first) {
3305     fprintf(f, "\n");
3306   }
3307 }
3308
3309 static void rna_generate_static_parameter_prototypes(FILE *f,
3310                                                      StructRNA *srna,
3311                                                      FunctionDefRNA *dfunc,
3312                                                      const char *name_override,
3313                                                      int close_prototype)
3314 {
3315   FunctionRNA *func;
3316   PropertyDefRNA *dparm;
3317   StructDefRNA *dsrna;
3318   PropertyType type;
3319   int flag, flag_parameter, pout, cptr, first;
3320   const char *ptrstr;
3321
3322   dsrna = rna_find_struct_def(srna);
3323   func = dfunc->func;
3324
3325   /* return type */
3326   for (dparm = dfunc->cont.properties.first; dparm; dparm = dparm->next) {
3327     if (dparm->prop == func->c_ret) {
3328       if (dparm->prop->arraydimension) {
3329         fprintf(f, "XXX no array return types yet"); /* XXX not supported */
3330       }
3331       else if (dparm->prop->type == PROP_POINTER && !(dparm->prop->flag_parameter & PARM_RNAPTR)) {
3332         fprintf(f, "%s%s *", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
3333       }
3334       else {
3335         fprintf(f, "%s%s ", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
3336       }
3337
3338       break;
3339     }
3340   }
3341
3342   /* void if nothing to return */
3343   if (!dparm) {
3344     fprintf(f, "void ");
3345   }
3346
3347   /* function name */
3348   if (name_override == NULL || name_override[0] == '\0') {
3349     fprintf(f, "%s(", dfunc->call);
3350   }
3351   else {
3352     fprintf(f, "%s(", name_override);
3353   }
3354
3355   first = 1;
3356
3357   /* self, context and reports parameters */
3358   if (func->flag & FUNC_USE_SELF_ID) {
3359     fprintf(f, "struct ID *_selfid");
3360     first = 0;
3361   }
3362
3363   if ((func->flag & FUNC_NO_SELF) == 0) {
3364     if (!first) {
3365       fprintf(f, ", ");
3366     }
3367     if (dsrna->dnafromprop) {
3368       fprintf(f, "struct %s *_self", dsrna->dnafromname);
3369     }
3370     else if (dsrna->dnaname) {
3371       fprintf(f, "struct %s *_self", dsrna->dnaname);
3372     }
3373     else {
3374       fprintf(f, "struct %s *_self", srna->identifier);
3375     }
3376     first = 0;
3377   }
3378   else if (func->flag & FUNC_USE_SELF_TYPE) {
3379     if (!first) {
3380       fprintf(f, ", ");
3381     }
3382     fprintf(f, "struct StructRNA *_type");
3383     first = 0;
3384   }
3385
3386   if (func->flag & FUNC_USE_MAIN) {
3387     if (!first) {
3388       fprintf(f, ", ");
3389     }
3390     first = 0;
3391     fprintf(f, "Main *bmain");
3392   }
3393
3394   if (func->flag & FUNC_USE_CONTEXT) {
3395     if (!first) {
3396       fprintf(f, ", ");
3397     }
3398     first = 0;
3399     fprintf(f, "bContext *C");
3400   }
3401
3402   if (func->flag & FUNC_USE_REPORTS) {
3403     if (!first) {
3404       fprintf(f, ", ");
3405     }
3406     first = 0;
3407     fprintf(f, "ReportList *reports");
3408   }
3409
3410   /* defined parameters */
3411   for (dparm = dfunc->cont.properties.first; dparm; dparm = dparm->next) {
3412     type = dparm->prop->type;
3413     flag = dparm->prop->flag;
3414     flag_parameter = dparm->prop->flag_parameter;
3415     pout = (flag_parameter & PARM_OUTPUT);
3416     cptr = ((type == PROP_POINTER) && !(flag_parameter & PARM_RNAPTR));
3417
3418     if (dparm->prop == func->c_ret) {
3419       continue;
3420     }
3421
3422     if (cptr || (flag & PROP_DYNAMIC)) {
3423       ptrstr = pout ? "**" : "*";
3424     }
3425     else if (type == PROP_POINTER || dparm->prop->arraydimension) {
3426       ptrstr = "*";
3427     }
3428     else if (type == PROP_STRING && (flag & PROP_THICK_WRAP)) {
3429       ptrstr = "";
3430     }
3431     else {
3432       ptrstr = pout ? "*" : "";
3433     }
3434
3435     if (!first) {
3436       fprintf(f, ", ");
3437     }
3438     first = 0;
3439
3440     if (flag & PROP_DYNAMIC) {
3441       fprintf(f, "int %s%s_len, ", pout ? "*" : "", dparm->prop->identifier);
3442     }
3443
3444     if (!(flag & PROP_DYNAMIC) && dparm->prop->arraydimension) {
3445       fprintf(f,
3446               "%s%s %s[%u]",
3447               rna_type_struct(dparm->prop),
3448               rna_parameter_type_name(dparm->prop),
3449               rna_safe_id(dparm->prop->identifier),
3450               dparm->prop->totarraylength);
3451     }
3452     else {
3453       fprintf(f,
3454               "%s%s %s%s",
3455               rna_type_struct(dparm->prop),
3456               rna_parameter_type_name(dparm->prop),
3457               ptrstr,
3458               rna_safe_id(dparm->prop->identifier));
3459     }
3460   }
3461
3462   /* ensure func(void) if there are no args */
3463   if (first) {
3464     fprintf(f, "void");
3465   }
3466
3467   fprintf(f, ")");
3468
3469   if (close_prototype) {
3470     fprintf(f, ";\n");
3471   }
3472 }
3473
3474 static void rna_generate_static_function_prototypes(BlenderRNA *UNUSED(brna),
3475                                                     StructRNA *srna,
3476                                                     FILE *f)
3477 {
3478   FunctionRNA *func;
3479   FunctionDefRNA *dfunc;
3480   int first = 1;
3481
3482   for (func = srna->functions.first; func; func = func->cont.next) {
3483     dfunc = rna_find_function_def(func);
3484
3485     if (dfunc->call) {
3486       if (first) {
3487         fprintf(f, "/* Repeated prototypes to detect errors */\n\n");
3488         first = 0;
3489       }
3490
3491       rna_generate_static_parameter_prototypes(f, srna, dfunc, NULL, 1);
3492     }
3493   }
3494
3495   fprintf(f, "\n");
3496 }
3497
3498 static void rna_generate_struct_prototypes(FILE *f)
3499 {
3500   StructDefRNA *ds;
3501   PropertyDefRNA *dp;
3502   FunctionDefRNA *dfunc;
3503   const char *structures[2048];
3504   int all_structures = 0;
3505
3506   /* structures definitions */
3507   for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
3508     for (dfunc = ds->functions.first; dfunc; dfunc = dfunc->cont.next) {
3509       if (dfunc->call) {
3510         for (dp = dfunc->cont.properties.first; dp; dp = dp->next) {
3511           if (dp->prop->type == PROP_POINTER) {
3512             int a, found = 0;
3513             const char *struct_name = rna_parameter_type_name(dp->prop);
3514             if (struct_name == NULL) {
3515               printf("No struct found for property '%s'\n", dp->prop->identifier);
3516               exit(1);
3517             }
3518
3519             for (a = 0; a < all_structures; a++) {
3520               if (STREQ(struct_name, structures[a])) {
3521                 found = 1;
3522                 break;
3523               }
3524             }
3525
3526             if (found == 0) {
3527               fprintf(f, "struct %s;\n", struct_name);
3528
3529               if (all_structures >= sizeof(structures) / sizeof(structures[0])) {
3530                 printf("Array size to store all structures names is too small\n");
3531                 exit(1);
3532               }
3533
3534               structures[all_structures++] = struct_name;
3535             }
3536           }
3537         }
3538       }
3539     }
3540   }
3541
3542   fprintf(f, "\n");
3543 }
3544
3545 static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, PropertyRNA *prop)
3546 {
3547   char *strnest = (char *)"", *errnest = (char *)"";
3548   int len, freenest = 0;
3549
3550   if (nest != NULL) {
3551     len = strlen(nest);
3552
3553     strnest = MEM_mallocN(sizeof(char) * (len + 2), "rna_generate_property -> strnest");
3554     errnest = MEM_mallocN(sizeof(char) * (len + 2), "rna_generate_property -> errnest");
3555
3556     strcpy(strnest, "_");
3557     strcat(strnest, nest);
3558     strcpy(errnest, ".");
3559     strcat(errnest, nest);
3560
3561     freenest = 1;
3562   }
3563
3564   switch (prop->type) {
3565     case PROP_ENUM: {
3566       EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
3567       int i, defaultfound = 0, totflag = 0;
3568
3569       if (eprop->item) {
3570         fprintf(f,
3571                 "static const EnumPropertyItem rna_%s%s_%s_items[%d] = {\n\t",
3572                 srna->identifier,
3573                 strnest,
3574                 prop->identifier,
3575                 eprop->totitem + 1);
3576
3577         for (i = 0; i < eprop->totitem; i++) {
3578           fprintf(f, "{%d, ", eprop->item[i].value);
3579           rna_print_c_string(f, eprop->item[i].identifier);
3580           fprintf(f, ", ");
3581           fprintf(f, "%d, ", eprop->item[i].icon);
3582           rna_print_c_string(f, eprop->item[i].name);
3583           fprintf(f, ", ");
3584           rna_print_c_string(f, eprop->item[i].description);
3585           fprintf(f, "},\n\t");
3586
3587           if (eprop->item[i].identifier[0]) {
3588             if (prop->flag & PROP_ENUM_FLAG) {
3589               totflag |= eprop->item[i].value;
3590             }
3591             else {
3592               if (eprop->defaultvalue == eprop->item[i].value) {
3593                 defaultfound = 1;
3594               }
3595             }
3596           }
3597         }
3598
3599         fprintf(f, "{0, NULL, 0, NULL, NULL}\n};\n\n");
3600
3601         if (prop->flag & PROP_ENUM_FLAG) {
3602           if (eprop->defaultvalue & ~totflag) {
3603             CLOG_ERROR(&LOG,
3604                        "%s%s.%s, enum default includes unused bits (%d).",
3605                        srna->identifier,
3606                        errnest,
3607                        prop->identifier,
3608                        eprop->defaultvalue & ~totflag);
3609             DefRNA.error = 1;
3610           }
3611         }
3612         else {
3613           if (!defaultfound && !(eprop->itemf && eprop->item == DummyRNA_NULL_items)) {
3614             CLOG_ERROR(&LOG,
3615                        "%s%s.%s, enum default is not in items.",
3616                        srna->identifier,
3617                        errnest,
3618                        prop->identifier);
3619             DefRNA.error = 1;
3620           }
3621         }
3622       }
3623       else {
3624         CLOG_ERROR(&LOG,
3625                    "%s%s.%s, enum must have items defined.",
3626                    srna->identifier,
3627                    errnest,
3628                    prop->identifier);
3629         DefRNA.error = 1;
3630       }
3631       break;
3632     }
3633     case PROP_BOOLEAN: {
3634       BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
3635       unsigned int i;
3636
3637       if (prop->arraydimension && prop->totarraylength) {
3638         fprintf(f,
3639                 "static bool rna_%s%s_%s_default[%u] = {\n\t",
3640                 srna->identifier,
3641                 strnest,
3642                 prop->identifier,
3643                 prop->totarraylength);
3644
3645         for (i = 0; i < prop->totarraylength; i++) {
3646           if (bprop->defaultarray) {
3647             fprintf(f, "%d", bprop->defaultarray[i]);
3648           }
3649           else {
3650             fprintf(f, "%d", bprop->defaultvalue);
3651           }
3652           if (i != prop->totarraylength - 1) {
3653             fprintf(f, ",\n\t");
3654           }
3655         }
3656
3657         fprintf(f, "\n};\n\n");
3658       }
3659       break;
3660     }
3661     case PROP_INT: {
3662       IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
3663       unsigned int i;
3664
3665       if (prop->arraydimension && prop->totarraylength) {
3666         fprintf(f,
3667                 "static int rna_%s%s_%s_default[%u] = {\n\t",
3668                 srna->identifier,
3669                 strnest,
3670                 prop->identifier,
3671                 prop->totarraylength);
3672
3673         for (i = 0; i < prop->totarraylength; i++) {
3674           if (iprop->defaultarray) {
3675             fprintf(f, "%d", iprop->defaultarray[i]);
3676           }
3677           else {
3678             fprintf(f, "%d", iprop->defaultvalue);
3679           }
3680           if (i != prop->totarraylength - 1) {
3681             fprintf(f, ",\n\t");
3682           }
3683         }
3684
3685         fprintf(f, "\n};\n\n");
3686       }
3687       break;
3688     }
3689     case PROP_FLOAT: {
3690       FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
3691       unsigned int i;
3692
3693       if (prop->arraydimension && prop->totarraylength) {
3694         fprintf(f,
3695                 "static float rna_%s%s_%s_default[%u] = {\n\t",
3696                 srna->identifier,
3697                 strnest,
3698                 prop->identifier,
3699                 prop->totarraylength);
3700
3701         for (i = 0; i < prop->totarraylength; i++) {
3702           if (fprop->defaultarray) {
3703             rna_float_print(f, fprop->defaultarray[i]);
3704           }
3705           else {
3706             rna_float_print(f, fprop->defaultvalue);
3707           }
3708           if (i != prop->totarraylength - 1) {
3709             fprintf(f, ",\n\t");
3710           }
3711         }
3712
3713         fprintf(f, "\n};\n\n");
3714       }
3715       break;
3716     }
3717     case PROP_POINTER: {
3718       PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
3719
3720       /* XXX This systematically enforces that flag on ID pointers...
3721        * we'll probably have to revisit. :/ */
3722       StructRNA *type = rna_find_struct((const char *)pprop->type);
3723       if (type && (type->flag & STRUCT_ID)) {
3724         prop->flag |= PROP_PTR_NO_OWNERSHIP;
3725       }
3726       break;
3727     }
3728     case PROP_COLLECTION: {
3729       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
3730
3731       /* XXX This systematically enforces that flag on ID pointers...
3732        * we'll probably have to revisit. :/ */
3733       StructRNA *type = rna_find_struct((const char *)cprop->item_type);
3734       if (type && (type->flag & STRUCT_ID)) {
3735         prop->flag |= PROP_PTR_NO_OWNERSHIP;
3736       }
3737       break;
3738     }
3739     default:
3740       break;
3741   }
3742
3743   fprintf(f,
3744           "%s rna_%s%s_%s = {\n",
3745           rna_property_structname(prop->type),
3746           srna->identifier,
3747           strnest,
3748           prop->identifier);
3749
3750   if (prop->next) {
3751     fprintf(
3752         f, "\t{(PropertyRNA *)&rna_%s%s_%s, ", srna->identifier, strnest, prop->next->identifier);
3753   }
3754   else {
3755     fprintf(f, "\t{NULL, ");
3756   }
3757   if (prop->prev) {
3758     fprintf(
3759         f, "(PropertyRNA *)&rna_%s%s_%s,\n", srna->identifier, strnest, prop->prev->identifier);
3760   }
3761   else {
3762     fprintf(f, "NULL,\n");
3763   }
3764   fprintf(f, "\t%d, ", prop->magic);
3765   rna_print_c_string(f, prop->identifier);
3766   fprintf(f,
3767           ", %d, %d, %d, %d, %d, ",
3768           prop->flag,
3769           prop->flag_override,
3770           prop->flag_parameter,
3771           prop->flag_internal,
3772           prop->tags);
3773   rna_print_c_string(f, prop->name);
3774   fprintf(f, ",\n\t");
3775   rna_print_c_string(f, prop->description);
3776   fprintf(f, ",\n\t");
3777   fprintf(f, "%d, ", prop->icon);
3778   rna_print_c_string(f, prop->translation_context);
3779   fprintf(f, ",\n");
3780   fprintf(f,
3781           "\t%s, %s | %s, %s, %u, {%u, %u, %u}, %u,\n",
3782           RNA_property_typename(prop->type),
3783           rna_property_subtypename(prop->subtype),
3784           rna_property_subtype_unit(prop->subtype),
3785           rna_function_string(prop->getlength),
3786           prop->arraydimension,
3787           prop->arraylength[0],
3788           prop->arraylength[1],
3789           prop->arraylength[2],
3790           prop->totarraylength);
3791   fprintf(f,
3792           "\t%s%s, %d, %s, %s, %s, %s, %s,\n",
3793           (prop->flag & PROP_CONTEXT_UPDATE) ? "(UpdateFunc)" : "",
3794           rna_function_string(prop->update),
3795           prop->noteflag,
3796           rna_function_string(prop->editable),
3797           rna_function_string(prop->itemeditable),
3798           rna_function_string(prop->override_diff),
3799           rna_function_string(prop->override_store),
3800           rna_function_string(prop->override_apply));
3801
3802   if (prop->flag_internal & PROP_INTERN_RAW_ACCESS) {
3803     rna_set_raw_offset(f, srna, prop);
3804   }
3805   else {
3806     fprintf(f, "\t0, -1");
3807   }
3808
3809   /* our own type - collections/arrays only */
3810   if (prop->srna) {
3811     fprintf(f, ", &RNA_%s", (const char *)prop->srna);
3812   }
3813   else {
3814     fprintf(f, ", NULL");
3815   }
3816
3817   fprintf(f, "},\n");
3818
3819   switch (prop->type) {
3820     case PROP_BOOLEAN: {
3821       BoolPropertyRNA *bprop = (BoolPropertyRNA *)prop;
3822       fprintf(f,
3823               "\t%s, %s, %s, %s, %s, %s, %s, %s, %d, ",
3824               rna_function_string(bprop->get),
3825               rna_function_string(bprop->set),
3826               rna_function_string(bprop->getarray),
3827               rna_function_string(bprop->setarray),
3828               rna_function_string(bprop->get_ex),
3829               rna_function_string(bprop->set_ex),
3830               rna_function_string(bprop->getarray_ex),
3831               rna_function_string(bprop->setarray_ex),
3832               bprop->defaultvalue);
3833       if (prop->arraydimension && prop->totarraylength) {
3834         fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
3835       }
3836       else {
3837         fprintf(f, "NULL\n");
3838       }
3839       break;
3840     }
3841     case PROP_INT: {
3842       IntPropertyRNA *iprop = (IntPropertyRNA *)prop;
3843       fprintf(f,
3844               "\t%s, %s, %s, %s, %s, %s, %s, %s, %s, %s,\n\t",
3845               rna_function_string(iprop->get),
3846               rna_function_string(iprop->set),
3847               rna_function_string(iprop->getarray),
3848               rna_function_string(iprop->setarray),
3849               rna_function_string(iprop->range),
3850               rna_function_string(iprop->get_ex),
3851               rna_function_string(iprop->set_ex),
3852               rna_function_string(iprop->getarray_ex),
3853               rna_function_string(iprop->setarray_ex),
3854               rna_function_string(iprop->range_ex));
3855       rna_int_print(f, iprop->softmin);
3856       fprintf(f, ", ");
3857       rna_int_print(f, iprop->softmax);
3858       fprintf(f, ", ");
3859       rna_int_print(f, iprop->hardmin);
3860       fprintf(f, ", ");
3861       rna_int_print(f, iprop->hardmax);
3862       fprintf(f, ", ");
3863       rna_int_print(f, iprop->step);
3864       fprintf(f, ", ");
3865       rna_int_print(f, iprop->defaultvalue);
3866       fprintf(f, ", ");
3867       if (prop->arraydimension && prop->totarraylength) {
3868         fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
3869       }
3870       else {
3871         fprintf(f, "NULL\n");
3872       }
3873       break;
3874     }
3875     case PROP_FLOAT: {
3876       FloatPropertyRNA *fprop = (FloatPropertyRNA *)prop;
3877       fprintf(f,
3878               "\t%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, ",
3879               rna_function_string(fprop->get),
3880               rna_function_string(fprop->set),
3881               rna_function_string(fprop->getarray),
3882               rna_function_string(fprop->setarray),
3883               rna_function_string(fprop->range),
3884               rna_function_string(fprop->get_ex),
3885               rna_function_string(fprop->set_ex),
3886               rna_function_string(fprop->getarray_ex),
3887               rna_function_string(fprop->setarray_ex),
3888               rna_function_string(fprop->range_ex));
3889       rna_float_print(f, fprop->softmin);
3890       fprintf(f, ", ");
3891       rna_float_print(f, fprop->softmax);
3892       fprintf(f, ", ");
3893       rna_float_print(f, fprop->hardmin);
3894       fprintf(f, ", ");
3895       rna_float_print(f, fprop->hardmax);
3896       fprintf(f, ", ");
3897       rna_float_print(f, fprop->step);
3898       fprintf(f, ", ");
3899       rna_int_print(f, (int)fprop->precision);
3900       fprintf(f, ", ");
3901       rna_float_print(f, fprop->defaultvalue);
3902       fprintf(f, ", ");
3903       if (prop->arraydimension && prop->totarraylength) {
3904         fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
3905       }
3906       else {
3907         fprintf(f, "NULL\n");
3908       }
3909       break;
3910     }
3911     case PROP_STRING: {
3912       StringPropertyRNA *sprop = (StringPropertyRNA *)prop;
3913       fprintf(f,
3914               "\t%s, %s, %s, %s, %s, %s, %d, ",
3915               rna_function_string(sprop->get),
3916               rna_function_string(sprop->length),
3917               rna_function_string(sprop->set),
3918               rna_function_string(sprop->get_ex),
3919               rna_function_string(sprop->length_ex),
3920               rna_function_string(sprop->set_ex),
3921               sprop->maxlength);
3922       rna_print_c_string(f, sprop->defaultvalue);
3923       fprintf(f, "\n");
3924       break;
3925     }
3926     case PROP_ENUM: {
3927       EnumPropertyRNA *eprop = (EnumPropertyRNA *)prop;
3928       fprintf(f,
3929               "\t%s, %s, %s, %s, %s, NULL, ",
3930               rna_function_string(eprop->get),
3931               rna_function_string(eprop->set),
3932               rna_function_string(eprop->itemf),
3933               rna_function_string(eprop->get_ex),
3934               rna_function_string(eprop->set_ex));
3935       if (eprop->item) {
3936         fprintf(f, "rna_%s%s_%s_items, ", srna->identifier, strnest, prop->identifier);
3937       }
3938       else {
3939         fprintf(f, "NULL, ");
3940       }
3941       fprintf(f, "%d, %d\n", eprop->totitem, eprop->defaultvalue);
3942       break;
3943     }
3944     case PROP_POINTER: {
3945       PointerPropertyRNA *pprop = (PointerPropertyRNA *)prop;
3946       fprintf(f,
3947               "\t%s, %s, %s, %s,",
3948               rna_function_string(pprop->get),
3949               rna_function_string(pprop->set),
3950               rna_function_string(pprop->typef),
3951               rna_function_string(pprop->poll));
3952       if (pprop->type) {
3953         fprintf(f, "&RNA_%s\n", (const char *)pprop->type);
3954       }
3955       else {
3956         fprintf(f, "NULL\n");
3957       }
3958       break;
3959     }
3960     case PROP_COLLECTION: {
3961       CollectionPropertyRNA *cprop = (CollectionPropertyRNA *)prop;
3962       fprintf(f,
3963               "\t%s, %s, %s, %s, %s, %s, %s, %s, ",
3964               rna_function_string(cprop->begin),
3965               rna_function_string(cprop->next),
3966               rna_function_string(cprop->end),
3967               rna_function_string(cprop->get),
3968               rna_function_string(cprop->length),
3969               rna_function_string(cprop->lookupint),
3970               rna_function_string(cprop->lookupstring),
3971               rna_function_string(cprop->assignint));
3972       if (cprop->item_type) {
3973         fprintf(f, "&RNA_%s\n", (const char *)cprop->item_type);
3974       }
3975       else {
3976         fprintf(f, "NULL\n");
3977       }
3978       break;
3979     }
3980   }
3981
3982   fprintf(f, "};\n\n");
3983
3984   if (freenest) {
3985     MEM_freeN(strnest);
3986     MEM_freeN(errnest);
3987   }
3988 }
3989
3990 static void rna_generate_struct(BlenderRNA *UNUSED(brna), StructRNA *srna, FILE *f)
3991 {
3992   FunctionRNA *func;
3993   FunctionDefRNA *dfunc;
3994   PropertyRNA *prop, *parm;
3995   StructRNA *base;
3996
3997   fprintf(f, "/* %s */\n", srna->name);
3998
3999   for (prop = srna->cont.properties.first; prop; prop = prop->next) {
4000     rna_generate_property(f, srna, NULL, prop);
4001   }
4002
4003   for (func = srna->functions.first; func; func = func->cont.next) {
4004     for (parm = func->cont.properties.first; parm; parm = parm->next) {
4005       rna_generate_property(f, srna, func->identifier, parm);
4006     }
4007
4008     fprintf(f, "%s%s rna_%s_%s_func = {\n", "", "FunctionRNA", srna->identifier, func->identifier);
4009
4010     if (func->cont.next) {
4011       fprintf(f,
4012               "\t{(FunctionRNA *)&rna_%s_%s_func, ",
4013               srna->identifier,
4014               ((FunctionRNA *)func->cont.next)->identifier);
4015     }
4016     else {
4017       fprintf(f, "\t{NULL, ");
4018     }
4019     if (func->cont.prev) {
4020       fprintf(f,
4021               "(FunctionRNA *)&rna_%s_%s_func,\n",
4022               srna->identifier,
4023               ((FunctionRNA *)func->cont.prev)->identifier);
4024     }
4025     else {
4026       fprintf(f, "NULL,\n");
4027     }
4028
4029     fprintf(f, "\tNULL,\n");
4030
4031     parm = func->cont.properties.first;
4032     if (parm) {
4033       fprintf(f,
4034               "\t{(PropertyRNA *)&rna_%s_%s_%s, ",
4035               srna->identifier,
4036               func->identifier,
4037               parm->identifier);
4038     }
4039     else {
4040       fprintf(f, "\t{NULL, ");
4041     }
4042
4043     parm = func->cont.properties.last;
4044     if (parm) {
4045       fprintf(f,
4046               "(PropertyRNA *)&rna_%s_%s_%s}},\n",
4047               srna->identifier,
4048               func->identifier,
4049               parm->identifier);
4050     }
4051     else {
4052       fprintf(f, "NULL}},\n");
4053     }
4054
4055     fprintf(f, "\t");
4056     rna_print_c_string(f, func->identifier);
4057     fprintf(f, ", %d, ", func->flag);
4058     rna_print_c_string(f, func->description);
4059     fprintf(f, ",\n");
4060
4061     dfunc = rna_find_function_def(func);
4062     if (dfunc->gencall) {
4063       fprintf(f, "\t%s,\n", dfunc->gencall);
4064     }
4065     else {
4066       fprintf(f, "\tNULL,\n");
4067     }
4068
4069     if (func->c_ret) {
4070       fprintf(f,
4071               "\t(PropertyRNA *)&rna_%s_%s_%s\n",
4072               srna->identifier,
4073               func->identifier,
4074               func->c_ret->identifier);
4075     }
4076     else {
4077       fprintf(f, "\tNULL\n");
4078     }
4079
4080     fprintf(f, "};\n");
4081     fprintf(f, "\n");
4082   }
4083
4084   fprintf(f, "StructRNA RNA_%s = {\n", srna->identifier);
4085
4086   if (srna->cont.next) {
4087     fprintf(f, "\t{(ContainerRNA *)&RNA_%s, ", ((StructRNA *)srna->cont.next)->identifier);
4088   }
4089   else {
4090     fprintf(f, "\t{NULL, ");
4091   }
4092   if (srna->cont.prev) {
4093     fprintf(f, "(ContainerRNA *)&RNA_%s,\n", ((StructRNA *)srna->cont.prev)->identifier);
4094   }
4095   else {
4096     fprintf(f, "NULL,\n");
4097   }
4098
4099   fprintf(f, "\tNULL,\n");
4100
4101   prop = srna->cont.properties.first;
4102   if (prop) {
4103     fprintf(f, "\t{(PropertyRNA *)&rna_%s_%s, ", srna->identifier, prop->identifier);
4104   }
4105   else {
4106     fprintf(f, "\t{NULL, ");
4107   }
4108
4109   prop = srna->cont.properties.last;
4110   if (prop) {
4111     fprintf(f, "(PropertyRNA *)&rna_%s_%s}},\n", srna->identifier, prop->identifier);
4112   }
4113   else {
4114     fprintf(f, "NULL}},\n");
4115   }
4116   fprintf(f, "\t");