diff --git a/mie/CMakeLists.txt b/mie/CMakeLists.txt index 500e377..ba9b1ac 100644 --- a/mie/CMakeLists.txt +++ b/mie/CMakeLists.txt @@ -11,5 +11,5 @@ else () endif () target_include_directories(mie PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/) -target_link_libraries(mie Bluelib::Core Bluelib::Object) +target_link_libraries(mie Bluelib::Core Bluelib::Ds) target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${IVY_STATIC}) diff --git a/mie/ctx.c b/mie/ctx.c index faccd59..3347199 100644 --- a/mie/ctx.c +++ b/mie/ctx.c @@ -1,6 +1,6 @@ -#include -#include -#include +#include +#include +#include #include #include #include @@ -62,23 +62,25 @@ void mie_ctx_destroy(struct mie_ctx *ctx) ctx->ctx_true = NULL; ctx->ctx_false = NULL; - b_btree_iterator it = {}; - b_btree_iterator_begin(&ctx->ctx_int_cache, &it); - while (b_btree_iterator_is_valid(&it)) { + b_btree_node *node = b_btree_first(&ctx->ctx_int_cache); + while (node) { struct ctx_int_cache_entry *entry - = b_unbox(struct ctx_int_cache_entry, it.node, i_node); - b_btree_iterator_erase(&it); + = b_unbox(struct ctx_int_cache_entry, node, i_node); + b_btree_node *next = b_btree_next(node); + b_btree_delete(&ctx->ctx_int_cache, node); - b_btree_iterator it2 = {}; - b_btree_iterator_begin(&entry->i_values, &it2); - while (b_btree_iterator_is_valid(&it2)) { + b_btree_node *node2 = b_btree_first(&entry->i_values); + while (node2) { struct ctx_int_value_cache_entry *value = b_unbox( - struct ctx_int_value_cache_entry, it2.node, i_node); - b_btree_iterator_erase(&it2); + struct ctx_int_value_cache_entry, node2, i_node); + b_btree_node *next2 = b_btree_next(node2); + b_btree_delete(&entry->i_values, node2); free(value); + node2 = next2; } free(entry); + node = next; } const size_t nr_types = sizeof ctx->ctx_types / sizeof ctx->ctx_types[0]; @@ -93,7 +95,7 @@ void mie_ctx_destroy(struct mie_ctx *ctx) mie_value_destroy(ctx->ctx_null); } - b_hashmap_release(ctx->ctx_sel_cache); + b_hashmap_unref(ctx->ctx_sel_cache); free(ctx); } diff --git a/mie/include/mie/ctx.h b/mie/include/mie/ctx.h index 00c61aa..7311ff3 100644 --- a/mie/include/mie/ctx.h +++ b/mie/include/mie/ctx.h @@ -2,6 +2,7 @@ #define MIE_CTX_H_ #include +#include #include struct mie_ctx { @@ -9,8 +10,8 @@ struct mie_ctx { struct mie_value *ctx_null; struct mie_type *ctx_types[__MIE_TYPE_COUNT]; b_btree ctx_int_cache; - struct b_hashmap *ctx_sel_cache; - struct b_hashmap *ctx_string_cache; + b_hashmap *ctx_sel_cache; + b_hashmap *ctx_string_cache; }; extern struct mie_ctx *mie_ctx_create(void); diff --git a/mie/include/mie/ir/const.h b/mie/include/mie/ir/const.h index e51f00f..df55e5c 100644 --- a/mie/include/mie/ir/const.h +++ b/mie/include/mie/ir/const.h @@ -1,6 +1,7 @@ #ifndef MIE_CONST_H_ #define MIE_CONST_H_ +#include #include #include @@ -13,8 +14,6 @@ #define MIE_SELECTOR(p) ((struct mie_selector *)(p)) #define MIE_ARRAY(p) ((struct mie_array *)(p)) -struct b_list; - struct mie_const { struct mie_value c_base; struct mie_type *c_type; @@ -47,7 +46,7 @@ struct mie_selector { struct mie_array { struct mie_const a_base; - struct b_list *a_values; + b_list *a_values; }; extern void mie_const_init(struct mie_const *c, struct mie_type *type); diff --git a/mie/include/mie/ir/convert.h b/mie/include/mie/ir/convert.h index d5a366a..67462a3 100644 --- a/mie/include/mie/ir/convert.h +++ b/mie/include/mie/ir/convert.h @@ -2,8 +2,8 @@ #define MIE_CONVERT_H_ #include -#include -#include +#include +#include #include #include diff --git a/mie/include/mie/ir/module.h b/mie/include/mie/ir/module.h index 7e109d2..fb8c3a5 100644 --- a/mie/include/mie/ir/module.h +++ b/mie/include/mie/ir/module.h @@ -4,11 +4,11 @@ #define MIE_MODULE(p) ((struct mie_module *)(p)) #include +#include #include #include struct mie_func; -struct b_hashmap; struct mie_module { struct mie_value m_base; @@ -17,8 +17,8 @@ struct mie_module { b_queue m_types; b_queue m_func; - struct b_hashmap *m_data; - struct b_hashmap *m_data_strings; + b_hashmap *m_data; + b_hashmap *m_data_strings; }; extern struct mie_module *mie_module_create(void); diff --git a/mie/include/mie/select/graph.h b/mie/include/mie/select/graph.h index d638214..7e1c25e 100644 --- a/mie/include/mie/select/graph.h +++ b/mie/include/mie/select/graph.h @@ -31,20 +31,9 @@ struct mie_select_graph { }; struct mie_select_use_iterator { - b_queue_iterator it_base; + b_queue_entry *it_ptr; }; -#define mie_select_use_foreach(it, q) b_queue_foreach (&(it)->it_base, q) - -static inline struct mie_select_use *mie_select_use_iterator_unbox( - struct mie_select_use_iterator *it) -{ - return b_unbox(struct mie_select_use, it->it_base.entry, u_entry); -} -MIE_API void mie_select_use_iterator_next(struct mie_select_use_iterator *it); -MIE_API bool mie_select_use_iterator_is_valid( - const struct mie_select_use_iterator *it); - MIE_API struct mie_select_graph *mie_select_graph_create(struct mie_ctx *ctx); MIE_API void mie_select_graph_destroy(struct mie_select_graph *graph); diff --git a/mie/include/mie/select/node.h b/mie/include/mie/select/node.h index a099055..86569ca 100644 --- a/mie/include/mie/select/node.h +++ b/mie/include/mie/select/node.h @@ -61,13 +61,13 @@ struct mie_select_node { }; struct mie_select_node_iterator { - b_queue_iterator it_base; + b_queue_entry *it_ptr; }; static inline struct mie_select_node *mie_select_node_iterator_unbox( struct mie_select_node_iterator *it) { - return b_unbox(struct mie_select_node, it->it_base.entry, n_entry); + return b_unbox(struct mie_select_node, it->it_ptr, n_entry); } MIE_API void mie_select_node_iterator_next(struct mie_select_node_iterator *it); diff --git a/mie/ir/block.c b/mie/ir/block.c index e8cc743..81591f2 100644 --- a/mie/ir/block.c +++ b/mie/ir/block.c @@ -70,19 +70,26 @@ static void cleanup(struct mie_value *value) { struct mie_block *block = MIE_BLOCK(value); - b_queue_iterator it; - b_queue_iterator_begin(&block->b_phi, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + b_queue_entry *entry = b_queue_first(&block->b_phi); + b_queue_entry *next = NULL; + + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&block->b_phi, entry); mie_value_destroy(v); + + entry = next; } - b_queue_iterator_begin(&block->b_instr, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + entry = b_queue_first(&block->b_instr); + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&block->b_instr, entry); mie_value_destroy(v); + + entry = next; } if (block->b_terminator) { diff --git a/mie/ir/builder.c b/mie/ir/builder.c index 241ddff..c1ba45a 100644 --- a/mie/ir/builder.c +++ b/mie/ir/builder.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -52,15 +52,16 @@ struct mie_record *mie_builder_put_record( return NULL; } - b_queue_iterator it = {}; - b_queue_foreach (&it, &builder->b_module->m_records) { - struct mie_value *rec - = b_unbox(struct mie_value, it.entry, v_entry); + b_queue_entry *entry = b_queue_first(&builder->b_module->m_records); + while (entry) { + struct mie_value *rec = b_unbox(struct mie_value, entry, v_entry); if (!strcmp(rec->v_name.n_str, name)) { /* TODO what to do about `val` here? */ return MIE_RECORD(rec); } + + entry = b_queue_next(entry); } struct mie_record *rec = mie_record_create(val); @@ -77,14 +78,15 @@ struct mie_record *mie_builder_get_record( return NULL; } - b_queue_iterator it = {}; - b_queue_foreach (&it, &builder->b_module->m_records) { - struct mie_value *rec - = b_unbox(struct mie_value, it.entry, v_entry); + b_queue_entry *entry = b_queue_first(&builder->b_module->m_records); + while (entry) { + struct mie_value *rec = b_unbox(struct mie_value, entry, v_entry); if (!strcmp(rec->v_name.n_str, name)) { return MIE_RECORD(rec); } + + entry = b_queue_next(entry); } return NULL; diff --git a/mie/ir/convert/text-write.c b/mie/ir/convert/text-write.c index 420422d..aed8d15 100644 --- a/mie/ir/convert/text-write.c +++ b/mie/ir/convert/text-write.c @@ -1,7 +1,7 @@ #include "convert.h" -#include -#include +#include +#include #include #include #include @@ -32,7 +32,8 @@ b_status write_char(struct mie_ir_converter *converter, char c) switch (converter->c_dest_medium) { case MIE_IR_CONVERTER_STRINGSTREAM: - return b_stringstream_add(converter->c_dest.stringstream, s); + return b_stream_write_string( + converter->c_dest.stringstream, s, NULL); case MIE_IR_CONVERTER_STRING: b_string_append_cstr(converter->c_dest.string, s); return B_SUCCESS; @@ -52,7 +53,8 @@ b_status write_string(struct mie_ir_converter *converter, const char *s) switch (converter->c_dest_medium) { case MIE_IR_CONVERTER_STRINGSTREAM: - return b_stringstream_add(converter->c_dest.stringstream, s); + return b_stream_write_string( + converter->c_dest.stringstream, s, NULL); case MIE_IR_CONVERTER_STRING: b_string_append_cstr(converter->c_dest.string, s); return B_SUCCESS; @@ -79,7 +81,8 @@ b_status write_string_f(struct mie_ir_converter *converter, const char *format, switch (converter->c_dest_medium) { case MIE_IR_CONVERTER_STRINGSTREAM: vsnprintf(buf, sizeof buf, format, arg); - status = b_stringstream_add(converter->c_dest.stringstream, buf); + status = b_stream_write_string( + converter->c_dest.stringstream, buf, NULL); break; case MIE_IR_CONVERTER_STRING: vsnprintf(buf, sizeof buf, format, arg); @@ -147,23 +150,26 @@ static b_status write_operand_const( break; case MIE_TYPE_ARRAY: { struct mie_array *array = MIE_ARRAY(value); - b_list_iterator it; - b_list_iterator_begin(array->a_values, &it); + b_iterator *it = b_list_begin(array->a_values); write_char(converter, '{'); - while (b_list_iterator_is_valid(&it)) { - if (it.i > 0) { + size_t i = 0; + b_foreach(void *, item, it) + { + if (i > 0) { write_char(converter, ','); } write_string(converter, "\n "); - struct mie_value *child = it.item; + struct mie_value *child = item; write_operand_const(converter, child, F_INCLUDE_TYPE); - b_list_iterator_next(&it); + i++; } + b_iterator_unref(it); + if (!b_list_empty(array->a_values)) { write_char(converter, '\n'); } @@ -292,39 +298,43 @@ static b_status write_module( struct mie_module *mod = MIE_MODULE(value); b_status status = B_SUCCESS; - b_queue_iterator it; - b_queue_foreach (&it, &mod->m_records) { + b_queue_entry *entry = b_queue_first(&mod->m_records); + while (entry) { struct mie_value *record - = b_unbox(struct mie_value, it.entry, v_entry); + = b_unbox(struct mie_value, entry, v_entry); status = write_value_to_text(converter, record); if (!B_OK(status)) { return status; } + + entry = b_queue_next(entry); } if (!b_queue_empty(&mod->m_records)) { write_char(converter, '\n'); } - b_queue_foreach (&it, &mod->m_types) { - struct mie_value *type - = b_unbox(struct mie_value, it.entry, v_entry); + entry = b_queue_first(&mod->m_types); + while (entry) { + struct mie_value *type = b_unbox(struct mie_value, entry, v_entry); status = write_value_to_text(converter, type); if (!B_OK(status)) { return status; } + + entry = b_queue_next(entry); } if (!b_queue_empty(&mod->m_types)) { write_char(converter, '\n'); } - b_hashmap_iterator it2; - b_hashmap_foreach(&it2, mod->m_data) + b_iterator *it = b_iterator_begin(mod->m_data); + b_foreach_ptr(b_hashmap_item, item, it) { - struct mie_value *data = it2.value->value_data; + struct mie_value *data = item->value.value_data; status = write_value_to_text(converter, data); if (!B_OK(status)) { @@ -332,18 +342,20 @@ static b_status write_module( } } + b_iterator_unref(it); + if (!b_hashmap_is_empty(mod->m_data)) { write_char(converter, '\n'); } unsigned long i = 0; - b_queue_foreach (&it, &mod->m_func) { + entry = b_queue_first(&mod->m_func); + while (entry) { if (i > 0) { write_char(converter, '\n'); } - struct mie_value *func - = b_unbox(struct mie_value, it.entry, v_entry); + struct mie_value *func = b_unbox(struct mie_value, entry, v_entry); status = write_value_to_text(converter, func); if (!B_OK(status)) { @@ -351,6 +363,7 @@ static b_status write_module( } i++; + entry = b_queue_next(entry); } return B_SUCCESS; @@ -390,10 +403,10 @@ static b_status write_func_definition( converter, "define %s @%s(", type_name, func->f_base.v_name.n_str); unsigned int i = 0; - b_queue_iterator it; - b_queue_foreach (&it, &func->f_args) { + struct b_queue_entry *entry = b_queue_first(&func->f_args); + while (entry) { struct mie_arg *arg = (struct mie_arg *)b_unbox( - struct mie_value, it.entry, v_entry); + struct mie_value, entry, v_entry); if (i > 0) { write_string(converter, ", "); @@ -405,6 +418,7 @@ static b_status write_func_definition( converter, "%s %%%s", type_name, arg->arg_base.v_name.n_str); i++; + entry = b_queue_next(entry); } write_string_f(converter, ")"); @@ -425,10 +439,12 @@ static b_status write_func_definition( write_string_f(converter, " {\n"); - b_queue_foreach (&it, &func->f_blocks) { + entry = b_queue_first(&func->f_blocks); + while (entry) { struct mie_value *block - = b_unbox(struct mie_value, it.entry, v_entry); + = b_unbox(struct mie_value, entry, v_entry); write_value_to_text(converter, block); + entry = b_queue_next(entry); } write_string_f(converter, "}\n"); @@ -442,17 +458,20 @@ static b_status write_block_definition( struct mie_block *block = MIE_BLOCK(value); write_string_f(converter, "%s:\n", block->b_base.v_name.n_str); - b_queue_iterator it; - b_queue_foreach (&it, &block->b_phi) { + b_queue_entry *entry = b_queue_first(&block->b_phi); + while (entry) { struct mie_value *instr - = b_unbox(struct mie_value, it.entry, v_entry); + = b_unbox(struct mie_value, entry, v_entry); write_value_to_text(converter, instr); + entry = b_queue_next(entry); } - b_queue_foreach (&it, &block->b_instr) { + entry = b_queue_first(&block->b_instr); + while (entry) { struct mie_value *instr - = b_unbox(struct mie_value, it.entry, v_entry); + = b_unbox(struct mie_value, entry, v_entry); write_value_to_text(converter, instr); + entry = b_queue_next(entry); } if (block->b_terminator) { diff --git a/mie/ir/data.c b/mie/ir/data.c index 667cc9b..9b044ff 100644 --- a/mie/ir/data.c +++ b/mie/ir/data.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include diff --git a/mie/ir/func.c b/mie/ir/func.c index 155015a..b1532a6 100644 --- a/mie/ir/func.c +++ b/mie/ir/func.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -118,19 +118,26 @@ static void cleanup(struct mie_value *value) { struct mie_func *func = MIE_FUNC(value); - b_queue_iterator it; - b_queue_iterator_begin(&func->f_args, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + b_queue_entry *entry = b_queue_first(&func->f_args); + b_queue_entry *next = NULL; + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&func->f_args, entry); + mie_value_destroy(v); + entry = next; } - b_queue_iterator_begin(&func->f_blocks, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + entry = b_queue_first(&func->f_blocks); + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&func->f_blocks, entry); + mie_value_destroy(v); + + entry = next; } mie_name_map_destroy(func->f_names); diff --git a/mie/ir/module.c b/mie/ir/module.c index f487ec7..da6f95f 100644 --- a/mie/ir/module.c +++ b/mie/ir/module.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -116,30 +116,36 @@ static void cleanup(struct mie_value *value) { struct mie_module *module = MIE_MODULE(value); - b_queue_iterator it; - b_queue_iterator_begin(&module->m_records, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + b_queue_entry *entry = b_queue_first(&module->m_records); + b_queue_entry *next = NULL; + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&module->m_records, entry); mie_value_destroy(v); + entry = next; } - b_queue_iterator_begin(&module->m_types, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + entry = b_queue_first(&module->m_types); + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&module->m_types, entry); mie_value_destroy(v); + entry = next; } - b_queue_iterator_begin(&module->m_func, &it); - while (b_queue_iterator_is_valid(&it)) { - struct mie_value *v = b_unbox(struct mie_value, it.entry, v_entry); - b_queue_iterator_erase(&it); + entry = b_queue_first(&module->m_func); + while (entry) { + struct mie_value *v = b_unbox(struct mie_value, entry, v_entry); + next = b_queue_next(entry); + b_queue_delete(&module->m_func, entry); mie_value_destroy(v); + entry = next; } - b_hashmap_release(module->m_data_strings); - b_hashmap_release(module->m_data); + b_hashmap_unref(module->m_data_strings); + b_hashmap_unref(module->m_data); } const struct mie_value_type module_value_type = { diff --git a/mie/name.c b/mie/name.c index 7811767..4b99ccf 100644 --- a/mie/name.c +++ b/mie/name.c @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -25,11 +25,12 @@ static struct mie_name_bucket *create_bucket(void) static void destroy_bucket(struct mie_name_bucket *bucket) { - b_queue_iterator it; - b_queue_iterator_begin(&bucket->b_names, &it); + b_queue_entry *entry = b_queue_first(&bucket->b_names); - while (b_queue_iterator_is_valid(&it)) { - b_queue_iterator_erase(&it); + while (entry) { + b_queue_entry *next = b_queue_next(entry); + b_queue_delete(&bucket->b_names, entry); + entry = next; } free(bucket); @@ -48,19 +49,20 @@ struct mie_name_map *mie_name_map_create(void) void mie_name_map_destroy(struct mie_name_map *map) { - b_btree_iterator it; - b_btree_iterator_begin(&map->m_entries, &it); + b_btree_node *node = b_btree_first(&map->m_entries); - while (b_btree_iterator_is_valid(&it)) { + while (node) { struct mie_name_map_entry *entry - = b_unbox(struct mie_name_map_entry, it.node, e_node); - b_btree_iterator_erase(&it); - + = b_unbox(struct mie_name_map_entry, node, e_node); + b_btree_node *next = b_btree_next(node); + b_btree_delete(&map->m_entries, node); if (entry->e_type == MIE_NAME_MAP_E_BUCKET) { struct mie_name_bucket *bucket = (struct mie_name_bucket *)entry; destroy_bucket(bucket); } + + node = next; } free(map); @@ -69,14 +71,17 @@ void mie_name_map_destroy(struct mie_name_map *map) static b_status put_name_in_bucket( struct mie_name_bucket *bucket, struct mie_name *name) { - b_queue_iterator it; - b_queue_foreach (&it, &bucket->b_names) { + b_queue_entry *entry = b_queue_first(&bucket->b_names); + + while (entry) { struct mie_name *cur = (struct mie_name *)b_unbox( - struct mie_name_map_entry, it.entry, e_entry); + struct mie_name_map_entry, entry, e_entry); if (!strcmp(cur->n_str, name->n_str)) { return B_ERR_NAME_EXISTS; } + + entry = b_queue_next(entry); } b_queue_push_back(&bucket->b_names, &name->n_base.e_entry); @@ -181,7 +186,7 @@ struct mie_name *mie_name_map_put( b_rope_to_cstr(&unique_name, str, sizeof str); entry->n_str = str; - entry->n_base.e_hash = b_hash_string(str); + entry->n_base.e_hash = b_hash_cstr(str); b_status status = put_name(map, entry); if (B_OK(status)) { diff --git a/mie/select/builder.c b/mie/select/builder.c index 4f81f98..99dc331 100644 --- a/mie/select/builder.c +++ b/mie/select/builder.c @@ -1,6 +1,6 @@ #include "builder.h" -#include +#include #include #include #include @@ -51,7 +51,7 @@ struct mie_select_builder *mie_select_builder_create( out->b_mem_access = b_hashmap_create(NULL, NULL); if (!out->b_mem_access) { - b_hashmap_release(out->b_nodes); + b_hashmap_unref(out->b_nodes); mie_select_graph_destroy(out->b_graph); free(out); return NULL; @@ -63,11 +63,11 @@ struct mie_select_builder *mie_select_builder_create( void mie_select_builder_destroy(struct mie_select_builder *builder) { if (builder->b_nodes) { - b_hashmap_release(builder->b_nodes); + b_hashmap_unref(builder->b_nodes); } if (builder->b_mem_access) { - b_hashmap_release(builder->b_mem_access); + b_hashmap_unref(builder->b_mem_access); } if (builder->b_graph) { @@ -96,12 +96,14 @@ const struct mie_target *mie_select_builder_get_target( static void clear_node_map(struct mie_select_builder *builder) { - b_hashmap_iterator it; - b_hashmap_iterator_begin(builder->b_nodes, &it); - while (b_hashmap_iterator_is_valid(&it)) { - free(it.value->value_data); - b_hashmap_iterator_erase(&it); + b_iterator *it = b_iterator_begin(builder->b_nodes); + while (b_iterator_is_valid(it)) { + b_hashmap_item *item = b_iterator_get_value(it).v_ptr; + free(item->value.value_data); + b_iterator_erase(it); } + + b_iterator_unref(it); } struct mie_select_graph *mie_select_builder_finish(struct mie_select_builder *builder) @@ -142,28 +144,30 @@ enum mie_status mie_select_builder_get_const( struct mie_type *ctype = mie_ctx_get_int_type(builder->b_ctx, 32); struct mie_select_node *node = NULL; - b_queue_iterator it; - b_queue_foreach (&it, &builder->b_graph->g_nodes) { - node = b_unbox(struct mie_select_node, it.entry, n_entry); + b_queue_entry *entry = b_queue_first(&builder->b_graph->g_nodes); + while (entry) { + node = b_unbox(struct mie_select_node, entry, n_entry); if (node->n_target != builtin) { - continue; + goto skip; } if (node->n_opcode != MIE_SELECT_OP_CONSTANT) { - continue; + goto skip; } if (!(node->n_flags & MIE_SELECT_NODE_F_IVALUE)) { - continue; + goto skip; } if (node->n_value.i != value) { - continue; + goto skip; } mie_select_node_get_value(node, ctype, 0, out); return MIE_SUCCESS; + skip: + entry = b_queue_next(entry); } enum mie_status status = mie_select_graph_get_node( @@ -368,15 +372,17 @@ struct mie_select_node *mie_select_builder_find_node_with_ivalue( struct mie_select_builder *builder, const struct mie_target *target, unsigned int opcode, long long val) { - b_queue_iterator it; - b_queue_foreach (&it, &builder->b_graph->g_nodes) { + b_queue_entry *entry = b_queue_first(&builder->b_graph->g_nodes); + while (entry) { struct mie_select_node *node - = b_unbox(struct mie_select_node, it.entry, n_entry); + = b_unbox(struct mie_select_node, entry, n_entry); if (node->n_target == target && node->n_opcode == opcode && node->n_value.i == val) { return node; } + + entry = b_queue_next(entry); } return NULL; diff --git a/mie/select/dump.c b/mie/select/dump.c index bd2fa6f..7a2d801 100644 --- a/mie/select/dump.c +++ b/mie/select/dump.c @@ -245,11 +245,12 @@ static void node_links_dump_dot(struct mie_select_node *node, b_stream *out) void mie_select_graph_dump_text(struct mie_select_graph *graph) { - b_queue_iterator it; - b_queue_foreach (&it, &graph->g_nodes) { + b_queue_entry *entry = b_queue_first(&graph->g_nodes); + while (entry) { struct mie_select_node *node - = b_unbox(struct mie_select_node, it.entry, n_entry); + = b_unbox(struct mie_select_node, entry, n_entry); node_dump_text(node); + entry = b_queue_next(entry); } } @@ -263,22 +264,25 @@ void mie_select_graph_dump_dot(struct mie_select_graph *graph) b_stream_write_string(tmpstream, "\tnode [shape=Mrecord];\n", NULL); b_stream_write_string(tmpstream, "\trankdir=\"BT\";\n", NULL); - b_queue_iterator it; - b_queue_foreach (&it, &graph->g_nodes) { + b_queue_entry *entry = b_queue_first(&graph->g_nodes); + while (entry) { struct mie_select_node *node - = b_unbox(struct mie_select_node, it.entry, n_entry); + = b_unbox(struct mie_select_node, entry, n_entry); node_dump_dot(node, tmpstream); + entry = b_queue_next(entry); } - b_queue_foreach (&it, &graph->g_nodes) { + entry = b_queue_first(&graph->g_nodes); + while (entry) { struct mie_select_node *node - = b_unbox(struct mie_select_node, it.entry, n_entry); + = b_unbox(struct mie_select_node, entry, n_entry); node_links_dump_dot(node, tmpstream); + entry = b_queue_next(entry); } b_stream_write_string(tmpstream, "}\n", NULL); - b_stream_close(tmpstream); + b_stream_unref(tmpstream); system("open graph.dot"); diff --git a/mie/select/graph.c b/mie/select/graph.c index 268473d..aa16a07 100644 --- a/mie/select/graph.c +++ b/mie/select/graph.c @@ -42,12 +42,12 @@ struct mie_select_graph *mie_select_graph_create(struct mie_ctx *ctx) void mie_select_graph_destroy(struct mie_select_graph *graph) { - b_queue_iterator it; - b_queue_iterator_begin(&graph->g_nodes, &it); - while (b_queue_iterator_is_valid(&it)) { + b_queue_entry *entry = b_queue_first(&graph->g_nodes); + while (entry) { struct mie_select_node *node - = b_unbox(struct mie_select_node, it.entry, n_entry); - b_queue_iterator_erase(&it); + = b_unbox(struct mie_select_node, entry, n_entry); + b_queue_entry *next = b_queue_next(entry); + b_queue_delete(&graph->g_nodes, entry); #if 0 if (node->n_value) { @@ -56,6 +56,7 @@ void mie_select_graph_destroy(struct mie_select_graph *graph) #endif free(node); + entry = next; } free(graph); diff --git a/mie/select/node.c b/mie/select/node.c index 5400f0a..0f2b878 100644 --- a/mie/select/node.c +++ b/mie/select/node.c @@ -22,6 +22,7 @@ const struct select_node_type *select_type_for_node(enum mie_select_opcode node) return node_types[node]; } +#if 0 void mie_select_node_iterator_next(struct mie_select_node_iterator *it) { b_queue_iterator_next(&it->it_base); @@ -31,6 +32,7 @@ bool mie_select_node_iterator_is_valid(const struct mie_select_node_iterator *it { return b_queue_iterator_is_valid(&it->it_base); } +#endif struct mie_select_node *mie_select_node_create( const struct mie_target *target, unsigned int op, @@ -101,13 +103,16 @@ enum mie_status mie_select_node_set_operands( enum mie_status mie_select_node_clear_operands(struct mie_select_node *node) { - struct mie_select_use_iterator it; - mie_select_use_foreach(&it, &node->n_use) - { - struct mie_select_use *use = mie_select_use_iterator_unbox(&it); + b_queue_entry *entry = b_queue_first(&node->n_use); + while (entry) { + + struct mie_select_use *use + = b_unbox(struct mie_select_use, entry, u_entry); if (use->u_value.v_node == node) { memset(&use->u_value, 0x0, sizeof use->u_value); } + + entry = b_queue_next(entry); } if (node->n_operands) { @@ -158,12 +163,12 @@ enum mie_status mie_select_node_set_description( { va_list arg; va_start(arg, format); - b_stringstream str; - b_stringstream_begin_dynamic(&str); - b_stringstream_addvf(&str, format, arg); + b_stringstream *str = b_stringstream_create(); + b_stream_write_vfmt(str, NULL, format, arg); va_end(arg); - node->n_description = b_stringstream_end(&str); + node->n_description = b_stringstream_steal(str); + b_stringstream_unref(str); return node->n_description ? MIE_SUCCESS : MIE_ERR_NO_MEMORY; }