← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/makesrna/intern/makesrna.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2014-02-19 11:24:23 UTC
  • mfrom: (14.2.23 sid)
  • Revision ID: package-import@ubuntu.com-20140219112423-rkmaz2m7ha06d4tk
Tags: 2.69-3ubuntu1
* Merge with Debian; remaining changes:
  - Configure without OpenImageIO on armhf, as it is not available on
    Ubuntu.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/makesrna/intern/makesrna.c
177
177
 
178
178
 
179
179
        if (len_new != len_org) {
180
 
                fclose(fp_new);
181
 
                fclose(fp_org);
 
180
                fclose(fp_new); fp_new = NULL;
 
181
                fclose(fp_org); fp_org = NULL;
182
182
                REN_IF_DIFF;
183
183
        }
184
184
 
191
191
        if (fread(arr_org, sizeof(char), len_org, fp_org) != len_org)
192
192
                fprintf(stderr, "%s:%d, error reading file %s for comparison.\n", __FILE__, __LINE__, orgfile);
193
193
 
194
 
        fclose(fp_new);
195
 
        fclose(fp_org);
 
194
        fclose(fp_new); fp_new = NULL;
 
195
        fclose(fp_org); fp_org = NULL;
196
196
 
197
197
        cmp = memcmp(arr_new, arr_org, len_new);
198
198
 
319
319
static void rna_print_data_get(FILE *f, PropertyDefRNA *dp)
320
320
{
321
321
        if (dp->dnastructfromname && dp->dnastructfromprop)
322
 
                fprintf(f, "    %s *data= (%s*)(((%s*)ptr->data)->%s);\n", dp->dnastructname, dp->dnastructname,
 
322
                fprintf(f, "    %s *data = (%s *)(((%s *)ptr->data)->%s);\n", dp->dnastructname, dp->dnastructname,
323
323
                        dp->dnastructfromname, dp->dnastructfromprop);
324
324
        else
325
 
                fprintf(f, "    %s *data= (%s*)(ptr->data);\n", dp->dnastructname, dp->dnastructname);
 
325
                fprintf(f, "    %s *data = (%s *)(ptr->data);\n", dp->dnastructname, dp->dnastructname);
326
326
}
327
327
 
328
328
static void rna_print_id_get(FILE *f, PropertyDefRNA *UNUSED(dp))
329
329
{
330
 
        fprintf(f, "    ID *id= ptr->id.data;\n");
 
330
        fprintf(f, "    ID *id = ptr->id.data;\n");
331
331
}
332
332
 
333
333
static void rna_construct_function_name(char *buffer, int size, const char *structname, const char *propname, const char *type)
646
646
                                        if (prop->flag & PROP_DYNAMIC) {
647
647
                                                char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier),
648
648
                                                                                        "get_length");
649
 
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
650
 
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
651
 
                                                fprintf(f, "    for (i=0; i < len; i++) {\n");
 
649
                                                fprintf(f, "    unsigned int arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
 
650
                                                fprintf(f, "    unsigned int i;\n");
 
651
                                                fprintf(f, "    unsigned int len = %s(ptr, arraylen);\n\n", lenfunc);
 
652
                                                fprintf(f, "    for (i = 0; i < len; i++) {\n");
652
653
                                                MEM_freeN(lenfunc);
653
654
                                        }
654
655
                                        else {
655
 
                                                fprintf(f, "    int i;\n\n");
656
 
                                                fprintf(f, "    for (i=0; i < %u; i++) {\n", prop->totarraylength);
 
656
                                                fprintf(f, "    unsigned int i;\n\n");
 
657
                                                fprintf(f, "    for (i = 0; i < %u; i++) {\n", prop->totarraylength);
657
658
                                        }
658
659
 
659
660
                                        if (dp->dnaarraylength == 1) {
674
675
                                                        fprintf(f, ") != 0);\n");
675
676
                                                }
