Brecht Van Lommel
4e4e8ef98f
* For RNA wrapped functions, the prototypes of the original function being wrapped is now generated as well. This is an extra check to ensure that the function is correctly wrapped. It's printed after the function is used to still get proper warnings in case the #include for it is missing.
2186 lines
66 KiB
C
2186 lines
66 KiB
C
/**
|
|
* $Id$
|
|
*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* Contributor(s): Blender Foundation (2008).
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "RNA_access.h"
|
|
#include "RNA_define.h"
|
|
#include "RNA_types.h"
|
|
|
|
#include "rna_internal.h"
|
|
|
|
#define RNA_VERSION_DATE "$Id$"
|
|
|
|
#ifdef _WIN32
|
|
#ifndef snprintf
|
|
#define snprintf _snprintf
|
|
#endif
|
|
#endif
|
|
|
|
/* Sorting */
|
|
|
|
static int cmp_struct(const void *a, const void *b)
|
|
{
|
|
const StructRNA *structa= *(const StructRNA**)a;
|
|
const StructRNA *structb= *(const StructRNA**)b;
|
|
|
|
return strcmp(structa->identifier, structb->identifier);
|
|
}
|
|
|
|
static int cmp_property(const void *a, const void *b)
|
|
{
|
|
const PropertyRNA *propa= *(const PropertyRNA**)a;
|
|
const PropertyRNA *propb= *(const PropertyRNA**)b;
|
|
|
|
if(strcmp(propa->identifier, "rna_type") == 0) return -1;
|
|
else if(strcmp(propb->identifier, "rna_type") == 0) return 1;
|
|
|
|
if(strcmp(propa->identifier, "name") == 0) return -1;
|
|
else if(strcmp(propb->identifier, "name") == 0) return 1;
|
|
|
|
return strcmp(propa->name, propb->name);
|
|
}
|
|
|
|
static int cmp_def_struct(const void *a, const void *b)
|
|
{
|
|
const StructDefRNA *dsa= *(const StructDefRNA**)a;
|
|
const StructDefRNA *dsb= *(const StructDefRNA**)b;
|
|
|
|
return cmp_struct(&dsa->srna, &dsb->srna);
|
|
}
|
|
|
|
static int cmp_def_property(const void *a, const void *b)
|
|
{
|
|
const PropertyDefRNA *dpa= *(const PropertyDefRNA**)a;
|
|
const PropertyDefRNA *dpb= *(const PropertyDefRNA**)b;
|
|
|
|
return cmp_property(&dpa->prop, &dpb->prop);
|
|
}
|
|
|
|
static void rna_sortlist(ListBase *listbase, int(*cmp)(const void*, const void*))
|
|
{
|
|
Link *link;
|
|
void **array;
|
|
int a, size;
|
|
|
|
if(listbase->first == listbase->last)
|
|
return;
|
|
|
|
for(size=0, link=listbase->first; link; link=link->next)
|
|
size++;
|
|
|
|
array= MEM_mallocN(sizeof(void*)*size, "rna_sortlist");
|
|
for(a=0, link=listbase->first; link; link=link->next, a++)
|
|
array[a]= link;
|
|
|
|
qsort(array, size, sizeof(void*), cmp);
|
|
|
|
listbase->first= listbase->last= NULL;
|
|
for(a=0; a<size; a++) {
|
|
link= array[a];
|
|
link->next= link->prev= NULL;
|
|
rna_addtail(listbase, link);
|
|
}
|
|
|
|
MEM_freeN(array);
|
|
}
|
|
|
|
/* Preprocessing */
|
|
|
|
static void rna_print_c_string(FILE *f, const char *str)
|
|
{
|
|
static char *escape[] = {"\''", "\"\"", "\??", "\\\\","\aa", "\bb", "\ff", "\nn", "\rr", "\tt", "\vv", NULL};
|
|
int i, j;
|
|
|
|
fprintf(f, "\"");
|
|
for(i=0; str[i]; i++) {
|
|
for(j=0; escape[j]; j++)
|
|
if(str[i] == escape[j][0])
|
|
break;
|
|
|
|
if(escape[j]) fprintf(f, "\\%c", escape[j][1]);
|
|
else fprintf(f, "%c", str[i]);
|
|
}
|
|
fprintf(f, "\"");
|
|
}
|
|
|
|
static void rna_print_data_get(FILE *f, PropertyDefRNA *dp)
|
|
{
|
|
if(dp->dnastructfromname && dp->dnastructfromprop)
|
|
fprintf(f, " %s *data= (%s*)(((%s*)ptr->data)->%s);\n", dp->dnastructname, dp->dnastructname, dp->dnastructfromname, dp->dnastructfromprop);
|
|
else
|
|
fprintf(f, " %s *data= (%s*)(ptr->data);\n", dp->dnastructname, dp->dnastructname);
|
|
}
|
|
|
|
static char *rna_alloc_function_name(const char *structname, const char *propname, const char *type)
|
|
{
|
|
AllocDefRNA *alloc;
|
|
char buffer[2048];
|
|
char *result;
|
|
|
|
snprintf(buffer, sizeof(buffer), "%s_%s_%s", structname, propname, type);
|
|
result= MEM_callocN(sizeof(char)*strlen(buffer)+1, "rna_alloc_function_name");
|
|
strcpy(result, buffer);
|
|
|
|
alloc= MEM_callocN(sizeof(AllocDefRNA), "AllocDefRNA");
|
|
alloc->mem= result;
|
|
rna_addtail(&DefRNA.allocs, alloc);
|
|
|
|
return result;
|
|
}
|
|
|
|
static const char *rna_find_type(const char *type)
|
|
{
|
|
StructDefRNA *ds;
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
if(ds->dnaname && strcmp(ds->dnaname, type)==0)
|
|
return ds->srna->identifier;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const char *rna_find_dna_type(const char *type)
|
|
{
|
|
StructDefRNA *ds;
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
if(strcmp(ds->srna->identifier, type)==0)
|
|
return ds->dnaname;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const char *rna_type_type_name(PropertyRNA *prop)
|
|
{
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN:
|
|
case PROP_INT:
|
|
case PROP_ENUM:
|
|
return "int";
|
|
case PROP_FLOAT:
|
|
return "float";
|
|
case PROP_STRING:
|
|
return "char*";
|
|
default:
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static const char *rna_type_type(PropertyRNA *prop)
|
|
{
|
|
const char *type;
|
|
|
|
type= rna_type_type_name(prop);
|
|
|
|
if(type)
|
|
return type;
|
|
|
|
return "PointerRNA";
|
|
}
|
|
|
|
static const char *rna_type_struct(PropertyRNA *prop)
|
|
{
|
|
const char *type;
|
|
|
|
type= rna_type_type_name(prop);
|
|
|
|
if(type)
|
|
return "";
|
|
|
|
return "struct ";
|
|
}
|
|
|
|
static const char *rna_parameter_type_name(PropertyRNA *parm)
|
|
{
|
|
const char *type;
|
|
|
|
type= rna_type_type_name(parm);
|
|
|
|
if(type)
|
|
return type;
|
|
|
|
switch(parm->type) {
|
|
case PROP_POINTER: {
|
|
PointerPropertyRNA *pparm= (PointerPropertyRNA*)parm;
|
|
|
|
if(strcmp((char*)pparm->type, "AnyType") == 0)
|
|
return "PointerRNA";
|
|
else
|
|
return rna_find_dna_type((const char *)pparm->type);
|
|
}
|
|
case PROP_COLLECTION: {
|
|
CollectionPropertyRNA *cparm= (CollectionPropertyRNA*)parm;
|
|
return rna_find_dna_type((const char *)cparm->type);
|
|
}
|
|
default:
|
|
return "<error, no type specified>";
|
|
}
|
|
}
|
|
|
|
static int rna_enum_bitmask(PropertyRNA *prop)
|
|
{
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
int a, mask= 0;
|
|
|
|
for(a=0; a<eprop->totitem; a++)
|
|
mask |= eprop->item[a].value;
|
|
|
|
return mask;
|
|
}
|
|
|
|
static int rna_color_quantize(PropertyRNA *prop, PropertyDefRNA *dp)
|
|
{
|
|
if(prop->type == PROP_FLOAT && prop->subtype == PROP_COLOR)
|
|
if(strcmp(dp->dnatype, "float") != 0 && strcmp(dp->dnatype, "double") != 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const char *rna_function_string(void *func)
|
|
{
|
|
return (func)? (const char*)func: "NULL";
|
|
}
|
|
|
|
static void rna_float_print(FILE *f, float num)
|
|
{
|
|
if(num == -FLT_MAX) fprintf(f, "-FLT_MAX");
|
|
else if(num == FLT_MAX) fprintf(f, "FLT_MAX");
|
|
else if((int)num == num) fprintf(f, "%.1ff", num);
|
|
else fprintf(f, "%.10ff", num);
|
|
}
|
|
|
|
static void rna_int_print(FILE *f, int num)
|
|
{
|
|
if(num == INT_MIN) fprintf(f, "INT_MIN");
|
|
else if(num == INT_MAX) fprintf(f, "INT_MAX");
|
|
else fprintf(f, "%d", num);
|
|
}
|
|
|
|
static char *rna_def_property_get_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, const char *manualfunc)
|
|
{
|
|
char *func;
|
|
int i;
|
|
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
if(!manualfunc) {
|
|
if(!dp->dnastructname || !dp->dnaname) {
|
|
fprintf(stderr, "rna_def_property_get_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
return NULL;
|
|
}
|
|
|
|
if(prop->type == PROP_STRING && ((StringPropertyRNA*)prop)->maxlength == 0) {
|
|
fprintf(stderr, "rna_def_property_get_func: string %s.%s has max length 0.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "get");
|
|
|
|
switch(prop->type) {
|
|
case PROP_STRING: {
|
|
StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
|
|
fprintf(f, "void %s(PointerRNA *ptr, char *value)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, value);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
fprintf(f, " BLI_strncpy(value, data->%s, %d);\n", dp->dnaname, sprop->maxlength);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
fprintf(f, "PointerRNA %s(PointerRNA *ptr)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " return %s(ptr);\n", manualfunc);
|
|
}
|
|
else {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
|
|
rna_print_data_get(f, dp);
|
|
if(dp->dnapointerlevel == 0)
|
|
fprintf(f, " return rna_pointer_inherit_refine(ptr, &RNA_%s, &data->%s);\n", (char*)pprop->type, dp->dnaname);
|
|
else
|
|
fprintf(f, " return rna_pointer_inherit_refine(ptr, &RNA_%s, data->%s);\n", (char*)pprop->type, dp->dnaname);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
|
|
|
|
fprintf(f, "static PointerRNA %s(CollectionPropertyIterator *iter)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
if(strcmp(manualfunc, "rna_iterator_listbase_get") == 0 ||
|
|
strcmp(manualfunc, "rna_iterator_array_get") == 0 ||
|
|
strcmp(manualfunc, "rna_iterator_array_dereference_get") == 0)
|
|
fprintf(f, " return rna_pointer_inherit_refine(&iter->parent, &RNA_%s, %s(iter));\n", (cprop->type)? (char*)cprop->type: "UnknownType", manualfunc);
|
|
else
|
|
fprintf(f, " return %s(iter);\n", manualfunc);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
break;
|
|
}
|
|
default:
|
|
if(prop->arraylength) {
|
|
fprintf(f, "void %s(PointerRNA *ptr, %s values[%d])\n", func, rna_type_type(prop), prop->arraylength);
|
|
fprintf(f, "{\n");
|
|
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, values);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
|
|
for(i=0; i<prop->arraylength; i++) {
|
|
if(dp->dnaarraylength == 1) {
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit)
|
|
fprintf(f, " values[%d]= (%s(data->%s & (%d<<%d)) != 0);\n", i, (dp->booleannegative)? "!": "", dp->dnaname, dp->booleanbit, i);
|
|
else
|
|
fprintf(f, " values[%d]= (%s)%s((&data->%s)[%d]);\n", i, rna_type_type(prop), (dp->booleannegative)? "!": "", dp->dnaname, i);
|
|
}
|
|
else {
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit) {
|
|
fprintf(f, " values[%d]= (%s(data->%s[%d] & ", i, (dp->booleannegative)? "!": "", dp->dnaname, i);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ") != 0);\n");
|
|
}
|
|
else if(rna_color_quantize(prop, dp))
|
|
fprintf(f, " values[%d]= (%s)(data->%s[%d]*(1.0f/255.0f));\n", i, rna_type_type(prop), dp->dnaname, i);
|
|
else
|
|
fprintf(f, " values[%d]= (%s)%s(data->%s[%d]);\n", i, rna_type_type(prop), (dp->booleannegative)? "!": "", dp->dnaname, i);
|
|
}
|
|
}
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
else {
|
|
fprintf(f, "%s %s(PointerRNA *ptr)\n", rna_type_type(prop), func);
|
|
fprintf(f, "{\n");
|
|
|
|
if(manualfunc) {
|
|
fprintf(f, " return %s(ptr);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit) {
|
|
fprintf(f, " return (%s((data->%s) & ", (dp->booleannegative)? "!": "", dp->dnaname);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ") != 0);\n");
|
|
}
|
|
else if(prop->type == PROP_ENUM && dp->enumbitflags) {
|
|
fprintf(f, " return ((data->%s) & ", dp->dnaname);
|
|
rna_int_print(f, rna_enum_bitmask(prop));
|
|
fprintf(f, ");\n");
|
|
}
|
|
else
|
|
fprintf(f, " return (%s)%s(data->%s);\n", rna_type_type(prop), (dp->booleannegative)? "!": "", dp->dnaname);
|
|
}
|
|
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
return func;
|
|
}
|
|
|
|
static void rna_clamp_value(FILE *f, PropertyRNA *prop, int array, int i)
|
|
{
|
|
if(prop->type == PROP_INT) {
|
|
IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
|
|
|
|
if(iprop->hardmin != INT_MIN || iprop->hardmax != INT_MAX) {
|
|
if(array) fprintf(f, "CLAMPIS(values[%d], ", i);
|
|
else fprintf(f, "CLAMPIS(value, ");
|
|
rna_int_print(f, iprop->hardmin); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->hardmax); fprintf(f, ");\n");
|
|
return;
|
|
}
|
|
}
|
|
else if(prop->type == PROP_FLOAT) {
|
|
FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
|
|
|
|
if(fprop->hardmin != -FLT_MAX || fprop->hardmax != FLT_MAX) {
|
|
if(array) fprintf(f, "CLAMPIS(values[%d], ", i);
|
|
else fprintf(f, "CLAMPIS(value, ");
|
|
rna_float_print(f, fprop->hardmin); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->hardmax); fprintf(f, ");\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(array)
|
|
fprintf(f, "values[%d];\n", i);
|
|
else
|
|
fprintf(f, "value;\n");
|
|
}
|
|
|
|
static char *rna_def_property_set_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, char *manualfunc)
|
|
{
|
|
char *func;
|
|
int i;
|
|
|
|
if(!(prop->flag & PROP_EDITABLE))
|
|
return NULL;
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
if(!manualfunc) {
|
|
if(!dp->dnastructname || !dp->dnaname) {
|
|
if(prop->flag & PROP_EDITABLE) {
|
|
fprintf(stderr, "rna_def_property_set_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "set");
|
|
|
|
switch(prop->type) {
|
|
case PROP_STRING: {
|
|
StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
|
|
fprintf(f, "void %s(PointerRNA *ptr, const char *value)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, value);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
fprintf(f, " BLI_strncpy(data->%s, value, %d);\n", dp->dnaname, sprop->maxlength);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
fprintf(f, "void %s(PointerRNA *ptr, PointerRNA value)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, value);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
fprintf(f, " data->%s= value.data;\n", dp->dnaname);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
break;
|
|
}
|
|
default:
|
|
if(prop->arraylength) {
|
|
fprintf(f, "void %s(PointerRNA *ptr, const %s values[%d])\n", func, rna_type_type(prop), prop->arraylength);
|
|
fprintf(f, "{\n");
|
|
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, values);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
|
|
for(i=0; i<prop->arraylength; i++) {
|
|
if(dp->dnaarraylength == 1) {
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit) {
|
|
fprintf(f, " if(%svalues[%d]) data->%s |= (%d<<%d);\n", (dp->booleannegative)? "!": "", i, dp->dnaname, dp->booleanbit, i);
|
|
fprintf(f, " else data->%s &= ~(%d<<%d);\n", dp->dnaname, dp->booleanbit, i);
|
|
}
|
|
else {
|
|
fprintf(f, " (&data->%s)[%d]= %s", dp->dnaname, i, (dp->booleannegative)? "!": "");
|
|
rna_clamp_value(f, prop, 1, i);
|
|
}
|
|
}
|
|
else {
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit) {
|
|
fprintf(f, " if(%svalues[%d]) data->%s[%d] |= ", (dp->booleannegative)? "!": "", i, dp->dnaname, i);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ";\n");
|
|
fprintf(f, " else data->%s[%d] &= ~", dp->dnaname, i);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ";\n");
|
|
}
|
|
else if(rna_color_quantize(prop, dp)) {
|
|
fprintf(f, " data->%s[%d]= FTOCHAR(values[%d]);\n", dp->dnaname, i, i);
|
|
}
|
|
else {
|
|
fprintf(f, " data->%s[%d]= %s", dp->dnaname, i, (dp->booleannegative)? "!": "");
|
|
rna_clamp_value(f, prop, 1, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
else {
|
|
fprintf(f, "void %s(PointerRNA *ptr, %s value)\n", func, rna_type_type(prop));
|
|
fprintf(f, "{\n");
|
|
|
|
if(manualfunc) {
|
|
fprintf(f, " %s(ptr, value);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
if(prop->type == PROP_BOOLEAN && dp->booleanbit) {
|
|
fprintf(f, " if(%svalue) data->%s |= ", (dp->booleannegative)? "!": "", dp->dnaname);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ";\n");
|
|
fprintf(f, " else data->%s &= ~", dp->dnaname);
|
|
rna_int_print(f, dp->booleanbit);
|
|
fprintf(f, ";\n");
|
|
}
|
|
else if(prop->type == PROP_ENUM && dp->enumbitflags) {
|
|
fprintf(f, " data->%s &= ~", dp->dnaname);
|
|
rna_int_print(f, rna_enum_bitmask(prop));
|
|
fprintf(f, ";\n");
|
|
fprintf(f, " data->%s |= value;\n", dp->dnaname);
|
|
}
|
|
else {
|
|
fprintf(f, " data->%s= %s", dp->dnaname, (dp->booleannegative)? "!": "");
|
|
rna_clamp_value(f, prop, 0, 0);
|
|
}
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
return func;
|
|
}
|
|
|
|
static char *rna_def_property_length_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, char *manualfunc)
|
|
{
|
|
char *func= NULL;
|
|
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
if(prop->type == PROP_STRING) {
|
|
if(!manualfunc) {
|
|
if(!dp->dnastructname || !dp->dnaname) {
|
|
fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "length");
|
|
|
|
fprintf(f, "int %s(PointerRNA *ptr)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " return %s(ptr);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
fprintf(f, " return strlen(data->%s);\n", dp->dnaname);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
else if(prop->type == PROP_COLLECTION) {
|
|
if(!manualfunc) {
|
|
if(prop->type == PROP_COLLECTION && (!(dp->dnalengthname || dp->dnalengthfixed)|| !dp->dnaname)) {
|
|
fprintf(stderr, "rna_def_property_length_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "length");
|
|
|
|
fprintf(f, "int %s(PointerRNA *ptr)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc) {
|
|
fprintf(f, " return %s(ptr);\n", manualfunc);
|
|
}
|
|
else {
|
|
rna_print_data_get(f, dp);
|
|
if(dp->dnalengthname)
|
|
fprintf(f, " return (data->%s == NULL)? 0: data->%s;\n", dp->dnaname, dp->dnalengthname);
|
|
else
|
|
fprintf(f, " return (data->%s == NULL)? 0: %d;\n", dp->dnaname, dp->dnalengthfixed);
|
|
}
|
|
fprintf(f, "}\n\n");
|
|
}
|
|
|
|
return func;
|
|
}
|
|
|
|
static char *rna_def_property_begin_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, char *manualfunc)
|
|
{
|
|
char *func, *getfunc;
|
|
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
if(!manualfunc) {
|
|
if(!dp->dnastructname || !dp->dnaname) {
|
|
fprintf(stderr, "rna_def_property_begin_func: %s.%s has no valid dna info.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "begin");
|
|
|
|
fprintf(f, "void %s(CollectionPropertyIterator *iter, PointerRNA *ptr)\n", func);
|
|
fprintf(f, "{\n");
|
|
|
|
if(!manualfunc)
|
|
rna_print_data_get(f, dp);
|
|
|
|
fprintf(f, "\n memset(iter, 0, sizeof(*iter));\n");
|
|
fprintf(f, " iter->parent= *ptr;\n");
|
|
fprintf(f, " iter->prop= (PropertyRNA*)&rna_%s_%s;\n", srna->identifier, prop->identifier);
|
|
|
|
if(dp->dnalengthname || dp->dnalengthfixed) {
|
|
if(manualfunc) {
|
|
fprintf(f, "\n %s(iter, ptr);\n", manualfunc);
|
|
}
|
|
else {
|
|
if(dp->dnalengthname)
|
|
fprintf(f, "\n rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), data->%s, NULL);\n", dp->dnaname, dp->dnaname, dp->dnalengthname);
|
|
else
|
|
fprintf(f, "\n rna_iterator_array_begin(iter, data->%s, sizeof(data->%s[0]), %d, NULL);\n", dp->dnaname, dp->dnaname, dp->dnalengthfixed);
|
|
}
|
|
}
|
|
else {
|
|
if(manualfunc)
|
|
fprintf(f, "\n %s(iter, ptr);\n", manualfunc);
|
|
else
|
|
fprintf(f, "\n rna_iterator_listbase_begin(iter, &data->%s, NULL);\n", dp->dnaname);
|
|
}
|
|
|
|
getfunc= rna_alloc_function_name(srna->identifier, prop->identifier, "get");
|
|
|
|
fprintf(f, "\n if(iter->valid)\n");
|
|
fprintf(f, " iter->ptr= %s(iter);\n", getfunc);
|
|
|
|
fprintf(f, "}\n\n");
|
|
|
|
|
|
return func;
|
|
}
|
|
|
|
static char *rna_def_property_next_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, char *manualfunc)
|
|
{
|
|
char *func, *getfunc;
|
|
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
if(!manualfunc)
|
|
return NULL;
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "next");
|
|
|
|
fprintf(f, "void %s(CollectionPropertyIterator *iter)\n", func);
|
|
fprintf(f, "{\n");
|
|
fprintf(f, " %s(iter);\n", manualfunc);
|
|
|
|
getfunc= rna_alloc_function_name(srna->identifier, prop->identifier, "get");
|
|
|
|
fprintf(f, "\n if(iter->valid)\n");
|
|
fprintf(f, " iter->ptr= %s(iter);\n", getfunc);
|
|
|
|
fprintf(f, "}\n\n");
|
|
|
|
return func;
|
|
}
|
|
|
|
static char *rna_def_property_end_func(FILE *f, StructRNA *srna, PropertyRNA *prop, PropertyDefRNA *dp, char *manualfunc)
|
|
{
|
|
char *func;
|
|
|
|
if(prop->flag & PROP_IDPROPERTY)
|
|
return NULL;
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "end");
|
|
|
|
fprintf(f, "void %s(CollectionPropertyIterator *iter)\n", func);
|
|
fprintf(f, "{\n");
|
|
if(manualfunc)
|
|
fprintf(f, " %s(iter);\n", manualfunc);
|
|
fprintf(f, "}\n\n");
|
|
|
|
return func;
|
|
}
|
|
|
|
static void rna_def_property_funcs(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
|
|
{
|
|
PropertyRNA *prop;
|
|
|
|
prop= dp->prop;
|
|
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN: {
|
|
BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
|
|
|
|
if(!prop->arraylength) {
|
|
bprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)bprop->get);
|
|
bprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)bprop->set);
|
|
}
|
|
else {
|
|
bprop->getarray= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)bprop->getarray);
|
|
bprop->setarray= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)bprop->setarray);
|
|
}
|
|
break;
|
|
}
|
|
case PROP_INT: {
|
|
IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
|
|
|
|
if(!prop->arraylength) {
|
|
iprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)iprop->get);
|
|
iprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)iprop->set);
|
|
}
|
|
else {
|
|
iprop->getarray= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)iprop->getarray);
|
|
iprop->setarray= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)iprop->setarray);
|
|
}
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
|
|
|
|
if(!prop->arraylength) {
|
|
fprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)fprop->get);
|
|
fprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)fprop->set);
|
|
}
|
|
else {
|
|
fprop->getarray= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)fprop->getarray);
|
|
fprop->setarray= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)fprop->setarray);
|
|
}
|
|
break;
|
|
}
|
|
case PROP_ENUM: {
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
|
|
eprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)eprop->get);
|
|
eprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)eprop->set);
|
|
break;
|
|
}
|
|
case PROP_STRING: {
|
|
StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
|
|
|
|
sprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)sprop->get);
|
|
sprop->length= (void*)rna_def_property_length_func(f, srna, prop, dp, (char*)sprop->length);
|
|
sprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)sprop->set);
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
|
|
|
|
pprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)pprop->get);
|
|
pprop->set= (void*)rna_def_property_set_func(f, srna, prop, dp, (char*)pprop->set);
|
|
if(!pprop->type) {
|
|
fprintf(stderr, "rna_def_property_funcs: %s.%s, pointer must have a struct type.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
|
|
|
|
if(dp->dnatype && strcmp(dp->dnatype, "ListBase")==0);
|
|
else if(dp->dnalengthname || dp->dnalengthfixed)
|
|
cprop->length= (void*)rna_def_property_length_func(f, srna, prop, dp, (char*)cprop->length);
|
|
|
|
cprop->get= (void*)rna_def_property_get_func(f, srna, prop, dp, (char*)cprop->get);
|
|
cprop->begin= (void*)rna_def_property_begin_func(f, srna, prop, dp, (char*)cprop->begin);
|
|
cprop->next= (void*)rna_def_property_next_func(f, srna, prop, dp, (char*)cprop->next);
|
|
cprop->end= (void*)rna_def_property_end_func(f, srna, prop, dp, (char*)cprop->end);
|
|
|
|
if(!(prop->flag & PROP_IDPROPERTY)) {
|
|
if(!cprop->begin) {
|
|
fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a begin function.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
if(!cprop->next) {
|
|
fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a next function.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
if(!cprop->get) {
|
|
fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a get function.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
}
|
|
if(!cprop->type) {
|
|
fprintf(stderr, "rna_def_property_funcs: %s.%s, collection must have a struct type.\n", srna->identifier, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void rna_def_property_funcs_header(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
|
|
{
|
|
PropertyRNA *prop;
|
|
char *func;
|
|
|
|
prop= dp->prop;
|
|
|
|
if(prop->flag & (PROP_IDPROPERTY|PROP_BUILTIN))
|
|
return;
|
|
|
|
func= rna_alloc_function_name(srna->identifier, prop->identifier, "");
|
|
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN:
|
|
case PROP_INT: {
|
|
if(!prop->arraylength) {
|
|
fprintf(f, "int %sget(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, int value);\n", func);
|
|
}
|
|
else {
|
|
fprintf(f, "void %sget(PointerRNA *ptr, int values[%d]);\n", func, prop->arraylength);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, const int values[%d]);\n", func, prop->arraylength);
|
|
}
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
if(!prop->arraylength) {
|
|
fprintf(f, "float %sget(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, float value);\n", func);
|
|
}
|
|
else {
|
|
fprintf(f, "void %sget(PointerRNA *ptr, float values[%d]);\n", func, prop->arraylength);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, const float values[%d]);\n", func, prop->arraylength);
|
|
}
|
|
break;
|
|
}
|
|
case PROP_ENUM: {
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
int i;
|
|
|
|
if(eprop->item) {
|
|
fprintf(f, "enum {\n");
|
|
|
|
for(i=0; i<eprop->totitem; i++)
|
|
fprintf(f, "\t%s_%s_%s = %d,\n", srna->identifier, prop->identifier, eprop->item[i].identifier, eprop->item[i].value);
|
|
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
|
|
fprintf(f, "int %sget(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, int value);\n", func);
|
|
|
|
break;
|
|
}
|
|
case PROP_STRING: {
|
|
StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
|
|
|
|
if(sprop->maxlength) {
|
|
fprintf(f, "#define %s_%s_MAX %d\n\n", srna->identifier, prop->identifier, sprop->maxlength);
|
|
}
|
|
|
|
fprintf(f, "void %sget(PointerRNA *ptr, char *value);\n", func);
|
|
fprintf(f, "int %slength(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, const char *value);\n", func);
|
|
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
fprintf(f, "PointerRNA %sget(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %sset(PointerRNA *ptr, PointerRNA value);\n", func);
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
fprintf(f, "void %sbegin(CollectionPropertyIterator *iter, PointerRNA *ptr);\n", func);
|
|
fprintf(f, "void %snext(CollectionPropertyIterator *iter);\n", func);
|
|
fprintf(f, "void %send(CollectionPropertyIterator *iter);\n", func);
|
|
//fprintf(f, "int %slength(PointerRNA *ptr);\n", func);
|
|
//fprintf(f, "void %slookup_int(PointerRNA *ptr, int key, StructRNA **type);\n", func);
|
|
//fprintf(f, "void %slookup_string(PointerRNA *ptr, const char *key, StructRNA **type);\n", func);
|
|
break;
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_def_property_funcs_header_cpp(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
|
|
{
|
|
PropertyRNA *prop;
|
|
|
|
prop= dp->prop;
|
|
|
|
if(prop->flag & (PROP_IDPROPERTY|PROP_BUILTIN))
|
|
return;
|
|
|
|
if(prop->name && prop->description && strcmp(prop->description, "") != 0)
|
|
fprintf(f, "\t/* %s: %s */\n", prop->name, prop->description);
|
|
else if(prop->name)
|
|
fprintf(f, "\t/* %s */\n", prop->name);
|
|
else
|
|
fprintf(f, "\t/* */\n");
|
|
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tbool %s(void);", prop->identifier);
|
|
else
|
|
fprintf(f, "\tArray<int, %d> %s(void);", prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_INT: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tint %s(void);", prop->identifier);
|
|
else
|
|
fprintf(f, "\tArray<int, %d> %s(void);", prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tfloat %s(void);", prop->identifier);
|
|
else
|
|
fprintf(f, "\tArray<float, %d> %s(void);", prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_ENUM: {
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
int i;
|
|
|
|
if(eprop->item) {
|
|
fprintf(f, "\tenum %s_enum {\n", prop->identifier);
|
|
|
|
for(i=0; i<eprop->totitem; i++)
|
|
fprintf(f, "\t\t%s_%s = %d,\n", prop->identifier, eprop->item[i].identifier, eprop->item[i].value);
|
|
|
|
fprintf(f, "\t};\n");
|
|
}
|
|
|
|
fprintf(f, "\t%s_enum %s(void);", prop->identifier, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_STRING: {
|
|
fprintf(f, "\tstd::string %s(void);", prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)dp->prop;
|
|
|
|
if(pprop->type)
|
|
fprintf(f, "\t%s %s(void);", (char*)pprop->type, prop->identifier);
|
|
else
|
|
fprintf(f, "\t%s %s(void);", "UnknownType", prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
|
|
|
|
if(cprop->type)
|
|
fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (char*)cprop->type, srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);
|
|
break;
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_def_property_funcs_impl_cpp(FILE *f, StructRNA *srna, PropertyDefRNA *dp)
|
|
{
|
|
PropertyRNA *prop;
|
|
|
|
prop= dp->prop;
|
|
|
|
if(prop->flag & (PROP_IDPROPERTY|PROP_BUILTIN))
|
|
return;
|
|
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tBOOLEAN_PROPERTY(%s, %s)", srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tBOOLEAN_ARRAY_PROPERTY(%s, %d, %s)", srna->identifier, prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_INT: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tINT_PROPERTY(%s, %s)", srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tINT_ARRAY_PROPERTY(%s, %d, %s)", srna->identifier, prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
if(!prop->arraylength)
|
|
fprintf(f, "\tFLOAT_PROPERTY(%s, %s)", srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tFLOAT_ARRAY_PROPERTY(%s, %d, %s)", srna->identifier, prop->arraylength, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_ENUM: {
|
|
fprintf(f, "\tENUM_PROPERTY(%s_enum, %s, %s)", prop->identifier, srna->identifier, prop->identifier);
|
|
|
|
break;
|
|
}
|
|
case PROP_STRING: {
|
|
fprintf(f, "\tSTRING_PROPERTY(%s, %s)", srna->identifier, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)dp->prop;
|
|
|
|
if(pprop->type)
|
|
fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", (char*)pprop->type, srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tPOINTER_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
/*CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
|
|
|
|
if(cprop->type)
|
|
fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", (char*)cprop->type, srna->identifier, prop->identifier);
|
|
else
|
|
fprintf(f, "\tCOLLECTION_PROPERTY(%s, %s, %s)", "UnknownType", srna->identifier, prop->identifier);*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA *dfunc)
|
|
{
|
|
StructRNA *srna;
|
|
FunctionRNA *func;
|
|
PropertyDefRNA *dparm;
|
|
char *funcname, *ptrstr;
|
|
|
|
srna= dsrna->srna;
|
|
func= dfunc->func;
|
|
|
|
funcname= rna_alloc_function_name(srna->identifier, func->identifier, "call");
|
|
|
|
fprintf(f, "void %s(PointerRNA *_ptr, ParameterList *_parms)", funcname);
|
|
fprintf(f, "\n{\n");
|
|
|
|
if((func->flag & FUNC_TYPESTATIC)==0) {
|
|
if(dsrna->dnaname) fprintf(f, "\tstruct %s *_self;\n", dsrna->dnaname);
|
|
else fprintf(f, "\tstruct %s *_self;\n", srna->identifier);
|
|
}
|
|
|
|
dparm= dfunc->cont.properties.first;
|
|
for(; dparm; dparm= dparm->next) {
|
|
ptrstr= (dparm->prop->type == PROP_POINTER || dparm->prop->arraylength > 0)? "*" : "";
|
|
fprintf(f, "\t%s%s %s%s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, dparm->prop->identifier);
|
|
}
|
|
|
|
fprintf(f, "\tchar *_data");
|
|
if(func->ret) fprintf(f, ", *_retdata");
|
|
fprintf(f, ";\n");
|
|
fprintf(f, "\t\n");
|
|
|
|
if((func->flag & FUNC_TYPESTATIC)==0) {
|
|
if(dsrna->dnaname) fprintf(f, "\t_self= (struct %s *)_ptr->data;\n", dsrna->dnaname);
|
|
else fprintf(f, "\t_self= (struct %s *)_ptr->data;\n", srna->identifier);
|
|
}
|
|
|
|
fprintf(f, "\t_data= (char *)_parms->data;\n");
|
|
|
|
dparm= dfunc->cont.properties.first;
|
|
for(; dparm; dparm= dparm->next) {
|
|
if(dparm->prop==func->ret)
|
|
fprintf(f, "\t_retdata= _data;\n");
|
|
else if(dparm->prop->arraylength)
|
|
fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
else if(dparm->prop->type == PROP_POINTER) {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)dparm->prop;
|
|
|
|
if(strcmp((char*)pprop->type, "AnyType") == 0)
|
|
fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
else
|
|
fprintf(f, "\t%s= *((%s%s**)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
}
|
|
else
|
|
fprintf(f, "\t%s= *((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
|
|
if(dparm->next)
|
|
fprintf(f, "\t_data+= %d;\n", rna_parameter_size(dparm->prop));
|
|
}
|
|
|
|
if(dfunc->call) {
|
|
fprintf(f, "\t\n");
|
|
fprintf(f, "\t");
|
|
if(func->ret) fprintf(f, "%s= ", func->ret->identifier);
|
|
fprintf(f, "%s(", dfunc->call);
|
|
|
|
if((func->flag & FUNC_TYPESTATIC)==0)
|
|
fprintf(f, "_self");
|
|
|
|
dparm= dfunc->cont.properties.first;
|
|
for(; dparm; dparm= dparm->next) {
|
|
if(dparm->prop==func->ret)
|
|
continue;
|
|
|
|
if((func->flag & FUNC_TYPESTATIC)==0 || dparm!=dfunc->cont.properties.first)
|
|
fprintf(f, ", ");
|
|
fprintf(f, "%s", dparm->prop->identifier);
|
|
}
|
|
|
|
fprintf(f, ");\n");
|
|
|
|
if(func->ret) {
|
|
dparm= rna_find_parameter_def(func->ret);
|
|
ptrstr= dparm->prop->type == PROP_POINTER || dparm->prop->arraylength > 0 ? "*" : "";
|
|
fprintf(f, "\t*((%s%s%s*)_retdata)= %s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, func->ret->identifier);
|
|
}
|
|
}
|
|
|
|
fprintf(f, "}\n\n");
|
|
|
|
dfunc->gencall= funcname;
|
|
}
|
|
|
|
static void rna_auto_types()
|
|
{
|
|
StructDefRNA *ds;
|
|
PropertyDefRNA *dp;
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
/* DNA name for Screen is patched in 2.5, we do the reverse here .. */
|
|
if(ds->dnaname && strcmp(ds->dnaname, "Screen") == 0)
|
|
ds->dnaname= "bScreen";
|
|
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next) {
|
|
if(dp->dnastructname && strcmp(dp->dnastructname, "Screen") == 0)
|
|
dp->dnastructname= "bScreen";
|
|
|
|
if(dp->dnatype) {
|
|
if(dp->prop->type == PROP_POINTER) {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)dp->prop;
|
|
|
|
if(!pprop->type && !pprop->get)
|
|
pprop->type= (StructRNA*)rna_find_type(dp->dnatype);
|
|
}
|
|
else if(dp->prop->type== PROP_COLLECTION) {
|
|
CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)dp->prop;
|
|
|
|
if(!cprop->type && !cprop->get && strcmp(dp->dnatype, "ListBase")==0)
|
|
cprop->type= (StructRNA*)rna_find_type(dp->dnatype);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void rna_sort(BlenderRNA *brna)
|
|
{
|
|
StructDefRNA *ds;
|
|
StructRNA *srna;
|
|
|
|
rna_sortlist(&brna->structs, cmp_struct);
|
|
rna_sortlist(&DefRNA.structs, cmp_def_struct);
|
|
|
|
for(srna=brna->structs.first; srna; srna=srna->cont.next)
|
|
rna_sortlist(&srna->cont.properties, cmp_property);
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
rna_sortlist(&ds->cont.properties, cmp_def_property);
|
|
}
|
|
|
|
static const char *rna_property_structname(PropertyType type)
|
|
{
|
|
switch(type) {
|
|
case PROP_BOOLEAN: return "BooleanPropertyRNA";
|
|
case PROP_INT: return "IntPropertyRNA";
|
|
case PROP_FLOAT: return "FloatPropertyRNA";
|
|
case PROP_STRING: return "StringPropertyRNA";
|
|
case PROP_ENUM: return "EnumPropertyRNA";
|
|
case PROP_POINTER: return "PointerPropertyRNA";
|
|
case PROP_COLLECTION: return "CollectionPropertyRNA";
|
|
default: return "UnknownPropertyRNA";
|
|
}
|
|
}
|
|
|
|
static const char *rna_property_typename(PropertyType type)
|
|
{
|
|
switch(type) {
|
|
case PROP_BOOLEAN: return "PROP_BOOLEAN";
|
|
case PROP_INT: return "PROP_INT";
|
|
case PROP_FLOAT: return "PROP_FLOAT";
|
|
case PROP_STRING: return "PROP_STRING";
|
|
case PROP_ENUM: return "PROP_ENUM";
|
|
case PROP_POINTER: return "PROP_POINTER";
|
|
case PROP_COLLECTION: return "PROP_COLLECTION";
|
|
default: return "PROP_UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static const char *rna_property_subtypename(PropertyType type)
|
|
{
|
|
switch(type) {
|
|
case PROP_NONE: return "PROP_NONE";
|
|
case PROP_UNSIGNED: return "PROP_UNSIGNED";
|
|
case PROP_FILEPATH: return "PROP_FILEPATH";
|
|
case PROP_DIRPATH: return "PROP_DIRPATH";
|
|
case PROP_COLOR: return "PROP_COLOR";
|
|
case PROP_VECTOR: return "PROP_VECTOR";
|
|
case PROP_MATRIX: return "PROP_MATRIX";
|
|
case PROP_ROTATION: return "PROP_ROTATION";
|
|
case PROP_NEVER_NULL: return "PROP_NEVER_NULL";
|
|
case PROP_PERCENTAGE: return "PROP_PERCENTAGE";
|
|
default: return "PROP_UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static void rna_generate_prototypes(BlenderRNA *brna, FILE *f)
|
|
{
|
|
StructRNA *srna;
|
|
|
|
for(srna=brna->structs.first; srna; srna=srna->cont.next)
|
|
fprintf(f, "extern StructRNA RNA_%s;\n", srna->identifier);
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_generate_blender(BlenderRNA *brna, FILE *f)
|
|
{
|
|
StructRNA *srna;
|
|
|
|
fprintf(f, "BlenderRNA BLENDER_RNA = {");
|
|
|
|
srna= brna->structs.first;
|
|
if(srna) fprintf(f, "{&RNA_%s, ", srna->identifier);
|
|
else fprintf(f, "{NULL, ");
|
|
|
|
srna= brna->structs.last;
|
|
if(srna) fprintf(f, "&RNA_%s}", srna->identifier);
|
|
else fprintf(f, "NULL}");
|
|
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
|
|
static void rna_generate_property_prototypes(BlenderRNA *brna, StructRNA *srna, FILE *f)
|
|
{
|
|
PropertyRNA *prop;
|
|
StructRNA *base;
|
|
|
|
base= srna->base;
|
|
while (base) {
|
|
fprintf(f, "\n");
|
|
for(prop=base->cont.properties.first; prop; prop=prop->next)
|
|
fprintf(f, "%s%s rna_%s_%s;\n", "extern ", rna_property_structname(prop->type), base->identifier, prop->identifier);
|
|
base= base->base;
|
|
}
|
|
|
|
if(srna->cont.properties.first)
|
|
fprintf(f, "\n");
|
|
|
|
for(prop=srna->cont.properties.first; prop; prop=prop->next)
|
|
fprintf(f, "%s%s rna_%s_%s;\n", (prop->flag & PROP_EXPORT)? "": "", rna_property_structname(prop->type), srna->identifier, prop->identifier);
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_generate_parameter_prototypes(BlenderRNA *brna, StructRNA *srna, FunctionRNA *func, FILE *f)
|
|
{
|
|
PropertyRNA *parm;
|
|
|
|
for(parm= func->cont.properties.first; parm; parm= parm->next)
|
|
fprintf(f, "%s%s rna_%s_%s_%s;\n", "extern ", rna_property_structname(parm->type), srna->identifier, func->identifier, parm->identifier);
|
|
|
|
if(func->cont.properties.first)
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_generate_function_prototypes(BlenderRNA *brna, StructRNA *srna, FILE *f)
|
|
{
|
|
FunctionRNA *func;
|
|
StructRNA *base;
|
|
|
|
base= srna->base;
|
|
while (base) {
|
|
for(func= base->functions.first; func; func= func->cont.next) {
|
|
fprintf(f, "%s%s rna_%s_%s;\n", "extern ", "FunctionRNA", base->identifier, func->identifier);
|
|
rna_generate_parameter_prototypes(brna, base, func, f);
|
|
}
|
|
|
|
if(base->functions.first)
|
|
fprintf(f, "\n");
|
|
|
|
base= base->base;
|
|
}
|
|
|
|
for(func= srna->functions.first; func; func= func->cont.next) {
|
|
fprintf(f, "%s%s rna_%s_%s;\n", "extern ", "FunctionRNA", srna->identifier, func->identifier);
|
|
rna_generate_parameter_prototypes(brna, srna, func, f);
|
|
}
|
|
|
|
if(srna->functions.first)
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_generate_static_parameter_prototypes(BlenderRNA *brna, StructRNA *srna, FunctionDefRNA *dfunc, FILE *f)
|
|
{
|
|
FunctionRNA *func;
|
|
PropertyDefRNA *dparm;
|
|
StructDefRNA *dsrna;
|
|
|
|
dsrna= rna_find_struct_def(srna);
|
|
func= dfunc->func;
|
|
|
|
for(dparm= dfunc->cont.properties.first; dparm; dparm= dparm->next) {
|
|
if(dparm->prop==func->ret) {
|
|
if(dparm->prop->arraylength)
|
|
fprintf(f, "XXX no array return types yet"); /* XXX not supported */
|
|
else if(dparm->prop->type == PROP_POINTER)
|
|
fprintf(f, "%s%s *", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
else
|
|
fprintf(f, "%s%s ", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!dparm)
|
|
fprintf(f, "void ");
|
|
|
|
fprintf(f, "%s(", dfunc->call);
|
|
|
|
if(dsrna->dnaname) fprintf(f, "struct %s *_self", dsrna->dnaname);
|
|
else fprintf(f, "struct %s *_self", srna->identifier);
|
|
|
|
for(dparm= dfunc->cont.properties.first; dparm; dparm= dparm->next) {
|
|
if(dparm->prop==func->ret) ;
|
|
else if(dparm->prop->arraylength)
|
|
fprintf(f, ", %s%s %s[%d]", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), dparm->prop->identifier, dparm->prop->arraylength);
|
|
else if(dparm->prop->type == PROP_POINTER)
|
|
fprintf(f, ", %s%s *%s", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), dparm->prop->identifier);
|
|
else
|
|
fprintf(f, ", %s%s %s", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), dparm->prop->identifier);
|
|
}
|
|
|
|
fprintf(f, ");\n");
|
|
}
|
|
|
|
static void rna_generate_static_function_prototypes(BlenderRNA *brna, StructRNA *srna, FILE *f)
|
|
{
|
|
FunctionRNA *func;
|
|
FunctionDefRNA *dfunc;
|
|
|
|
fprintf(f, "/* Repeated prototypes to detect errors */\n\n");
|
|
|
|
for(func= srna->functions.first; func; func= func->cont.next) {
|
|
dfunc= rna_find_function_def(func);
|
|
if(dfunc->call)
|
|
rna_generate_static_parameter_prototypes(brna, srna, dfunc, f);
|
|
}
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, PropertyRNA *prop)
|
|
{
|
|
char *strnest= "", *errnest= "";
|
|
int len, freenest= 0;
|
|
|
|
if(nest != NULL) {
|
|
len= strlen(nest);
|
|
|
|
strnest= MEM_mallocN(sizeof(char)*(len+1), "rna_generate_property -> strnest");
|
|
errnest= MEM_mallocN(sizeof(char)*(len+1), "rna_generate_property -> errnest");
|
|
|
|
strcpy(strnest, "_"); strcat(strnest, nest);
|
|
strcpy(errnest, "."); strcat(errnest, nest);
|
|
|
|
freenest= 1;
|
|
}
|
|
|
|
switch(prop->type) {
|
|
case PROP_ENUM: {
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
int i, defaultfound= 0;
|
|
|
|
if(eprop->item) {
|
|
fprintf(f, "static EnumPropertyItem rna_%s%s_%s_items[%d] = {", srna->identifier, strnest, prop->identifier, eprop->totitem);
|
|
|
|
for(i=0; i<eprop->totitem; i++) {
|
|
fprintf(f, "{%d, ", eprop->item[i].value);
|
|
rna_print_c_string(f, eprop->item[i].identifier); fprintf(f, ", ");
|
|
rna_print_c_string(f, eprop->item[i].name); fprintf(f, ", ");
|
|
rna_print_c_string(f, eprop->item[i].description); fprintf(f, "}");
|
|
if(i != eprop->totitem-1)
|
|
fprintf(f, ", ");
|
|
|
|
if(eprop->defaultvalue == eprop->item[i].value)
|
|
defaultfound= 1;
|
|
}
|
|
|
|
fprintf(f, "};\n\n");
|
|
|
|
if(!defaultfound) {
|
|
fprintf(stderr, "rna_generate_structs: %s%s.%s, enum default is not in items.\n", srna->identifier, errnest, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
}
|
|
else {
|
|
fprintf(stderr, "rna_generate_structs: %s%s.%s, enum must have items defined.\n", srna->identifier, errnest, prop->identifier);
|
|
DefRNA.error= 1;
|
|
}
|
|
break;
|
|
}
|
|
case PROP_BOOLEAN: {
|
|
BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
|
|
unsigned int i;
|
|
|
|
if(prop->arraylength) {
|
|
fprintf(f, "static int rna_%s%s_%s_default[%d] = {", srna->identifier, strnest, prop->identifier, prop->arraylength);
|
|
|
|
for(i=0; i<prop->arraylength; i++) {
|
|
if(bprop->defaultarray)
|
|
fprintf(f, "%d", bprop->defaultarray[i]);
|
|
else
|
|
fprintf(f, "%d", bprop->defaultvalue);
|
|
if(i != prop->arraylength-1)
|
|
fprintf(f, ", ");
|
|
}
|
|
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
break;
|
|
}
|
|
case PROP_INT: {
|
|
IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
|
|
unsigned int i;
|
|
|
|
if(prop->arraylength) {
|
|
fprintf(f, "static int rna_%s%s_%s_default[%d] = {", srna->identifier, strnest, prop->identifier, prop->arraylength);
|
|
|
|
for(i=0; i<prop->arraylength; i++) {
|
|
if(iprop->defaultarray)
|
|
fprintf(f, "%d", iprop->defaultarray[i]);
|
|
else
|
|
fprintf(f, "%d", iprop->defaultvalue);
|
|
if(i != prop->arraylength-1)
|
|
fprintf(f, ", ");
|
|
}
|
|
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
|
|
unsigned int i;
|
|
|
|
if(prop->arraylength) {
|
|
fprintf(f, "static float rna_%s%s_%s_default[%d] = {", srna->identifier, strnest, prop->identifier, prop->arraylength);
|
|
|
|
for(i=0; i<prop->arraylength; i++) {
|
|
if(fprop->defaultarray)
|
|
rna_float_print(f, fprop->defaultarray[i]);
|
|
else
|
|
rna_float_print(f, fprop->defaultvalue);
|
|
if(i != prop->arraylength-1)
|
|
fprintf(f, ", ");
|
|
}
|
|
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
fprintf(f, "%s%s rna_%s%s_%s = {\n", (prop->flag & PROP_EXPORT)? "": "", rna_property_structname(prop->type), srna->identifier, strnest, prop->identifier);
|
|
|
|
if(prop->next) fprintf(f, "\t{(PropertyRNA*)&rna_%s%s_%s, ", srna->identifier, strnest, prop->next->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
if(prop->prev) fprintf(f, "(PropertyRNA*)&rna_%s%s_%s,\n", srna->identifier, strnest, prop->prev->identifier);
|
|
else fprintf(f, "NULL,\n");
|
|
fprintf(f, "\t%d, ", prop->magic);
|
|
rna_print_c_string(f, prop->identifier);
|
|
fprintf(f, ", %d, ", prop->flag);
|
|
rna_print_c_string(f, prop->name); fprintf(f, ",\n\t");
|
|
rna_print_c_string(f, prop->description); fprintf(f, ",\n");
|
|
fprintf(f, "\t%s, %s, %d,\n", rna_property_typename(prop->type), rna_property_subtypename(prop->subtype), prop->arraylength);
|
|
fprintf(f, "\t%s, %d, %s},\n", rna_function_string(prop->update), prop->noteflag, rna_function_string(prop->editable));
|
|
|
|
switch(prop->type) {
|
|
case PROP_BOOLEAN: {
|
|
BooleanPropertyRNA *bprop= (BooleanPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, %s, %s, %d, ", rna_function_string(bprop->get), rna_function_string(bprop->set), rna_function_string(bprop->getarray), rna_function_string(bprop->setarray), bprop->defaultvalue);
|
|
if(prop->arraylength) fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
|
|
else fprintf(f, "NULL\n");
|
|
break;
|
|
}
|
|
case PROP_INT: {
|
|
IntPropertyRNA *iprop= (IntPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, %s, %s, %s,\n\t", rna_function_string(iprop->get), rna_function_string(iprop->set), rna_function_string(iprop->getarray), rna_function_string(iprop->setarray), rna_function_string(iprop->range));
|
|
rna_int_print(f, iprop->softmin); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->softmax); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->hardmin); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->hardmax); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->step); fprintf(f, ", ");
|
|
rna_int_print(f, iprop->defaultvalue); fprintf(f, ", ");
|
|
if(prop->arraylength) fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
|
|
else fprintf(f, "NULL\n");
|
|
break;
|
|
}
|
|
case PROP_FLOAT: {
|
|
FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, %s, %s, %s, ", rna_function_string(fprop->get), rna_function_string(fprop->set), rna_function_string(fprop->getarray), rna_function_string(fprop->setarray), rna_function_string(fprop->range));
|
|
rna_float_print(f, fprop->softmin); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->softmax); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->hardmin); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->hardmax); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->step); fprintf(f, ", ");
|
|
rna_int_print(f, (int)fprop->precision); fprintf(f, ", ");
|
|
rna_float_print(f, fprop->defaultvalue); fprintf(f, ", ");
|
|
if(prop->arraylength) fprintf(f, "rna_%s%s_%s_default\n", srna->identifier, strnest, prop->identifier);
|
|
else fprintf(f, "NULL\n");
|
|
break;
|
|
}
|
|
case PROP_STRING: {
|
|
StringPropertyRNA *sprop= (StringPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, %s, %d, ", rna_function_string(sprop->get), rna_function_string(sprop->length), rna_function_string(sprop->set), sprop->maxlength);
|
|
rna_print_c_string(f, sprop->defaultvalue); fprintf(f, "\n");
|
|
break;
|
|
}
|
|
case PROP_ENUM: {
|
|
EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, rna_%s%s_%s_items, %d, %d\n", rna_function_string(eprop->get), rna_function_string(eprop->set), srna->identifier, strnest, prop->identifier, eprop->totitem, eprop->defaultvalue);
|
|
break;
|
|
}
|
|
case PROP_POINTER: {
|
|
PointerPropertyRNA *pprop= (PointerPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, ", rna_function_string(pprop->get), rna_function_string(pprop->set));
|
|
if(pprop->type) fprintf(f, "&RNA_%s\n", (char*)pprop->type);
|
|
else fprintf(f, "NULL\n");
|
|
break;
|
|
}
|
|
case PROP_COLLECTION: {
|
|
CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop;
|
|
fprintf(f, "\t%s, %s, %s, %s, %s, %s, %s, ", rna_function_string(cprop->begin), rna_function_string(cprop->next), rna_function_string(cprop->end), rna_function_string(cprop->get), rna_function_string(cprop->length), rna_function_string(cprop->lookupint), rna_function_string(cprop->lookupstring));
|
|
if(cprop->type) fprintf(f, "&RNA_%s\n", (char*)cprop->type);
|
|
else fprintf(f, "NULL\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
fprintf(f, "};\n\n");
|
|
|
|
if(freenest) {
|
|
MEM_freeN(strnest);
|
|
MEM_freeN(errnest);
|
|
}
|
|
}
|
|
|
|
static void rna_generate_struct(BlenderRNA *brna, StructRNA *srna, FILE *f)
|
|
{
|
|
FunctionRNA *func;
|
|
FunctionDefRNA *dfunc;
|
|
PropertyRNA *prop, *parm;
|
|
StructRNA *base;
|
|
|
|
fprintf(f, "/* %s */\n", srna->name);
|
|
|
|
for(prop= srna->cont.properties.first; prop; prop= prop->next)
|
|
rna_generate_property(f, srna, NULL, prop);
|
|
|
|
for(func= srna->functions.first; func; func= func->cont.next) {
|
|
for(parm= func->cont.properties.first; parm; parm= parm->next)
|
|
rna_generate_property(f, srna, func->identifier, parm);
|
|
|
|
fprintf(f, "%s%s rna_%s_%s = {\n", "", "FunctionRNA", srna->identifier, func->identifier);
|
|
|
|
if(func->cont.next) fprintf(f, "\t{(FunctionRNA*)&rna_%s_%s, ", srna->identifier, ((FunctionRNA*)func->cont.next)->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
if(func->cont.prev) fprintf(f, "(FunctionRNA*)&rna_%s_%s,\n", srna->identifier, ((FunctionRNA*)func->cont.prev)->identifier);
|
|
else fprintf(f, "NULL,\n");
|
|
|
|
parm= func->cont.properties.first;
|
|
if(parm) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s_%s, ", srna->identifier, func->identifier, parm->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
|
|
parm= func->cont.properties.last;
|
|
if(parm) fprintf(f, "(PropertyRNA*)&rna_%s_%s_%s}},\n", srna->identifier, func->identifier, parm->identifier);
|
|
else fprintf(f, "NULL}},\n");
|
|
|
|
fprintf(f, "\t");
|
|
rna_print_c_string(f, func->identifier);
|
|
fprintf(f, ", %d, ", func->flag);
|
|
rna_print_c_string(f, func->description); fprintf(f, ",\n");
|
|
|
|
dfunc= rna_find_function_def(func);
|
|
if(dfunc->gencall) fprintf(f, "\t%s,\n", dfunc->gencall);
|
|
else fprintf(f, "\tNULL,\n");
|
|
|
|
if(func->ret) fprintf(f, "\t(PropertyRNA*)&rna_%s_%s_%s\n", srna->identifier, func->identifier, func->ret->identifier);
|
|
else fprintf(f, "\tNULL\n");
|
|
|
|
fprintf(f, "};\n");
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "StructRNA RNA_%s = {\n", srna->identifier);
|
|
|
|
if(srna->cont.next) fprintf(f, "\t{(ContainerRNA *)&RNA_%s, ", ((StructRNA*)srna->cont.next)->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
if(srna->cont.prev) fprintf(f, "(ContainerRNA *)&RNA_%s,\n", ((StructRNA*)srna->cont.prev)->identifier);
|
|
else fprintf(f, "NULL,\n");
|
|
|
|
prop= srna->cont.properties.first;
|
|
if(prop) fprintf(f, "\t{(PropertyRNA*)&rna_%s_%s, ", srna->identifier, prop->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
|
|
prop= srna->cont.properties.last;
|
|
if(prop) fprintf(f, "(PropertyRNA*)&rna_%s_%s}},\n", srna->identifier, prop->identifier);
|
|
else fprintf(f, "NULL}},\n");
|
|
|
|
fprintf(f, "\tNULL,\n"); /* PyType - Cant initialize here */
|
|
|
|
fprintf(f, "\t");
|
|
rna_print_c_string(f, srna->identifier);
|
|
fprintf(f, ", %d, ", srna->flag);
|
|
rna_print_c_string(f, srna->name);
|
|
fprintf(f, ", ");
|
|
rna_print_c_string(f, srna->description);
|
|
fprintf(f, ",\n");
|
|
|
|
prop= srna->nameproperty;
|
|
if(prop) {
|
|
base= srna;
|
|
while (base->base && base->base->nameproperty==prop)
|
|
base= base->base;
|
|
|
|
fprintf(f, "\t(PropertyRNA*)&rna_%s_%s, ", base->identifier, prop->identifier);
|
|
}
|
|
else fprintf(f, "\tNULL, ");
|
|
|
|
prop= srna->iteratorproperty;
|
|
base= srna;
|
|
while (base->base && base->base->iteratorproperty==prop)
|
|
base= base->base;
|
|
fprintf(f, "(PropertyRNA*)&rna_%s_rna_properties,\n", base->identifier);
|
|
|
|
if(srna->base) fprintf(f, "\t&RNA_%s,\n", srna->base->identifier);
|
|
else fprintf(f, "\tNULL,\n");
|
|
|
|
if(srna->nested) fprintf(f, "\t&RNA_%s,\n", srna->nested->identifier);
|
|
else fprintf(f, "\tNULL,\n");
|
|
|
|
fprintf(f, "\t%s,\n", rna_function_string(srna->refine));
|
|
fprintf(f, "\t%s,\n", rna_function_string(srna->path));
|
|
|
|
func= srna->functions.first;
|
|
if(func) fprintf(f, "\t{(FunctionRNA*)&rna_%s_%s, ", srna->identifier, func->identifier);
|
|
else fprintf(f, "\t{NULL, ");
|
|
|
|
func= srna->functions.last;
|
|
if(func) fprintf(f, "(FunctionRNA*)&rna_%s_%s}\n", srna->identifier, func->identifier);
|
|
else fprintf(f, "NULL}\n");
|
|
|
|
fprintf(f, "};\n");
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
typedef struct RNAProcessItem {
|
|
char *filename;
|
|
void (*define)(BlenderRNA *brna);
|
|
} RNAProcessItem;
|
|
|
|
RNAProcessItem PROCESS_ITEMS[]= {
|
|
{"rna_rna.c", RNA_def_rna},
|
|
{"rna_ID.c", RNA_def_ID},
|
|
{"rna_texture.c", RNA_def_texture},
|
|
{"rna_action.c", RNA_def_action},
|
|
{"rna_animation.c", RNA_def_animation},
|
|
{"rna_actuator.c", RNA_def_actuator},
|
|
{"rna_armature.c", RNA_def_armature},
|
|
{"rna_brush.c", RNA_def_brush},
|
|
{"rna_camera.c", RNA_def_camera},
|
|
{"rna_cloth.c", RNA_def_cloth},
|
|
{"rna_color.c", RNA_def_color},
|
|
{"rna_constraint.c", RNA_def_constraint},
|
|
{"rna_context.c", RNA_def_context},
|
|
{"rna_controller.c", RNA_def_controller},
|
|
{"rna_curve.c", RNA_def_curve},
|
|
{"rna_fluidsim.c", RNA_def_fluidsim},
|
|
{"rna_group.c", RNA_def_group},
|
|
{"rna_image.c", RNA_def_image},
|
|
{"rna_key.c", RNA_def_key},
|
|
{"rna_lamp.c", RNA_def_lamp},
|
|
{"rna_lattice.c", RNA_def_lattice},
|
|
{"rna_main.c", RNA_def_main},
|
|
{"rna_material.c", RNA_def_material},
|
|
{"rna_mesh.c", RNA_def_mesh},
|
|
{"rna_meta.c", RNA_def_meta},
|
|
{"rna_modifier.c", RNA_def_modifier},
|
|
{"rna_nodetree.c", RNA_def_nodetree},
|
|
{"rna_object.c", RNA_def_object},
|
|
{"rna_object_force.c", RNA_def_object_force},
|
|
{"rna_packedfile.c", RNA_def_packedfile},
|
|
{"rna_particle.c", RNA_def_particle},
|
|
{"rna_pose.c", RNA_def_pose},
|
|
{"rna_property.c", RNA_def_gameproperty},
|
|
{"rna_radio.c", RNA_def_radio},
|
|
{"rna_scene.c", RNA_def_scene},
|
|
{"rna_screen.c", RNA_def_screen},
|
|
{"rna_scriptlink.c", RNA_def_scriptlink},
|
|
{"rna_sensor.c", RNA_def_sensor},
|
|
{"rna_sequence.c", RNA_def_sequence},
|
|
{"rna_space.c", RNA_def_space},
|
|
{"rna_text.c", RNA_def_text},
|
|
{"rna_timeline.c", RNA_def_timeline_marker},
|
|
{"rna_sound.c", RNA_def_sound},
|
|
{"rna_ui.c", RNA_def_ui},
|
|
{"rna_userdef.c", RNA_def_userdef},
|
|
{"rna_vfont.c", RNA_def_vfont},
|
|
{"rna_vpaint.c", RNA_def_vpaint},
|
|
{"rna_wm.c", RNA_def_wm},
|
|
{"rna_world.c", RNA_def_world},
|
|
{NULL, NULL}};
|
|
|
|
static void rna_generate(BlenderRNA *brna, FILE *f, char *filename)
|
|
{
|
|
StructDefRNA *ds;
|
|
PropertyDefRNA *dp;
|
|
FunctionDefRNA *dfunc;
|
|
|
|
fprintf(f, "\n/* Automatically generated struct definitions for the Data API.\n"
|
|
" Do not edit manually, changes will be overwritten. */\n\n"
|
|
"#define RNA_RUNTIME\n\n");
|
|
|
|
fprintf(f, "#include <float.h>\n");
|
|
fprintf(f, "#include <limits.h>\n");
|
|
fprintf(f, "#include <string.h>\n\n");
|
|
|
|
fprintf(f, "#include \"BLI_blenlib.h\"\n\n");
|
|
|
|
fprintf(f, "#include \"BKE_utildefines.h\"\n\n");
|
|
|
|
fprintf(f, "#include \"RNA_define.h\"\n");
|
|
fprintf(f, "#include \"RNA_types.h\"\n");
|
|
fprintf(f, "#include \"rna_internal.h\"\n\n");
|
|
|
|
rna_generate_prototypes(brna, f);
|
|
|
|
fprintf(f, "#include \"%s\"\n\n", filename);
|
|
|
|
fprintf(f, "/* Autogenerated Functions */\n\n");
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
if(!filename || ds->filename == filename) {
|
|
rna_generate_property_prototypes(brna, ds->srna, f);
|
|
rna_generate_function_prototypes(brna, ds->srna, f);
|
|
}
|
|
}
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
if(!filename || ds->filename == filename)
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next)
|
|
rna_def_property_funcs(f, ds->srna, dp);
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
if(!filename || ds->filename == filename) {
|
|
for(dfunc=ds->functions.first; dfunc; dfunc= dfunc->cont.next)
|
|
rna_def_function_funcs(f, ds, dfunc);
|
|
|
|
rna_generate_static_function_prototypes(brna, ds->srna, f);
|
|
}
|
|
}
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
if(!filename || ds->filename == filename)
|
|
rna_generate_struct(brna, ds->srna, f);
|
|
|
|
if(strcmp(filename, "rna_ID.c") == 0) {
|
|
/* this is ugly, but we cannot have c files compiled for both
|
|
* makesrna and blender with some build systems at the moment */
|
|
fprintf(f, "#include \"rna_define.c\"\n\n");
|
|
|
|
rna_generate_blender(brna, f);
|
|
}
|
|
}
|
|
|
|
static void rna_generate_header(BlenderRNA *brna, FILE *f)
|
|
{
|
|
StructDefRNA *ds;
|
|
PropertyDefRNA *dp;
|
|
StructRNA *srna;
|
|
|
|
fprintf(f, "\n#ifndef __RNA_BLENDER_H__\n");
|
|
fprintf(f, "#define __RNA_BLENDER_H__\n\n");
|
|
|
|
fprintf(f, "/* Automatically generated function declarations for the Data API.\n"
|
|
" Do not edit manually, changes will be overwritten. */\n\n");
|
|
|
|
fprintf(f, "#include \"RNA_types.h\"\n\n");
|
|
|
|
fprintf(f, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n");
|
|
|
|
fprintf(f, "#define FOREACH_BEGIN(property, sptr, itemptr) \\\n");
|
|
fprintf(f, " { \\\n");
|
|
fprintf(f, " CollectionPropertyIterator rna_macro_iter; \\\n");
|
|
fprintf(f, " for(property##_begin(&rna_macro_iter, sptr); rna_macro_iter.valid; property##_next(&rna_macro_iter)) { \\\n");
|
|
fprintf(f, " itemptr= rna_macro_iter.ptr;\n\n");
|
|
|
|
fprintf(f, "#define FOREACH_END(property) \\\n");
|
|
fprintf(f, " } \\\n");
|
|
fprintf(f, " property##_end(&rna_macro_iter); \\\n");
|
|
fprintf(f, " }\n\n");
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
srna= ds->srna;
|
|
|
|
fprintf(f, "/**************** %s ****************/\n\n", srna->name);
|
|
|
|
while(srna) {
|
|
fprintf(f, "extern StructRNA RNA_%s;\n", srna->identifier);
|
|
srna= srna->base;
|
|
}
|
|
fprintf(f, "\n");
|
|
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next)
|
|
rna_def_property_funcs_header(f, ds->srna, dp);
|
|
}
|
|
|
|
fprintf(f, "#ifdef __cplusplus\n}\n#endif\n\n");
|
|
|
|
fprintf(f, "#endif /* __RNA_BLENDER_H__ */\n\n");
|
|
}
|
|
|
|
static const char *cpp_classes = ""
|
|
"\n"
|
|
"#include <string>\n"
|
|
"\n"
|
|
"namespace RNA {\n"
|
|
"\n"
|
|
"#define BOOLEAN_PROPERTY(sname, identifier) \\\n"
|
|
" bool sname::identifier(void) { return (bool)sname##_##identifier##_get(&ptr); }\n"
|
|
"\n"
|
|
"#define BOOLEAN_ARRAY_PROPERTY(sname, size, identifier) \\\n"
|
|
" Array<int,size> sname::identifier(void) \\\n"
|
|
" { Array<int, size> ar; sname##_##identifier##_get(&ptr, ar.data); return ar; }\n"
|
|
"\n"
|
|
"#define INT_PROPERTY(sname, identifier) \\\n"
|
|
" int sname::identifier(void) { return sname##_##identifier##_get(&ptr); }\n"
|
|
"\n"
|
|
"#define INT_ARRAY_PROPERTY(sname, size, identifier) \\\n"
|
|
" Array<int,size> sname::identifier(void) \\\n"
|
|
" { Array<int, size> ar; sname##_##identifier##_get(&ptr, ar.data); return ar; }\n"
|
|
"\n"
|
|
"#define FLOAT_PROPERTY(sname, identifier) \\\n"
|
|
" float sname::identifier(void) { return sname##_##identifier##_get(&ptr); }\n"
|
|
"\n"
|
|
"#define FLOAT_ARRAY_PROPERTY(sname, size, identifier) \\\n"
|
|
" Array<float,size> sname::identifier(void) \\\n"
|
|
" { Array<float, size> ar; sname##_##identifier##_get(&ptr, ar.data); return ar; }\n"
|
|
"\n"
|
|
"#define ENUM_PROPERTY(type, sname, identifier) \\\n"
|
|
" sname::type sname::identifier(void) { return (type)sname##_##identifier##_get(&ptr); }\n"
|
|
"\n"
|
|
"#define STRING_PROPERTY(sname, identifier) \\\n"
|
|
" std::string sname::identifier(void) { \\\n"
|
|
" int len= sname##_##identifier##_length(&ptr); \\\n"
|
|
" std::string str; str.resize(len); \\\n"
|
|
" sname##_##identifier##_get(&ptr, &str[0]); return str; } \\\n"
|
|
"\n"
|
|
"#define POINTER_PROPERTY(type, sname, identifier) \\\n"
|
|
" type sname::identifier(void) { return type(sname##_##identifier##_get(&ptr)); }\n"
|
|
"\n"
|
|
"#define COLLECTION_PROPERTY(type, sname, identifier) \\\n"
|
|
" typedef CollectionIterator<type, sname##_##identifier##_begin, \\\n"
|
|
" sname##_##identifier##_next, sname##_##identifier##_end> identifier##_iterator; \\\n"
|
|
" Collection<sname, type, sname##_##identifier##_begin, \\\n"
|
|
" sname##_##identifier##_next, sname##_##identifier##_end> identifier;\n"
|
|
"\n"
|
|
"class Pointer {\n"
|
|
"public:\n"
|
|
" Pointer(const PointerRNA& p) : ptr(p) { }\n"
|
|
" operator const PointerRNA&() { return ptr; }\n"
|
|
" bool is_a(StructRNA *type) { return RNA_struct_is_a(&ptr, type); }\n"
|
|
" operator void*() { return ptr.data; }\n"
|
|
" operator bool() { return ptr.data != NULL; }\n"
|
|
"\n"
|
|
" PointerRNA ptr;\n"
|
|
"};\n"
|
|
"\n"
|
|
"\n"
|
|
"template<typename T, int Tsize>\n"
|
|
"class Array {\n"
|
|
"public:\n"
|
|
" T data[Tsize];\n"
|
|
" operator T*() { return data; }\n"
|
|
"};\n"
|
|
"\n"
|
|
"typedef void (*TBeginFunc)(CollectionPropertyIterator *iter, PointerRNA *ptr);\n"
|
|
"typedef void (*TNextFunc)(CollectionPropertyIterator *iter);\n"
|
|
"typedef void (*TEndFunc)(CollectionPropertyIterator *iter);\n"
|
|
"\n"
|
|
"template<typename T, TBeginFunc Tbegin, TNextFunc Tnext, TEndFunc Tend>\n"
|
|
"class CollectionIterator {\n"
|
|
"public:\n"
|
|
" CollectionIterator() : t(iter.ptr), init(false) { iter.valid= false; }\n"
|
|
" ~CollectionIterator(void) { if(init) Tend(&iter); };\n"
|
|
" const CollectionIterator<T, Tbegin, Tnext, Tend>& operator=(const CollectionIterator<T, Tbegin, Tnext, Tend>& copy)\n"
|
|
" { if(init) Tend(&iter); iter= copy.iter; if(iter.internal) iter.internal= MEM_dupallocN(iter.internal); t= copy.t; init= copy.init; return *this; }\n"
|
|
"\n"
|
|
" operator bool(void)\n"
|
|
" { return iter.valid != 0; }\n"
|
|
" const CollectionIterator<T, Tbegin, Tnext, Tend>& operator++() { Tnext(&iter); t = T(iter.ptr); return *this; }\n"
|
|
" T& operator*(void) { return t; }\n"
|
|
" T* operator->(void) { return &t; }\n"
|
|
" bool operator==(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) { return iter.valid == other.iter.valid; }\n"
|
|
" bool operator!=(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) { return iter.valid != other.iter.valid; }\n"
|
|
"\n"
|
|
" void begin(const Pointer& ptr)\n"
|
|
" { if(init) Tend(&iter); Tbegin(&iter, (PointerRNA*)&ptr.ptr); t = T(iter.ptr); init = true; }\n"
|
|
"\n"
|
|
"private:\n"
|
|
" CollectionPropertyIterator iter;\n"
|
|
" T t;\n"
|
|
" bool init;\n"
|
|
"};\n"
|
|
"\n"
|
|
"template<typename Tp, typename T, TBeginFunc Tbegin, TNextFunc Tnext, TEndFunc Tend>\n"
|
|
"class Collection {\n"
|
|
"public:\n"
|
|
" Collection(const PointerRNA& p) : ptr(p) {}\n"
|
|
"\n"
|
|
" CollectionIterator<T, Tbegin, Tnext, Tend> begin()\n"
|
|
" { CollectionIterator<T, Tbegin, Tnext, Tend> iter; iter.begin(ptr); return iter; }\n"
|
|
" CollectionIterator<T, Tbegin, Tnext, Tend> end()\n"
|
|
" { return CollectionIterator<T, Tbegin, Tnext, Tend>(); } /* test */ \n"
|
|
"\n"
|
|
"private:\n"
|
|
" PointerRNA ptr;\n"
|
|
"};\n"
|
|
"\n";
|
|
|
|
static void rna_generate_header_cpp(BlenderRNA *brna, FILE *f)
|
|
{
|
|
StructDefRNA *ds;
|
|
PropertyDefRNA *dp;
|
|
StructRNA *srna;
|
|
|
|
fprintf(f, "\n#ifndef __RNA_BLENDER_CPP_H__\n");
|
|
fprintf(f, "#define __RNA_BLENDER_CPP_H__\n\n");
|
|
|
|
fprintf(f, "/* Automatically generated classes for the Data API.\n"
|
|
" Do not edit manually, changes will be overwritten. */\n\n");
|
|
|
|
fprintf(f, "#include \"RNA_blender.h\"\n");
|
|
fprintf(f, "#include \"RNA_types.h\"\n");
|
|
|
|
fprintf(f, cpp_classes);
|
|
|
|
fprintf(f, "/**************** Declarations ****************/\n\n");
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
fprintf(f, "class %s;\n", ds->srna->identifier);
|
|
fprintf(f, "\n");
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
srna= ds->srna;
|
|
|
|
fprintf(f, "/**************** %s ****************/\n\n", srna->name);
|
|
|
|
fprintf(f, "class %s : public %s {\n", srna->identifier, (srna->base)? srna->base->identifier: "Pointer");
|
|
fprintf(f, "public:\n");
|
|
fprintf(f, "\t%s(const PointerRNA& ptr) :\n\t\t%s(ptr)", srna->identifier, (srna->base)? srna->base->identifier: "Pointer");
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next)
|
|
if(!(dp->prop->flag & (PROP_IDPROPERTY|PROP_BUILTIN)))
|
|
if(dp->prop->type == PROP_COLLECTION)
|
|
fprintf(f, ",\n\t\t%s(ptr)", dp->prop->identifier);
|
|
fprintf(f, "\n\t\t{}\n\n");
|
|
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next)
|
|
rna_def_property_funcs_header_cpp(f, ds->srna, dp);
|
|
fprintf(f, "};\n\n");
|
|
}
|
|
|
|
|
|
fprintf(f, "/**************** Implementation ****************/\n");
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next) {
|
|
for(dp=ds->cont.properties.first; dp; dp=dp->next)
|
|
rna_def_property_funcs_impl_cpp(f, ds->srna, dp);
|
|
|
|
fprintf(f, "\n");
|
|
}
|
|
|
|
fprintf(f, "}\n\n#endif /* __RNA_BLENDER_CPP_H__ */\n\n");
|
|
}
|
|
|
|
static void make_bad_file(char *file)
|
|
{
|
|
FILE *fp= fopen(file, "w");
|
|
fprintf(fp, "ERROR! Cannot make correct RNA file, STUPID!\n");
|
|
fclose(fp);
|
|
}
|
|
|
|
static int rna_preprocess(char *outfile)
|
|
{
|
|
BlenderRNA *brna;
|
|
StructDefRNA *ds;
|
|
FILE *file;
|
|
char deffile[4096];
|
|
int i, status;
|
|
|
|
/* define rna */
|
|
brna= RNA_create();
|
|
|
|
for(i=0; PROCESS_ITEMS[i].filename; i++) {
|
|
if(PROCESS_ITEMS[i].define) {
|
|
PROCESS_ITEMS[i].define(brna);
|
|
|
|
for(ds=DefRNA.structs.first; ds; ds=ds->cont.next)
|
|
if(!ds->filename)
|
|
ds->filename= PROCESS_ITEMS[i].filename;
|
|
}
|
|
}
|
|
|
|
rna_auto_types();
|
|
|
|
|
|
/* create RNA_blender_cpp.h */
|
|
strcpy(deffile, outfile);
|
|
strcat(deffile, "RNA_blender_cpp.h");
|
|
|
|
status= (DefRNA.error != 0);
|
|
|
|
if(status) {
|
|
make_bad_file(deffile);
|
|
}
|
|
else {
|
|
file = fopen(deffile, "w");
|
|
|
|
if(!file) {
|
|
printf ("Unable to open file: %s\n", deffile);
|
|
status = 1;
|
|
}
|
|
else {
|
|
rna_generate_header_cpp(brna, file);
|
|
fclose(file);
|
|
|
|
status= (DefRNA.error != 0);
|
|
}
|
|
}
|
|
|
|
rna_sort(brna);
|
|
|
|
/* create rna_gen_*.c files */
|
|
for(i=0; PROCESS_ITEMS[i].filename; i++) {
|
|
strcpy(deffile, outfile);
|
|
strcat(deffile, PROCESS_ITEMS[i].filename);
|
|
deffile[strlen(deffile)-2] = '\0';
|
|
strcat(deffile, "_gen.c");
|
|
|
|
if(status) {
|
|
make_bad_file(deffile);
|
|
}
|
|
else {
|
|
file = fopen(deffile, "w");
|
|
|
|
if(!file) {
|
|
printf ("Unable to open file: %s\n", deffile);
|
|
status = 1;
|
|
}
|
|
else {
|
|
rna_generate(brna, file, PROCESS_ITEMS[i].filename);
|
|
fclose(file);
|
|
|
|
status= (DefRNA.error != 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* create RNA_blender.h */
|
|
strcpy(deffile, outfile);
|
|
strcat(deffile, "RNA_blender.h");
|
|
|
|
if(status) {
|
|
make_bad_file(deffile);
|
|
}
|
|
else {
|
|
file = fopen(deffile, "w");
|
|
|
|
if(!file) {
|
|
printf ("Unable to open file: %s\n", deffile);
|
|
status = 1;
|
|
}
|
|
else {
|
|
rna_generate_header(brna, file);
|
|
fclose(file);
|
|
|
|
status= (DefRNA.error != 0);
|
|
}
|
|
}
|
|
|
|
/* free RNA */
|
|
RNA_define_free(brna);
|
|
RNA_free(brna);
|
|
|
|
return status;
|
|
}
|
|
|
|
static void mem_error_cb(char *errorStr)
|
|
{
|
|
fprintf(stderr, "%s", errorStr);
|
|
fflush(stderr);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int totblock, return_status = 0;
|
|
|
|
if(argc<2) {
|
|
printf("Usage: %s outdirectory/\n", argv[0]);
|
|
return_status = 1;
|
|
}
|
|
else {
|
|
printf("Running makesrna, program versions %s\n", RNA_VERSION_DATE);
|
|
return_status= rna_preprocess(argv[1]);
|
|
}
|
|
|
|
totblock= MEM_get_memory_blocks_in_use();
|
|
if(totblock!=0) {
|
|
printf("Error Totblock: %d\n",totblock);
|
|
MEM_set_error_callback(mem_error_cb);
|
|
MEM_printmemlist();
|
|
}
|
|
|
|
return return_status;
|
|
}
|
|
|
|
|