From 7a21db5914dd7a5666e603d66ed3948b659ba2fc Mon Sep 17 00:00:00 2001 From: Tavian Barnes Date: Sat, 8 May 2010 23:21:48 -0600 Subject: New DMNSN_ARRAY_FOREACH() macro, faster than iterating with dmnsn_array_get(). --- dimension/common.rules | 16 ++-- dimension/lexer.l | 17 ++--- dimension/parse.c | 48 +++++------- dimension/realize.c | 199 +++++++++++++++++++++---------------------------- dimension/tokenize.c | 6 +- 5 files changed, 121 insertions(+), 165 deletions(-) (limited to 'dimension') diff --git a/dimension/common.rules b/dimension/common.rules index 4644627..d897eb3 100644 --- a/dimension/common.rules +++ b/dimension/common.rules @@ -152,11 +152,9 @@ OBJECT: FINITE_SOLID_OBJECT *modifiers = dmnsn_new_astnode(DMNSN_AST_OBJECT_MODIFIERS, @4); dmnsn_copy_children(*modifiers, orig_modifiers); - for (size_t i = 0; i < dmnsn_array_size($4.children); ++i) { - dmnsn_astnode astnode; - dmnsn_array_get($4.children, i, &astnode); - ++*astnode.refcount; - dmnsn_array_push(modifiers->children, &astnode); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, astnode, $4.children) { + ++*astnode->refcount; + dmnsn_array_push(modifiers->children, astnode); } dmnsn_delete_astnode($4); break; @@ -185,11 +183,9 @@ OBJECT: FINITE_SOLID_OBJECT dmnsn_array_size($$.children) - 1, &modifiers); - for (size_t i = 0; i < dmnsn_array_size($4.children); ++i) { - dmnsn_astnode astnode; - dmnsn_array_get($4.children, i, &astnode); - ++*astnode.refcount; - dmnsn_array_push(modifiers.children, &astnode); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, astnode, $4.children) { + ++*astnode->refcount; + dmnsn_array_push(modifiers.children, astnode); } dmnsn_delete_astnode($4); diff --git a/dimension/lexer.l b/dimension/lexer.l index 6198fea..a3dc683 100644 --- a/dimension/lexer.l +++ b/dimension/lexer.l @@ -421,10 +421,8 @@ dmnsn_delete_token(dmnsn_token token) void dmnsn_delete_tokens(dmnsn_array *tokens) { - dmnsn_token token; - for (size_t i = 0; i < dmnsn_array_size(tokens); ++i) { - dmnsn_array_get(tokens, i, &token); - dmnsn_delete_token(token); + DMNSN_ARRAY_FOREACH (dmnsn_token *, token, tokens) { + dmnsn_delete_token(*token); } dmnsn_delete_array(tokens); } @@ -453,19 +451,16 @@ dmnsn_print_token(FILE *file, dmnsn_token token) void dmnsn_print_token_sexpr(FILE *file, const dmnsn_array *tokens) { - dmnsn_token token; - if (dmnsn_array_size(tokens) == 0) { fprintf(file, "()"); } else { fprintf(file, "("); - dmnsn_array_get(tokens, 0, &token); - dmnsn_print_token(file, token); + dmnsn_token *token = dmnsn_array_first(tokens); + dmnsn_print_token(file, *token); - for (size_t i = 1; i < dmnsn_array_size(tokens); ++i) { + for (++token; token <= (dmnsn_token *)dmnsn_array_last(tokens); ++token) { fprintf(file, " "); - dmnsn_array_get(tokens, i, &token); - dmnsn_print_token(file, token); + dmnsn_print_token(file, *token); } fprintf(file, ")"); diff --git a/dimension/parse.c b/dimension/parse.c index 54b5880..efb208f 100644 --- a/dimension/parse.c +++ b/dimension/parse.c @@ -288,10 +288,8 @@ dmnsn_declare_symbol(dmnsn_symbol_table *symtable, void dmnsn_undef_symbol(dmnsn_symbol_table *symtable, const char *id) { - for (size_t i = 0; i < dmnsn_array_size(symtable); ++i) { - dmnsn_patricia_trie *trie; - dmnsn_array_get(symtable, dmnsn_array_size(symtable) - i - 1, &trie); - if (dmnsn_patricia_remove(trie, id)) + DMNSN_ARRAY_FOREACH (dmnsn_patricia_trie **, trie, symtable) { + if (dmnsn_patricia_remove(*trie, id)) break; } } @@ -301,11 +299,11 @@ dmnsn_find_symbol(dmnsn_symbol_table *symtable, const char *id) { dmnsn_astnode *symbol = NULL; - for (size_t i = 0; i < dmnsn_array_size(symtable); ++i) { - dmnsn_patricia_trie *trie; - dmnsn_array_get(symtable, dmnsn_array_size(symtable) - i - 1, &trie); - - symbol = dmnsn_patricia_find(trie, id); + for (dmnsn_patricia_trie **trie = dmnsn_array_last(symtable); + trie >= (dmnsn_patricia_trie **)dmnsn_array_first(symtable); + --trie) + { + symbol = dmnsn_patricia_find(*trie, id); if (symbol) break; } @@ -469,10 +467,8 @@ void dmnsn_delete_astree(dmnsn_astree *astree) { if (astree) { - for (size_t i = 0; i < dmnsn_array_size(astree); ++i) { - dmnsn_astnode node; - dmnsn_array_get(astree, i, &node); - dmnsn_delete_astnode(node); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, node, astree) { + dmnsn_delete_astnode(*node); } dmnsn_delete_array(astree); } @@ -514,9 +510,8 @@ dmnsn_vector_promote(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) if (astnode.type == DMNSN_AST_VECTOR) { dmnsn_astnode component; - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_array_get(astnode.children, i, &component); - component = dmnsn_eval_scalar(component, symtable); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, i, astnode.children) { + component = dmnsn_eval_scalar(*i, symtable); if (component.type == DMNSN_AST_NONE) { dmnsn_delete_astnode(promoted); @@ -1773,15 +1768,12 @@ dmnsn_print_astnode(FILE *file, dmnsn_astnode astnode) static void dmnsn_print_astree(FILE *file, dmnsn_astnode astnode) { - dmnsn_astnode child; - if (astnode.children && dmnsn_array_size(astnode.children) > 0) { fprintf(file, "("); dmnsn_print_astnode(file, astnode); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_array_get(astnode.children, i, &child); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, child, astnode.children) { fprintf(file, " "); - dmnsn_print_astree(file, child); + dmnsn_print_astree(file, *child); } fprintf(file, ")"); } else { @@ -1792,19 +1784,19 @@ dmnsn_print_astree(FILE *file, dmnsn_astnode astnode) void dmnsn_print_astree_sexpr(FILE *file, const dmnsn_astree *astree) { - dmnsn_astnode astnode; - if (dmnsn_array_size(astree) == 0) { fprintf(file, "()"); } else { fprintf(file, "("); - dmnsn_array_get(astree, 0, &astnode); - dmnsn_print_astree(file, astnode); + dmnsn_astnode *astnode = dmnsn_array_first(astree); + dmnsn_print_astree(file, *astnode); - for (size_t i = 1; i < dmnsn_array_size(astree); ++i) { + for (++astnode; + astnode <= (dmnsn_astnode *)dmnsn_array_last(astree); + ++astnode) + { fprintf(file, " "); - dmnsn_array_get(astree, i, &astnode); - dmnsn_print_astree(file, astnode); + dmnsn_print_astree(file, *astnode); } fprintf(file, ")"); diff --git a/dimension/realize.c b/dimension/realize.c index 05eae07..ec0819f 100644 --- a/dimension/realize.c +++ b/dimension/realize.c @@ -190,17 +190,16 @@ dmnsn_realize_global_settings(dmnsn_astnode astnode, dmnsn_scene *scene) dmnsn_assert(astnode.type == DMNSN_AST_GLOBAL_SETTINGS, "Expected global settings."); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode item, child; - dmnsn_array_get(astnode.children, i, &item); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) { + dmnsn_astnode child; - switch (item.type) { + switch (item->type) { case DMNSN_AST_ASSUMED_GAMMA: /* assumed_gamma not supported */ break; case DMNSN_AST_MAX_TRACE_LEVEL: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); scene->reclimit = dmnsn_realize_integer(child); break; @@ -227,44 +226,43 @@ dmnsn_realize_camera(dmnsn_astnode astnode) dmnsn_camera *camera = NULL; - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode item; - dmnsn_array_get(astnode.children, i, &item); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) { + dmnsn_astnode child; - switch (item.type) { + switch (item->type) { /* Camera types */ case DMNSN_AST_PERSPECTIVE: - camera_type = item.type; + camera_type = item->type; break; /* Camera vectors */ case DMNSN_AST_LOCATION: - dmnsn_array_get(item.children, 0, &item); - location = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + location = dmnsn_realize_vector(child); break; case DMNSN_AST_RIGHT: - dmnsn_array_get(item.children, 0, &item); - right = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + right = dmnsn_realize_vector(child); break; case DMNSN_AST_UP: - dmnsn_array_get(item.children, 0, &item); - right = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + right = dmnsn_realize_vector(child); break; case DMNSN_AST_SKY: - dmnsn_array_get(item.children, 0, &item); - sky = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + sky = dmnsn_realize_vector(child); break; case DMNSN_AST_DIRECTION: - dmnsn_array_get(item.children, 0, &item); - direction = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + direction = dmnsn_realize_vector(child); break; /* Camera modifiers */ case DMNSN_AST_LOOK_AT: { - dmnsn_array_get(item.children, 0, &item); - dmnsn_vector look_at = dmnsn_realize_vector(item); + dmnsn_array_get(item->children, 0, &child); + dmnsn_vector look_at = dmnsn_realize_vector(child); /* Line the camera up with the sky */ @@ -312,8 +310,8 @@ dmnsn_realize_camera(dmnsn_astnode astnode) case DMNSN_AST_ANGLE: { - dmnsn_array_get(item.children, 0, &item); - double angle = deg2rad*dmnsn_realize_float(item); + dmnsn_array_get(item->children, 0, &child); + double angle = deg2rad*dmnsn_realize_float(child); direction = dmnsn_vector_mul( 0.5*dmnsn_vector_norm(right)/tan(angle/2.0), dmnsn_vector_normalize(direction) @@ -325,7 +323,7 @@ dmnsn_realize_camera(dmnsn_astnode astnode) case DMNSN_AST_ROTATION: case DMNSN_AST_SCALE: case DMNSN_AST_TRANSLATION: - trans = dmnsn_matrix_mul(dmnsn_realize_transformation(item), trans); + trans = dmnsn_matrix_mul(dmnsn_realize_transformation(*item), trans); break; default: @@ -408,16 +406,13 @@ dmnsn_realize_pigment_modifiers(dmnsn_astnode astnode, dmnsn_pigment *pigment) dmnsn_assert(astnode.type == DMNSN_AST_PIGMENT_MODIFIERS, "Expected pigment modifiers."); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode modifier; - dmnsn_array_get(astnode.children, i, &modifier); - - switch (modifier.type) { + DMNSN_ARRAY_FOREACH(dmnsn_astnode *, modifier, astnode.children) { + switch (modifier->type) { case DMNSN_AST_ROTATION: case DMNSN_AST_SCALE: case DMNSN_AST_TRANSLATION: pigment->trans = dmnsn_matrix_mul( - dmnsn_realize_transformation(modifier), + dmnsn_realize_transformation(*modifier), pigment->trans ); break; @@ -507,13 +502,12 @@ dmnsn_realize_reflection(dmnsn_astnode astnode) dmnsn_astnode items; dmnsn_array_get(astnode.children, 2, &items); - for (size_t i = 0; i < dmnsn_array_size(items.children); ++i) { - dmnsn_astnode item, child; - dmnsn_array_get(items.children, i, &item); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, items.children) { + dmnsn_astnode child; - switch (item.type) { + switch (item->type) { case DMNSN_AST_FALLOFF: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); falloff = dmnsn_realize_float(child); break; @@ -545,35 +539,34 @@ dmnsn_realize_finish(dmnsn_astnode astnode) dmnsn_finish *reflection = NULL; - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode item, child; - dmnsn_array_get(astnode.children, i, &item); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) { + dmnsn_astnode child; - switch (item.type) { + switch (item->type) { case DMNSN_AST_AMBIENT: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); ambient = dmnsn_realize_color(child); ambient_set = true; break; case DMNSN_AST_DIFFUSE: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); diffuse = dmnsn_realize_float(child); diffuse_set = true; break; case DMNSN_AST_PHONG: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); phong = dmnsn_realize_float(child); break; case DMNSN_AST_PHONG_SIZE: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); phong_size = dmnsn_realize_float(child); break; case DMNSN_AST_REFLECTION: dmnsn_delete_finish(reflection); - reflection = dmnsn_realize_reflection(item); + reflection = dmnsn_realize_reflection(*item); break; default: @@ -616,26 +609,25 @@ dmnsn_realize_texture(dmnsn_astnode astnode) dmnsn_texture *texture = dmnsn_new_texture(); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode item; - dmnsn_array_get(astnode.children, i, &item); - - switch (item.type) { + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) { + switch (item->type) { case DMNSN_AST_PIGMENT: dmnsn_delete_pigment(texture->pigment); - texture->pigment = dmnsn_realize_pigment(item); + texture->pigment = dmnsn_realize_pigment(*item); break; case DMNSN_AST_FINISH: dmnsn_delete_finish(texture->finish); - texture->finish = dmnsn_realize_finish(item); + texture->finish = dmnsn_realize_finish(*item); break; case DMNSN_AST_ROTATION: case DMNSN_AST_SCALE: case DMNSN_AST_TRANSLATION: - texture->trans = dmnsn_matrix_mul(dmnsn_realize_transformation(item), - texture->trans); + texture->trans = dmnsn_matrix_mul( + dmnsn_realize_transformation(*item), + texture->trans + ); break; default: @@ -653,13 +645,12 @@ dmnsn_realize_interior(dmnsn_astnode astnode) dmnsn_interior *interior = dmnsn_new_interior(); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode item, child; - dmnsn_array_get(astnode.children, i, &item); + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, item, astnode.children) { + dmnsn_astnode child; - switch (item.type) { + switch (item->type) { case DMNSN_AST_IOR: - dmnsn_array_get(item.children, 0, &child); + dmnsn_array_get(item->children, 0, &child); interior->ior = dmnsn_realize_float(child); break; @@ -680,40 +671,37 @@ dmnsn_realize_object_modifiers(dmnsn_astnode astnode, dmnsn_object *object) /* Save the pre-existing transformations */ dmnsn_matrix existing_trans = dmnsn_matrix_inverse(object->trans); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode modifier; - dmnsn_array_get(astnode.children, i, &modifier); - - switch (modifier.type) { + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, modifier, astnode.children) { + switch (modifier->type) { case DMNSN_AST_ROTATION: case DMNSN_AST_SCALE: case DMNSN_AST_TRANSLATION: object->trans = dmnsn_matrix_mul( - dmnsn_realize_transformation(modifier), + dmnsn_realize_transformation(*modifier), object->trans ); break; case DMNSN_AST_TEXTURE: dmnsn_delete_texture(object->texture); - object->texture = dmnsn_realize_texture(modifier); + object->texture = dmnsn_realize_texture(*modifier); break; case DMNSN_AST_PIGMENT: if (!object->texture) object->texture = dmnsn_new_texture(); dmnsn_delete_pigment(object->texture->pigment); - object->texture->pigment = dmnsn_realize_pigment(modifier); + object->texture->pigment = dmnsn_realize_pigment(*modifier); break; case DMNSN_AST_FINISH: if (!object->texture) object->texture = dmnsn_new_texture(); dmnsn_delete_finish(object->texture->finish); - object->texture->finish = dmnsn_realize_finish(modifier); + object->texture->finish = dmnsn_realize_finish(*modifier); break; case DMNSN_AST_INTERIOR: dmnsn_delete_interior(object->interior); - object->interior = dmnsn_realize_interior(modifier); + object->interior = dmnsn_realize_interior(*modifier); break; default: @@ -738,26 +726,13 @@ dmnsn_realize_light_source_modifiers(dmnsn_astnode astnode, dmnsn_light *light) dmnsn_assert(astnode.type == DMNSN_AST_OBJECT_MODIFIERS, "Expected object modifiers."); - for (size_t i = 0; i < dmnsn_array_size(astnode.children); ++i) { - dmnsn_astnode modifier; - dmnsn_array_get(astnode.children, i, &modifier); - - switch (modifier.type) { + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, modifier, astnode.children) { + switch (modifier->type) { case DMNSN_AST_ROTATION: - light->x0 = dmnsn_transform_vector( - dmnsn_realize_rotation(modifier), - light->x0 - ); - break; case DMNSN_AST_SCALE: - light->x0 = dmnsn_transform_vector( - dmnsn_realize_scale(modifier), - light->x0 - ); - break; case DMNSN_AST_TRANSLATION: light->x0 = dmnsn_transform_vector( - dmnsn_realize_translation(modifier), + dmnsn_realize_transformation(*modifier), light->x0 ); break; @@ -890,31 +865,32 @@ dmnsn_realize_csg(dmnsn_astnode astnode, dmnsn_array *lights, dmnsn_array_get(astnode.children, 0, &objects); dmnsn_array_get(astnode.children, 1, &modifiers); - size_t i; dmnsn_object *csg = NULL; - for (i = 0; i < dmnsn_array_size(objects.children) && !csg; ++i) { - dmnsn_astnode onode; - dmnsn_array_get(objects.children, i, &onode); - - if (onode.type == DMNSN_AST_LIGHT_SOURCE) { - dmnsn_light *light = dmnsn_realize_light_source(onode); + dmnsn_astnode *onode; + for (onode = dmnsn_array_first(objects.children); + onode <= (dmnsn_astnode *)dmnsn_array_last(objects.children); + ++onode) + { + if (onode->type == DMNSN_AST_LIGHT_SOURCE) { + dmnsn_light *light = dmnsn_realize_light_source(*onode); dmnsn_realize_light_source_modifiers(modifiers, light); dmnsn_array_push(lights, &light); } else { - csg = dmnsn_realize_object(onode, lights); + csg = dmnsn_realize_object(*onode, lights); + break; } } - for (; i < dmnsn_array_size(objects.children); ++i) { - dmnsn_astnode onode; - dmnsn_array_get(objects.children, i, &onode); - - if (onode.type == DMNSN_AST_LIGHT_SOURCE) { - dmnsn_light *light = dmnsn_realize_light_source(onode); + for (++onode; + onode <= (dmnsn_astnode *)dmnsn_array_last(objects.children); + ++onode) + { + if (onode->type == DMNSN_AST_LIGHT_SOURCE) { + dmnsn_light *light = dmnsn_realize_light_source(*onode); dmnsn_realize_light_source_modifiers(modifiers, light); dmnsn_array_push(lights, &light); } else { - dmnsn_object *object = dmnsn_realize_object(onode, lights); + dmnsn_object *object = dmnsn_realize_object(*onode, lights); csg = (*csg_object_fn)(csg, object); } } @@ -1009,25 +985,24 @@ dmnsn_realize_astree(const dmnsn_astree *astree) * Now parse the abstract syntax tree */ - dmnsn_astnode astnode; - for (size_t i = 0; i < dmnsn_array_size(astree); ++i) { - dmnsn_array_get(astree, i, &astnode); - - dmnsn_light *light; + DMNSN_ARRAY_FOREACH (dmnsn_astnode *, astnode, astree) { + dmnsn_astnode child; + dmnsn_light *light; dmnsn_object *object; - switch (astnode.type) { + + switch (astnode->type) { case DMNSN_AST_GLOBAL_SETTINGS: - dmnsn_realize_global_settings(astnode, scene); + dmnsn_realize_global_settings(*astnode, scene); break; case DMNSN_AST_BACKGROUND: - dmnsn_array_get(astnode.children, 0, &astnode); - scene->background = dmnsn_realize_color(astnode); + dmnsn_array_get(astnode->children, 0, &child); + scene->background = dmnsn_realize_color(child); break; case DMNSN_AST_CAMERA: dmnsn_delete_camera(scene->camera); - scene->camera = dmnsn_realize_camera(astnode); + scene->camera = dmnsn_realize_camera(*astnode); break; case DMNSN_AST_BOX: @@ -1037,13 +1012,13 @@ dmnsn_realize_astree(const dmnsn_astree *astree) case DMNSN_AST_PLANE: case DMNSN_AST_SPHERE: case DMNSN_AST_UNION: - object = dmnsn_realize_object(astnode, scene->lights); + object = dmnsn_realize_object(*astnode, scene->lights); if (object) dmnsn_array_push(scene->objects, &object); break; case DMNSN_AST_LIGHT_SOURCE: - light = dmnsn_realize_light_source(astnode); + light = dmnsn_realize_light_source(*astnode); dmnsn_array_push(scene->lights, &light); break; diff --git a/dimension/tokenize.c b/dimension/tokenize.c index efa1064..98253ce 100644 --- a/dimension/tokenize.c +++ b/dimension/tokenize.c @@ -67,10 +67,8 @@ dmnsn_delete_token_buffer(void *ptr) { dmnsn_token_buffer *tbuffer = ptr; if (tbuffer) { - for (size_t i = 0; i < dmnsn_array_size(tbuffer->buffered); ++i) { - dmnsn_buffered_token buffered; - dmnsn_array_get(tbuffer->buffered, i, &buffered); - free(buffered.lval.value); + DMNSN_ARRAY_FOREACH (dmnsn_buffered_token *, buffered, tbuffer->buffered) { + free(buffered->lval.value); } dmnsn_delete_array(tbuffer->buffered); -- cgit v1.2.3