676
677
                                                else if (rna_color_quantize(prop, dp)) {
677
 
                                                        fprintf(f, "            values[i] = (%s)(data->%s[i]*(1.0f / 255.0f));\n",
 
678
                                                        fprintf(f, "            values[i] = (%s)(data->%s[i] * (1.0f / 255.0f));\n",
678
679
                                                                rna_type_type(prop), dp->dnaname);
679
680
                                                }
680
681
                                                else if (dp->dnatype) {
681
 
                                                        fprintf(f, "            values[i] = (%s)%s(((%s*)data->%s)[i]);\n",
 
682
                                                        fprintf(f, "            values[i] = (%s)%s(((%s *)data->%s)[i]);\n",
682
683
                                                                rna_type_type(prop), (dp->booleannegative) ? "!" : "", dp->dnatype, dp->dnaname);
683
684
                                                }
684
685
                                                else {
897
898
                                                char *lenfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier),
898
899
                                                                                        "set_length");
899
900
                                                fprintf(f, "    int i, arraylen[RNA_MAX_ARRAY_DIMENSION];\n");
900
 
                                                fprintf(f, "    int len= %s(ptr, arraylen);\n\n", lenfunc);
 
901
                                                fprintf(f, "    int len = %s(ptr, arraylen);\n\n", lenfunc);
901
902
                                                rna_clamp_value_range(f, prop);
902
 
                                                fprintf(f, "    for (i=0; i < len; i++) {\n");
 
903
                                                fprintf(f, "    for (i = 0; i < len; i++) {\n");
903
904
                                                MEM_freeN(lenfunc);
904
905
                                        }
905
906
                                        else {
906
907
                                                fprintf(f, "    int i;\n\n");
907
908
                                                rna_clamp_value_range(f, prop);
908
 
                                                fprintf(f, "    for (i=0; i < %u; i++) {\n", prop->totarraylength);
 
909
                                                fprintf(f, "    for (i = 0; i < %u; i++) {\n", prop->totarraylength);
909
910
                                        }
910
911
 
911
912
                                        if (dp->dnaarraylength == 1) {
934
935
                                                }
