int symexpand(struct idl *idl, struct sym *sym) { char *key; struct sym *mem; iter_t iter; if (IS_EXPANDED(sym)) { return 0; } sym->flags |= FLAGS_EXPANDED; sym->orig = sym; if (IS_INTERFACE(sym)) { const char *pd = hashmap_get(&sym->attrs, "pointer_default"); idl->ptr_default = PTR_TYPE_UNIQUE; if (pd) { if (strcmp(pd, "ptr") == 0) { idl->ptr_default = PTR_TYPE_PTR; } else if (strcmp(pd, "ref") == 0) { idl->ptr_default = PTR_TYPE_REF; } } } else if (IS_ENUM(sym)) { char buf[16]; int val = 0; linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { mem->flags = FLAGS_CONST | FLAGS_PRIMATIVE; if (mem->value) { val = strtoul(mem->value, NULL, 0); } sprintf(buf, "%d", val++); mem->value = dupstr(buf, idl->al); } } else if (sym->ptr) { if (hashmap_get(&sym->attrs, "unique")) { sym->ptr_type = PTR_TYPE_UNIQUE; } else if (hashmap_get(&sym->attrs, "ptr")) { sym->ptr_type = PTR_TYPE_PTR; } else if (hashmap_get(&sym->attrs, "ref")) { sym->ptr_type = PTR_TYPE_REF; } else if (IS_PARAMETER(sym) || IS_OPERATION(sym)) { sym->ptr_type = PTR_TYPE_REF; } else { sym->ptr_type = idl->ptr_default; } } /* If the symbol is typedef'd add it to the table using the * typedef'd name too */ if (IS_TYPEDEFD(sym) && sym->name) { if (IS_ENUM(sym) && (mem = hashmap_get(idl->syms, sym->idl_type))) { mem->noemit = 1; /* supress redundant enum */ } key = sym->name; } else { key = sym->idl_type; } if (hashmap_get(idl->syms, key) == NULL) { if (hashmap_put(idl->syms, key, sym) == -1) { AMSG(""); } } /* If the symbol has members it is already expanded */ if (linkedlist_size(&sym->mems) == 0) { struct sym *s = symlook(idl, sym->idl_type); if (s) { sym->interface = s->interface; linkedlist_iterate(&s->mems, &iter); while ((mem = linkedlist_next(&s->mems, &iter))) { struct sym *cpy = symnew(idl->al); symcopy(mem, cpy, idl->al); linkedlist_add(&sym->mems, cpy); } } else { AMSG(""); return -1; } } sym->id = idl->symid++; /* Perform expansion recursively on all symbols */ linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { symexpand(idl, mem); mem->parent = sym; } return 0; }
static void tre_do_print(FILE *stream, tre_ast_node_t *ast, int indent) { int code_min, code_max, pos; int num_tags = ast->num_tags; tre_literal_t *lit; tre_iteration_t *iter; tre_findent(stream, indent); switch (ast->type) { case LITERAL: lit = ast->obj; code_min = lit->code_min; code_max = lit->code_max; pos = lit->position; if (IS_EMPTY(lit)) { fprintf(stream, "literal empty\n"); } else if (IS_ASSERTION(lit)) { int i; char *assertions[] = { "bol", "eol", "bracket", "bow", "eow", "wb", "!wb", "backref" }; if (code_max >= ASSERT_LAST << 1) assert(0); fprintf(stream, "assertions: "); for (i = 0; (1 << i) <= ASSERT_LAST; i++) if (code_max & (1 << i)) fprintf(stream, "%s ", assertions[i]); fprintf(stream, "\n"); } else if (IS_TAG(lit)) { fprintf(stream, "tag %d\n", code_max); } else if (IS_BACKREF(lit)) { fprintf(stream, "backref %d, pos %d\n", code_max, pos); } else if (IS_PARAMETER(lit)) { tre_print_params(lit->u.params); fprintf(stream, "\n"); } else { fprintf(stream, "literal (%c, %c) (%d, %d), pos %d, sub %d, " "%d tags\n", code_min, code_max, code_min, code_max, pos, ast->submatch_id, num_tags); } break; case ITERATION: iter = ast->obj; fprintf(stream, "iteration {%d, %d}, sub %d, %d tags, %s\n", iter->min, iter->max, ast->submatch_id, num_tags, iter->minimal ? "minimal" : "greedy"); tre_do_print(stream, iter->arg, indent + 2); break; case UNION: fprintf(stream, "union, sub %d, %d tags\n", ast->submatch_id, num_tags); tre_do_print(stream, ((tre_union_t *)ast->obj)->left, indent + 2); tre_do_print(stream, ((tre_union_t *)ast->obj)->right, indent + 2); break; case CATENATION: fprintf(stream, "catenation, sub %d, %d tags\n", ast->submatch_id, num_tags); tre_do_print(stream, ((tre_catenation_t *)ast->obj)->left, indent + 2); tre_do_print(stream, ((tre_catenation_t *)ast->obj)->right, indent + 2); break; default: assert(0); break; } }