935
936
                                                else {
936
937
                                                        if (dp->dnatype)
937
 
                                                                fprintf(f, "            ((%s*)data->%s)[i] = %s", dp->dnatype, dp->dnaname,
 
938
                                                                fprintf(f, "            ((%s *)data->%s)[i] = %s", dp->dnatype, dp->dnaname,
938
939
                                                                        (dp->booleannegative) ? "!" : "");
939
940
                                                        else
940
941
                                                                fprintf(f, "            (data->%s)[i] = %s", dp->dnaname, (dp->booleannegative) ? "!" : "");
1072
1073
                rna_print_data_get(f, dp);
1073
1074
 
1074
1075
        fprintf(f, "\n  memset(iter, 0, sizeof(*iter));\n");
1075
 
        fprintf(f, "    iter->parent= *ptr;\n");
1076
 
        fprintf(f, "    iter->prop= (PropertyRNA *)&rna_%s_%s;\n", srna->identifier, prop->identifier);
 
1076
        fprintf(f, "    iter->parent = *ptr;\n");
 
1077
        fprintf(f, "    iter->prop = (PropertyRNA *)&rna_%s_%s;\n", srna->identifier, prop->identifier);
1077
1078
 
1078
1079
        if (dp->dnalengthname || dp->dnalengthfixed) {
1079
1080
                if (manualfunc) {
1100
1101
        getfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get");
1101
1102
 
1102
1103
        fprintf(f, "\n  if (iter->valid)\n");
1103
 
        fprintf(f, "            iter->ptr= %s(iter);\n", getfunc);
 
1104
        fprintf(f, "            iter->ptr = %s(iter);\n", getfunc);
1104
1105
 
1105
1106
        fprintf(f, "}\n\n");
1106
1107
 
1139
1140
                return func;
1140
1141
        }
1141
1142
 
1142
 
        fprintf(f, "    int found= 0;\n");
 
1143
        fprintf(f, "    int found = 0;\n");
1143
1144
        fprintf(f, "    CollectionPropertyIterator iter;\n\n");
1144
1145
 
1145
1146
        fprintf(f, "    %s_%s_begin(&iter, ptr);\n\n", srna->identifier, rna_safe_id(prop->identifier));
1146
1147
        fprintf(f, "    if (iter.valid) {\n");
1147
1148
 
1148
1149
        if (strcmp(nextfunc, "rna_iterator_array_next") == 0) {
1149
 
                fprintf(f, "            ArrayIterator *internal= iter.internal;\n");
 
1150
                fprintf(f, "            ArrayIterator *internal = iter.internal;\n");
1150
1151
                fprintf(f, "            if (index < 0 || index >= internal->length) {\n");
1151
1152
                fprintf(f, "#ifdef __GNUC__\n");
1152
1153
                fprintf(f, "                    printf(\"Array iterator out of range: %%s (index %%d)\\n\", __func__, index);\n");
1158
1159
                fprintf(f, "                    while (index-- > 0 && iter.valid) {\n");
1159
1160
                fprintf(f, "                            rna_iterator_array_next(&iter);\n");
1160
1161
                fprintf(f, "                    }\n");
1161
 
                fprintf(f, "                    found= (index == -1 && iter.valid);\n");
 
1162
                fprintf(f, "                    found = (index == -1 && iter.valid);\n");
1162
1163
                fprintf(f, "            }\n");
1163
1164
                fprintf(f, "            else {\n");
1164
 
                fprintf(f, "                    internal->ptr += internal->itemsize*index;\n");
1165
 
                fprintf(f, "                    found= 1;\n");
 
1165
                fprintf(f, "                    internal->ptr += internal->itemsize * index;\n");
 
1166
                fprintf(f, "                    found = 1;\n");
1166
1167
                fprintf(f, "            }\n");
1167
1168
        }
1168
1169
        else if (strcmp(nextfunc, "rna_iterator_listbase_next") == 0) {
1169
 
                fprintf(f, "            ListBaseIterator *internal= iter.internal;\n");
 
1170
                fprintf(f, "            ListBaseIterator *internal = iter.internal;\n");
1170
1171
                fprintf(f, "            if (internal->skip) {\n");
1171
1172
                fprintf(f, "                    while (index-- > 0 && iter.valid) {\n");
1172
1173
                fprintf(f, "                            rna_iterator_listbase_next(&iter);\n");
1173
1174
                fprintf(f, "                    }\n");
1174
 
                fprintf(f, "                    found= (index == -1 && iter.valid);\n");
 
1175
                fprintf(f, "                    found = (index == -1 && iter.valid);\n");
1175
1176
                fprintf(f, "            }\n");
1176
1177
                fprintf(f, "            else {\n");
1177
1178
                fprintf(f, "                    while (index-- > 0 && internal->link)\n");
1178
 
                fprintf(f, "                            internal->link= internal->link->next;\n");
1179
 
                fprintf(f, "                    found= (index == -1 && internal->link);\n");
 
1179
                fprintf(f, "                            internal->link = internal->link->next;\n");
 
1180
                fprintf(f, "                    found = (index == -1 && internal->link);\n");
1180
1181
                fprintf(f, "            }\n");
1181
1182
        }
1182
1183
 
1318
1319
        getfunc = rna_alloc_function_name(srna->identifier, rna_safe_id(prop->identifier), "get");
1319
1320
 
1320
1321
        fprintf(f, "\n  if (iter->valid)\n");
1321
 
        fprintf(f, "            iter->ptr= %s(iter);\n", getfunc);
 
1322
        fprintf(f, "            iter->ptr = %s(iter);\n", getfunc);
1322
1323
 
1323
1324
        fprintf(f, "}\n\n");
1324
1325
 
2202
2203
                else if ((type == PROP_POINTER) && (flag & PROP_RNAPTR) && !(flag & PROP_THICK_WRAP))
2203
2204
                        ptrstr = "*";
2204
2205
                /* PROP_THICK_WRAP strings are pre-allocated on the ParameterList stack,
2205
 
                 * but type name for string props is already char*, so leave empty */
 
2206
                 * but type name for string props is already (char *), so leave empty */
2206
2207
                else if (type == PROP_STRING && (flag & PROP_THICK_WRAP))
2207
2208
                        ptrstr = "";
2208
2209
                else
2225
2226
 
2226
2227
        /* assign self */
2227
2228
        if (func->flag & FUNC_USE_SELF_ID) {
2228
 
                fprintf(f, "\t_selfid= (struct ID*)_ptr->id.data;\n");
 
2229
                fprintf(f, "\t_selfid = (struct ID *)_ptr->id.data;\n");
2229
2230
        }
2230
2231
        
2231
2232
        if ((func->flag & FUNC_NO_SELF) == 0) {
2232
 
                if (dsrna->dnaname) fprintf(f, "\t_self= (struct %s *)_ptr->data;\n", dsrna->dnaname);
2233
 
                else fprintf(f, "\t_self= (struct %s *)_ptr->data;\n", srna->identifier);
 
2233
                if (dsrna->dnaname) fprintf(f, "\t_self = (struct %s *)_ptr->data;\n", dsrna->dnaname);
 
2234
                else fprintf(f, "\t_self = (struct %s *)_ptr->data;\n", srna->identifier);
2234
2235
        }
2235
2236
        else if (func->flag & FUNC_USE_SELF_TYPE) {
2236
 
                fprintf(f, "\t_type= _ptr->type;\n");
 
2237
                fprintf(f, "\t_type = _ptr->type;\n");
2237
2238
        }
2238
2239
 
2239
2240
        if (has_data) {
2240
 
                fprintf(f, "\t_data= (char *)_parms->data;\n");
 
2241
                fprintf(f, "\t_data = (char *)_parms->data;\n");
2241
2242
        }
2242
2243
 
2243
2244
        dparm = dfunc->cont.properties.first;
2248
2249
                cptr = ((type == PROP_POINTER) && !(flag & PROP_RNAPTR));
2249
2250
 
2250
2251
                if (dparm->prop == func->c_ret)
2251
 
                        fprintf(f, "\t_retdata= _data;\n");
 
2252
                        fprintf(f, "\t_retdata = _data;\n");
2252
2253
                else {
2253
2254
                        const char *data_str;
2254
2255
                        if (cptr || (flag & PROP_DYNAMIC)) {
2272
2273
                                valstr = "*";
2273
2274
                        }
2274
2275
 
2275
 
                        /* this must be kept in sync with RNA_parameter_length_get_data,
 
2276
                        /* this must be kept in sync with RNA_parameter_dynamic_length_get_data and RNA_parameter_get,
2276
2277
                         * we could just call the function directly, but this is faster */
2277
2278
                        if (flag & PROP_DYNAMIC) {
2278
 
                                fprintf(f, "\t%s_len= %s((int *)_data);\n", dparm->prop->identifier, pout ? "" : "*");
2279
 
                                data_str = "(&(((char *)_data)[sizeof(void *)]))";
 
2279
                                fprintf(f, "\t%s_len = %s((ParameterDynAlloc *)_data)->array_tot;\n", dparm->prop->identifier,
 
2280
                                                                                                      pout ? "(int *)&" : "(int)");
 
2281
                                data_str = "(&(((ParameterDynAlloc *)_data)->array))";
2280
2282
                        }
2281
2283
                        else {
2282
2284
                                data_str = "_data";
2286
2288
                        if (!pout)
2287
2289
                                fprintf(f, "%s", valstr);
2288
2290
 
2289
 
                        fprintf(f, "((%s%s%s)%s);\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
 
2291
                        fprintf(f, "((%s%s %s)%s);\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop),
2290
2292
                                ptrstr, data_str);
2291
2293
                }
2292
2294
 
2293
2295
                if (dparm->next)
2294
 
                        fprintf(f, "\t_data += %d;\n", rna_parameter_size_alloc(dparm->prop));
 
2296
                        fprintf(f, "\t_data += %d;\n", rna_parameter_size(dparm->prop));
2295
2297
        }
2296
2298
 
2297
2299
        if (dfunc->call) {
2356
2358
                        dparm = rna_find_parameter_def(func->c_ret);
2357
2359
                        ptrstr = (((dparm->prop->type == PROP_POINTER) && !(dparm->prop->flag & PROP_RNAPTR)) ||
2358
2360
                                  (dparm->prop->arraydimension)) ? "*" : "";
2359
 
                        fprintf(f, "\t*((%s%s%s*)_retdata) = %s;\n", rna_type_struct(dparm->prop),
 
2361
                        fprintf(f, "\t*((%s%s %s*)_retdata) = %s;\n", rna_type_struct(dparm->prop),
2360
2362
                                rna_parameter_type_name(dparm->prop), ptrstr, func->c_ret->identifier);
2361
2363
                }
2362
2364
        }
2690
2692
 
2691
2693
        }
2692
2694
 
 
2695
        /* ensure func(void) if there are no args */
 
2696
        if (first) fprintf(f, "void");
 
2697
 
2693
2698
        fprintf(f, ")");
 
2699
 
2694
2700
        if (close_prototype)
2695
2701
                fprintf(f, ";\n");
2696
2702
}
2762
2768
 
2763
2769
static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, PropertyRNA *prop)
2764
2770
{
2765
 
        char *strnest = "", *errnest = "";
 
2771
        char *strnest = (char *)"", *errnest = (char *)"";
2766
2772
        int len, freenest = 0;
2767
2773
        
2768
2774
        if (nest != NULL) {
2915
2921
        fprintf(f, ", %d, ", prop->flag);
2916
2922
        rna_print_c_string(f, prop->name); fprintf(f, ",\n\t");
2917
2923
        rna_print_c_string(f, prop->description); fprintf(f, ",\n\t");
2918
 
        fprintf(f, "%d,\n", prop->icon);
2919
 
        rna_print_c_string(f, prop->translation_context); fprintf(f, ",\n\t");
2920
 
        fprintf(f, "\t%s, %s|%s, %s, %u, {%u, %u, %u}, %u,\n",
 
2924
        fprintf(f, "%d, ", prop->icon);
 
2925
        rna_print_c_string(f, prop->translation_context); fprintf(f, ",\n");
 
2926
        fprintf(f, "\t%s, %s | %s, %s, %u, {%u, %u, %u}, %u,\n",
2921
2927
                RNA_property_typename(prop->type),
2922
2928
                rna_property_subtypename(prop->subtype),
2923
2929
                rna_property_subtype_unit(prop->subtype),
3155
3161
        else fprintf(f, "NULL}},\n");
3156
3162
        fprintf(f, "\t");
3157
3163
        rna_print_c_string(f, srna->identifier);
3158
 
        fprintf(f, "\t, NULL,NULL\n"); /* PyType - Cant initialize here */
 
3164
        fprintf(f, ", NULL, NULL"); /* PyType - Cant initialize here */
3159
3165
        fprintf(f, ", %d, ", srna->flag);
3160
3166
        rna_print_c_string(f, srna->name);
3161
 
        fprintf(f, ", ");
 
3167
        fprintf(f, ",\n\t");
3162
3168
        rna_print_c_string(f, srna->description);
3163
 
        fprintf(f, ", ");
 
3169
        fprintf(f, ",\n\t");
3164
3170
        rna_print_c_string(f, srna->translation_context);
3165
 
        fprintf(f, ",\n\t%d,\n", srna->icon);
 
3171
        fprintf(f, ", %d,\n", srna->icon);
3166
3172
 
3167
3173
        prop = srna->nameproperty;
3168
3174
        if (prop) {
3328
3334
                fprintf(f, "#include \"%s\"\n", api_filename);
3329
3335
        fprintf(f, "\n");
3330
3336
 
 
3337
        /* we want the included C files to have warnings enabled but for the generated code
 
3338
         * ignore unused-parameter warnings which are hard to prevent */
 
3339
#ifdef __GNUC__
 
3340
        fprintf(f, "#pragma GCC diagnostic ignored \"-Wunused-parameter\"\n\n");
 
3341
#endif
 
3342
 
3331
3343
        fprintf(f, "/* Autogenerated Functions */\n\n");
3332
3344
 
3333
3345
        for (ds = DefRNA.structs.first; ds; ds = ds->cont.next) {
3392
3404
        fprintf(f, "            CollectionPropertyIterator rna_macro_iter; \\\n");
3393
3405
        fprintf(f, "            for (property##_begin(&rna_macro_iter, sptr); rna_macro_iter.valid; "
3394
3406
                "property##_next(&rna_macro_iter)) { \\\n");
3395
 
        fprintf(f, "                    itemptr= rna_macro_iter.ptr;\n\n");
 
3407
        fprintf(f, "                    itemptr = rna_macro_iter.ptr;\n\n");
3396
3408
 
3397
3409
        fprintf(f, "#define FOREACH_END(property) \\\n");
3398
3410
        fprintf(f, "            } \\\n");
3495
3507
"\n"
3496
3508
"#define STRING_PROPERTY(sname, identifier) \\\n"
3497
3509
"       inline std::string sname::identifier(void) { \\\n"
3498
 
"               int len= sname##_##identifier##_length(&ptr); \\\n"
 
3510
"               int len = sname##_##identifier##_length(&ptr); \\\n"
3499
3511
"               std::string str; str.resize(len); \\\n"
3500
3512
"               sname##_##identifier##_get(&ptr, &str[0]); return str; } \\\n"
3501
3513
"       inline void sname::identifier(const std::string& value) { \\\n"
3543
3555
"       } \n"
3544
3556
"#define COLLECTION_PROPERTY_LOOKUP_INT_TRUE(sname, identifier) \\\n"
3545
3557
"       inline static int sname##_##identifier##_lookup_int_wrap(PointerRNA *ptr, int key, PointerRNA *r_ptr) \\\n"
3546
 
"       { return sname##_##identifier##_lookup_int(ptr, key, r_ptr); } \n"
3547
 
"\n"
 
3558
"       { \\\n"
 
3559
"               int found = sname##_##identifier##_lookup_int(ptr, key, r_ptr); \\\n"
 
3560
"               if (!found) \\\n"
 
3561
"                       memset(r_ptr, 0, sizeof(*r_ptr)); \\\n"
 
3562
"               return found; \\\n"
 
3563
"       } \n"
3548
3564
"#define COLLECTION_PROPERTY_LOOKUP_STRING_FALSE(sname, identifier) \\\n"
3549
3565
"       inline static int sname##_##identifier##_lookup_string_wrap(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) \\\n"
3550
3566
"       { \\\n"
3572
3588
"       } \n"
3573
3589
"#define COLLECTION_PROPERTY_LOOKUP_STRING_TRUE(sname, identifier) \\\n"
3574
3590
"       inline static int sname##_##identifier##_lookup_string_wrap(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) \\\n"
3575
 
"       { return sname##_##identifier##_lookup_string(ptr, key, r_ptr); } \n"
3576
 
"\n"
 
3591
"       { \\\n"
 
3592
"               int found = sname##_##identifier##_lookup_string(ptr, key, r_ptr); \\\n"
 
3593
"               if (!found) \\\n"
 
3594
"                       memset(r_ptr, 0, sizeof(*r_ptr)); \\\n"
 
3595
"               return found; \\\n"
 
3596
"       } \n"
3577
3597
"#define COLLECTION_PROPERTY(collection_funcs, type, sname, identifier, has_length, has_lookup_int, has_lookup_string) \\\n"
3578
3598
"       typedef CollectionIterator<type, sname##_##identifier##_begin, \\\n"
3579
3599
"               sname##_##identifier##_next, sname##_##identifier##_end> identifier##_iterator; \\\n"
3604
3624
"\n"
3605
3625
"       Array() {}\n"
3606
3626
"       Array(const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T) * Tsize); }\n"
3607
 
"       const Array<T, Tsize>& operator=(const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T) * Tsize); "
 
3627
"       const Array<T, Tsize>& operator = (const Array<T, Tsize>& other) { memcpy(data, other.data, sizeof(T) * Tsize); "
3608
3628
"return *this; }\n"
3609
3629
"\n"
3610
3630
"       operator T*() { return data; }\n"
3619
3639
"       DynamicArray() : data(NULL), length(0) {}\n"
3620
3640
"       DynamicArray(int new_length) : data(NULL), length(new_length) { data = (float *)malloc(sizeof(T) * new_length); }\n"
3621
3641
"       DynamicArray(const DynamicArray<T>& other) { copy_from(other); }\n"
3622
 
"       const DynamicArray<T>& operator=(const DynamicArray<T>& other) { copy_from(other); return *this; }\n"
 
3642
"       const DynamicArray<T>& operator = (const DynamicArray<T>& other) { copy_from(other); return *this; }\n"
3623
3643
"\n"
3624
3644
"       ~DynamicArray() { if (data) free(data); }\n"
3625
3645
"\n"
3644
3664
"template<typename T, TBeginFunc Tbegin, TNextFunc Tnext, TEndFunc Tend>\n"
3645
3665
"class CollectionIterator {\n"
3646
3666
"public:\n"
3647
 
"       CollectionIterator() : t(iter.ptr), init(false) { iter.valid= false; }\n"
 
3667
"       CollectionIterator() : t(iter.ptr), init(false) { iter.valid = false; }\n"
3648
3668
"       ~CollectionIterator(void) { if (init) Tend(&iter); };\n"
3649
3669
"\n"
3650
3670
"       operator bool(void)\n"
3653
3673
"\n"
3654
3674
"       T& operator*(void) { return t; }\n"
3655
3675
"       T* operator->(void) { return &t; }\n"
3656
 
"       bool operator==(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) "
 
3676
"       bool operator == (const CollectionIterator<T, Tbegin, Tnext, Tend>& other) "
3657
3677
"{ return iter.valid == other.iter.valid; }\n"
3658
3678
"       bool operator!=(const CollectionIterator<T, Tbegin, Tnext, Tend>& other) "
3659
3679
"{ return iter.valid != other.iter.valid; }\n"
3662
3682
"       { if (init) Tend(&iter); Tbegin(&iter, (PointerRNA *)&ptr.ptr); t = T(iter.ptr); init = true; }\n"
3663
3683
"\n"
3664
3684
"private:\n"
3665
 
"       const CollectionIterator<T, Tbegin, Tnext, Tend>& operator="
 
3685
"       const CollectionIterator<T, Tbegin, Tnext, Tend>& operator = "
3666
3686
"(const CollectionIterator<T, Tbegin, Tnext, Tend>& copy) {}\n"
3667
3687
""
3668
3688
"       CollectionPropertyIterator iter;\n"