diff --git a/CMakeLists.txt b/CMakeLists.txt index d602692..4eeb80d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,10 +24,10 @@ if (NOT MIE_STATIC) endif () if (MIE_STATIC) - set(Bluelib_STATIC TRUE) + set(FX_STATIC TRUE) endif () -find_package(Bluelib REQUIRED) +find_package(FX REQUIRED) add_subdirectory(mie) add_subdirectory(tool) diff --git a/cmake/FindBluelib.cmake b/cmake/FindBluelib.cmake deleted file mode 100644 index 648ceaa..0000000 --- a/cmake/FindBluelib.cmake +++ /dev/null @@ -1,189 +0,0 @@ -#[=======================================================================[.rst: -FindBluelib ------------- - -Find the Bluelib library and header directories - -Imported Targets -^^^^^^^^^^^^^^^^ - -This module defines the following :prop_tgt:`IMPORTED` target: - -``Bluelib::Bluelib`` -The Bluelib library, if found - -Result Variables -^^^^^^^^^^^^^^^^ - -This module will set the following variables in your project: - -``Bluelib_FOUND`` -true if the Bluelib C headers and libraries were found -``Bluelib_INCLUDE_DIR`` -directories containing the Bluelib C headers. - -``Bluelib_LIBRARY`` -the C library to link against - -Hints -^^^^^ - -The user may set the environment variable ``Bluelib_PREFIX`` to the root -directory of a Bluelib library installation. -#]=======================================================================] - -set (Bluelib_SEARCH_PATHS - ~/Library/Frameworks - /Library/Frameworks - /usr/local - /usr/local/share - /usr - /sw # Fink - /opt/local # DarwinPorts - /opt/csw # Blastwave - /opt - ${Bluelib_PREFIX} - $ENV{Bluelib_PREFIX}) - -if (Bluelib_STATIC) - set(_lib_suffix "-s") -endif () - -set(supported_components Core Ds Term Cmd Io Serial Compress) -set(components ${Bluelib_FIND_COMPONENTS}) -string(REPLACE ";" ", " supported_components_string_list "${supported_components}") - -if (NOT components) - set(components ${supported_components}) -endif () - -set(required_vars) - -foreach (component ${components}) - if (NOT "${component}" IN_LIST supported_components) - message(FATAL_ERROR "'${component}' is not a valid Bluelib module.\nSupported modules: ${supported_components_string_list}") - endif () - - string(TOLOWER ${component} header_name) - set(lib_name ${header_name}${_lib_suffix}) - - if (NOT Bluelib_${component}_INCLUDE_DIR) - find_path(Bluelib_${component}_INCLUDE_DIR - NAMES blue/${header_name}.h ${Bluelib_FIND_ARGS} - PATH_SUFFIXES include - PATHS ${Bluelib_SEARCH_PATHS}) - endif () - - if (NOT Bluelib_${component}_LIBRARY) - find_library(Bluelib_${component}_LIBRARY - NAMES blue-${lib_name} ${Bluelib_FIND_ARGS} - PATH_SUFFIXES lib - PATHS ${Bluelib_SEARCH_PATHS}) - else () - # on Windows, ensure paths are in canonical format (forward slahes): - file(TO_CMAKE_PATH "${Bluelib_${component}_LIBRARY}" Bluelib_${component}_LIBRARY) - endif() - - list(APPEND required_vars Bluelib_${component}_INCLUDE_DIR Bluelib_${component}_LIBRARY) -endforeach (component) - -unset(Bluelib_FIND_ARGS) - -include(FindPackageHandleStandardArgs) - -find_package_handle_standard_args(Bluelib - REQUIRED_VARS ${required_vars}) - -if (Bluelib_FOUND) - set(created_targets) - foreach (component ${components}) - string(TOLOWER ${component} header_name) - set(lib_name ${header_name}${_lib_suffix}) - - if(NOT TARGET Bluelib::${component}) - add_library(Bluelib::${component} UNKNOWN IMPORTED) - set_target_properties(Bluelib::${component} PROPERTIES - INTERFACE_INCLUDE_DIRECTORIES "${Bluelib_${component}_INCLUDE_DIR}") - target_compile_definitions(Bluelib::${component} INTERFACE _CRT_SECURE_NO_WARNINGS=1) - - if (Bluelib_STATIC) - target_compile_definitions(Bluelib::${component} INTERFACE BLUELIB_STATIC=1) - endif () - - set_target_properties(Bluelib::${component} PROPERTIES - IMPORTED_LINK_INTERFACE_LANGUAGES "C" - IMPORTED_LOCATION "${Bluelib_${component}_LIBRARY}") - set(created_targets ${created_targets} ${component}) - endif () - endforeach (component) - - foreach (component ${created_targets}) - if ("${component}" STREQUAL "Ds") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Ds' depends on 'Core', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Ds INTERFACE Bluelib::Core) - endif () - - if ("${component}" STREQUAL "Term") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Term' depends on 'Core', which was not specified in find_package()") - endif () - - if (NOT TARGET Bluelib::Ds) - message(FATAL_ERROR "Bluelib: Module 'Term' depends on 'Ds', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Term INTERFACE Bluelib::Core Bluelib::Ds) - endif () - - if ("${component}" STREQUAL "Serial") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Serial' depends on 'Core', which was not specified in find_package()") - endif () - - if (NOT TARGET Bluelib::Ds) - message(FATAL_ERROR "Bluelib: Module 'Serial' depends on 'Ds', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Serial INTERFACE Bluelib::Core Bluelib::Ds) - endif () - - if ("${component}" STREQUAL "Cmd") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Core', which was not specified in find_package()") - endif () - - if (NOT TARGET Bluelib::Ds) - message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Ds', which was not specified in find_package()") - endif () - - if (NOT TARGET Bluelib::Term) - message(FATAL_ERROR "Bluelib: Module 'Cmd' depends on 'Term', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Cmd INTERFACE Bluelib::Core Bluelib::Ds Bluelib::Term) - endif () - - if ("${component}" STREQUAL "Io") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Io' depends on 'Core', which was not specified in find_package()") - endif () - - if (NOT TARGET Bluelib::Ds) - message(FATAL_ERROR "Bluelib: Module 'Io' depends on 'Ds', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Io INTERFACE Bluelib::Core Bluelib::Ds) - endif () - - if ("${component}" STREQUAL "Compress") - if (NOT TARGET Bluelib::Core) - message(FATAL_ERROR "Bluelib: Module 'Compress' depends on 'Core', which was not specified in find_package()") - endif () - - target_link_libraries(Bluelib::Compress INTERFACE Bluelib::Core Bluelib::Ds) - endif () - endforeach (component) -endif() diff --git a/cmake/FindFX.cmake b/cmake/FindFX.cmake new file mode 100644 index 0000000..735ae13 --- /dev/null +++ b/cmake/FindFX.cmake @@ -0,0 +1,189 @@ +#[=======================================================================[.rst: +FindFX +------------ + +Find the FX library and header directories + +Imported Targets +^^^^^^^^^^^^^^^^ + +This module defines the following :prop_tgt:`IMPORTED` target: + +``FX::FX`` +The FX library, if found + +Result Variables +^^^^^^^^^^^^^^^^ + +This module will set the following variables in your project: + +``FX_FOUND`` +true if the FX C headers and libraries were found +``FX_INCLUDE_DIR`` +directories containing the FX C headers. + +``FX_LIBRARY`` +the C library to link against + +Hints +^^^^^ + +The user may set the environment variable ``FX_PREFIX`` to the root +directory of a FX library installation. +#]=======================================================================] + +set (FX_SEARCH_PATHS + ~/Library/Frameworks + /Library/Frameworks + /usr/local + /usr/local/share + /usr + /sw # Fink + /opt/local # DarwinPorts + /opt/csw # Blastwave + /opt + ${FX_PREFIX} + $ENV{FX_PREFIX}) + +if (FX_STATIC) + set(_lib_suffix "-s") +endif () + +set(supported_components Core Ds Term Cmd Io Serial Compress) +set(components ${FX_FIND_COMPONENTS}) +string(REPLACE ";" ", " supported_components_string_list "${supported_components}") + +if (NOT components) + set(components ${supported_components}) +endif () + +set(required_vars) + +foreach (component ${components}) + if (NOT "${component}" IN_LIST supported_components) + message(FATAL_ERROR "'${component}' is not a valid FX module.\nSupported modules: ${supported_components_string_list}") + endif () + + string(TOLOWER ${component} header_name) + set(lib_name ${header_name}${_lib_suffix}) + + if (NOT FX_${component}_INCLUDE_DIR) + find_path(FX_${component}_INCLUDE_DIR + NAMES fx/${header_name}.h ${FX_FIND_ARGS} + PATH_SUFFIXES include + PATHS ${FX_SEARCH_PATHS}) + endif () + + if (NOT FX_${component}_LIBRARY) + find_library(FX_${component}_LIBRARY + NAMES fx-${lib_name} ${FX_FIND_ARGS} + PATH_SUFFIXES lib + PATHS ${FX_SEARCH_PATHS}) + else () + # on Windows, ensure paths are in canonical format (forward slahes): + file(TO_CMAKE_PATH "${FX_${component}_LIBRARY}" FX_${component}_LIBRARY) + endif() + + list(APPEND required_vars FX_${component}_INCLUDE_DIR FX_${component}_LIBRARY) +endforeach (component) + +unset(FX_FIND_ARGS) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(FX + REQUIRED_VARS ${required_vars}) + +if (FX_FOUND) + set(created_targets) + foreach (component ${components}) + string(TOLOWER ${component} header_name) + set(lib_name ${header_name}${_lib_suffix}) + + if(NOT TARGET FX::${component}) + add_library(FX::${component} UNKNOWN IMPORTED) + set_target_properties(FX::${component} PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${FX_${component}_INCLUDE_DIR}") + target_compile_definitions(FX::${component} INTERFACE _CRT_SECURE_NO_WARNINGS=1) + + if (FX_STATIC) + target_compile_definitions(FX::${component} INTERFACE FX_STATIC=1) + endif () + + set_target_properties(FX::${component} PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${FX_${component}_LIBRARY}") + set(created_targets ${created_targets} ${component}) + endif () + endforeach (component) + + foreach (component ${created_targets}) + if ("${component}" STREQUAL "Ds") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Ds' depends on 'Core', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Ds INTERFACE FX::Core) + endif () + + if ("${component}" STREQUAL "Term") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Term' depends on 'Core', which was not specified in find_package()") + endif () + + if (NOT TARGET FX::Ds) + message(FATAL_ERROR "FX: Module 'Term' depends on 'Ds', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Term INTERFACE FX::Core FX::Ds) + endif () + + if ("${component}" STREQUAL "Serial") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Serial' depends on 'Core', which was not specified in find_package()") + endif () + + if (NOT TARGET FX::Ds) + message(FATAL_ERROR "FX: Module 'Serial' depends on 'Ds', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Serial INTERFACE FX::Core FX::Ds) + endif () + + if ("${component}" STREQUAL "Cmd") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Core', which was not specified in find_package()") + endif () + + if (NOT TARGET FX::Ds) + message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Ds', which was not specified in find_package()") + endif () + + if (NOT TARGET FX::Term) + message(FATAL_ERROR "FX: Module 'Cmd' depends on 'Term', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Cmd INTERFACE FX::Core FX::Ds FX::Term) + endif () + + if ("${component}" STREQUAL "Io") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Io' depends on 'Core', which was not specified in find_package()") + endif () + + if (NOT TARGET FX::Ds) + message(FATAL_ERROR "FX: Module 'Io' depends on 'Ds', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Io INTERFACE FX::Core FX::Ds) + endif () + + if ("${component}" STREQUAL "Compress") + if (NOT TARGET FX::Core) + message(FATAL_ERROR "FX: Module 'Compress' depends on 'Core', which was not specified in find_package()") + endif () + + target_link_libraries(FX::Compress INTERFACE FX::Core FX::Ds) + endif () + endforeach (component) +endif() diff --git a/mie/CMakeLists.txt b/mie/CMakeLists.txt index b56a1bb..b2fd804 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::Ds Bluelib::Io) +target_link_libraries(mie FX::Core FX::Ds FX::Io) target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${MIE_STATIC}) diff --git a/mie/attribute/attribute-definition.c b/mie/attribute/attribute-definition.c index 01398ef..54dabe0 100644 --- a/mie/attribute/attribute-definition.c +++ b/mie/attribute/attribute-definition.c @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -12,7 +12,7 @@ struct mie_attribute_definition *mie_attribute_definition_create( memset(out, 0x0, sizeof *out); - out->a_name = b_strdup(name); + out->a_name = fx_strdup(name); if (!out->a_name) { free(out); return NULL; @@ -20,7 +20,7 @@ struct mie_attribute_definition *mie_attribute_definition_create( out->a_parent = parent; - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&parent->d_attributes, &out->a_id, &name_rope); return out; diff --git a/mie/attribute/attribute-map.c b/mie/attribute/attribute-map.c index b33e265..9b5950b 100644 --- a/mie/attribute/attribute-map.c +++ b/mie/attribute/attribute-map.c @@ -1,6 +1,6 @@ -#include -#include -#include +#include +#include +#include #include enum attribute_map_entry_type { @@ -13,14 +13,14 @@ struct attribute_map_entry { enum attribute_map_entry_type e_type; uint64_t e_hash; union { - b_btree_node e_node; - b_queue_entry e_entry; + fx_bst_node e_node; + fx_queue_entry e_entry; }; }; struct attribute_map_bucket { struct attribute_map_entry b_base; - b_queue b_items; + fx_queue b_items; }; struct attribute_map_item { @@ -29,9 +29,9 @@ struct attribute_map_item { const struct mie_attribute *i_value; }; -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct attribute_map_entry, e_node, e_hash, put_entry); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct attribute_map_entry, uint64_t, e_node, e_hash, get_entry); void mie_attribute_map_init(struct mie_attribute_map *map) @@ -57,16 +57,16 @@ static const struct mie_attribute *get_attribute_from_item( static const struct mie_attribute *get_attribute_from_bucket( const struct attribute_map_bucket *bucket, const char *name) { - b_queue_entry *cur = b_queue_first(&bucket->b_items); + fx_queue_entry *cur = fx_queue_first(&bucket->b_items); while (cur) { - const struct attribute_map_item *item = b_unbox( + const struct attribute_map_item *item = fx_unbox( const struct attribute_map_item, cur, i_base.e_entry); if (!strcmp(item->i_name, name)) { return item->i_value; } - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } return NULL; @@ -90,7 +90,7 @@ static const struct mie_attribute *get_attribute_from_entry( const struct mie_attribute *mie_attribute_map_get( const struct mie_attribute_map *map, const char *name) { - uint64_t name_hash = b_hash_cstr(name); + uint64_t name_hash = fx_hash_cstr(name); struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash); if (!entry) { return NULL; @@ -107,13 +107,13 @@ static struct attribute_map_bucket *convert_item_to_bucket( return NULL; } - b_btree_delete(&map->m_entries, &item->i_base.e_node); + fx_bst_delete(&map->m_entries, &item->i_base.e_node); memset(bucket, 0x0, sizeof *bucket); bucket->b_base.e_type = ATTRMAP_ENTRY_BUCKET; bucket->b_base.e_hash = item->i_base.e_hash; - b_queue_push_back(&bucket->b_items, &item->i_base.e_entry); + fx_queue_push_back(&bucket->b_items, &item->i_base.e_entry); put_entry(&map->m_entries, &bucket->b_base); return bucket; @@ -132,7 +132,7 @@ static struct attribute_map_item *create_item( out->i_value = attrib; out->i_base.e_type = ATTRMAP_ENTRY_ITEM; out->i_base.e_hash = name_hash; - out->i_name = b_strdup(name); + out->i_name = fx_strdup(name); if (!out->i_name) { free(out); return NULL; @@ -145,7 +145,7 @@ enum mie_status mie_attribute_map_put( struct mie_attribute_map *map, const char *name, const struct mie_attribute *value, enum mie_attribute_map_flags flags) { - uint64_t name_hash = b_hash_cstr(name); + uint64_t name_hash = fx_hash_cstr(name); struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash); struct attribute_map_item *item = NULL; struct attribute_map_bucket *bucket = NULL; @@ -184,7 +184,7 @@ enum mie_status mie_attribute_map_put( return MIE_ERR_NO_MEMORY; } - b_queue_push_back(&bucket->b_items, &item->i_base.e_entry); + fx_queue_push_back(&bucket->b_items, &item->i_base.e_entry); return MIE_SUCCESS; } @@ -192,13 +192,13 @@ enum mie_status mie_attribute_map_iterator_begin( struct mie_attribute_map_iterator *it, const struct mie_attribute_map *map) { memset(it, 0x0, sizeof *it); - it->_n = b_btree_first(&map->m_entries); + it->_n = fx_bst_first(&map->m_entries); if (!it->_n) { return MIE_ERR_NO_DATA; } struct attribute_map_entry *entry - = b_unbox(struct attribute_map_entry, it->_n, e_node); + = fx_unbox(struct attribute_map_entry, it->_n, e_node); struct attribute_map_item *item = NULL; struct attribute_map_bucket *bucket = NULL; @@ -210,8 +210,8 @@ enum mie_status mie_attribute_map_iterator_begin( return MIE_SUCCESS; case ATTRMAP_ENTRY_BUCKET: bucket = (struct attribute_map_bucket *)entry; - it->_e = b_queue_first(&bucket->b_items); - item = b_unbox(struct attribute_map_item, it->_e, i_base.e_entry); + it->_e = fx_queue_first(&bucket->b_items); + item = fx_unbox(struct attribute_map_item, it->_e, i_base.e_entry); it->it_name = item->i_name; it->it_value = item->i_value; return MIE_SUCCESS; @@ -228,11 +228,11 @@ enum mie_status mie_attribute_map_iterator_move_next( struct attribute_map_bucket *next_bucket = NULL; if (it->_e) { - it->_e = b_queue_next(it->_e); - next_entry = b_unbox(struct attribute_map_entry, it->_e, e_entry); + it->_e = fx_queue_next(it->_e); + next_entry = fx_unbox(struct attribute_map_entry, it->_e, e_entry); } else if (it->_n) { - it->_n = b_btree_next(it->_n); - next_entry = b_unbox(struct attribute_map_entry, it->_n, e_node); + it->_n = fx_bst_next(it->_n); + next_entry = fx_unbox(struct attribute_map_entry, it->_n, e_node); } else { memset(it, 0x0, sizeof *it); return MIE_ERR_NO_DATA; @@ -249,8 +249,8 @@ enum mie_status mie_attribute_map_iterator_move_next( break; case ATTRMAP_ENTRY_BUCKET: next_bucket = (struct attribute_map_bucket *)next_item; - it->_e = b_queue_first(&next_bucket->b_items); - next_item = b_unbox( + it->_e = fx_queue_first(&next_bucket->b_items); + next_item = fx_unbox( struct attribute_map_item, it->_e, i_base.e_entry); break; default: diff --git a/mie/ctx.c b/mie/ctx.c index 7204bda..c9e560d 100644 --- a/mie/ctx.c +++ b/mie/ctx.c @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -140,123 +140,123 @@ bool mie_ctx_resolve_op(const struct mie_ctx *ctx, struct mie_op *op) struct mie_dialect *mie_ctx_get_dialect(const struct mie_ctx *ctx, const char *name) { - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_dialects), &name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - return b_unbox(struct mie_dialect, target, d_id); + return fx_unbox(struct mie_dialect, target, d_id); } const struct mie_op_definition *mie_ctx_get_op_definition( const struct mie_ctx *ctx, const char *dialect_name, const char *op_name) { - b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); + fx_rope dialect_name_rope = FX_ROPE_CSTR(dialect_name); mie_id id; mie_id_init_ns( &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id); + struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id); if (!dialect) { return NULL; } - b_rope op_name_rope = B_ROPE_CSTR(op_name); + fx_rope op_name_rope = FX_ROPE_CSTR(op_name); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &op_name_rope); target = mie_id_map_get(&dialect->d_ops, &id); - return b_unbox(struct mie_op_definition, target, op_id); + return fx_unbox(struct mie_op_definition, target, op_id); } struct mie_type_definition *mie_ctx_get_type_definition( const struct mie_ctx *ctx, const char *dialect_name, const char *type_name) { - b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); + fx_rope dialect_name_rope = FX_ROPE_CSTR(dialect_name); mie_id id; mie_id_init_ns( &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id); + struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id); if (!dialect) { return NULL; } - b_rope type_name_rope = B_ROPE_CSTR(type_name); + fx_rope type_name_rope = FX_ROPE_CSTR(type_name); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &type_name_rope); target = mie_id_map_get(&dialect->d_types, &id); - return b_unbox(struct mie_type_definition, target, ty_id); + return fx_unbox(struct mie_type_definition, target, ty_id); } const struct mie_trait_definition *mie_ctx_get_trait_definition( const struct mie_ctx *ctx, const char *dialect_name, const char *trait_name) { - b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); + fx_rope dialect_name_rope = FX_ROPE_CSTR(dialect_name); mie_id id; mie_id_init_ns( &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id); + struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id); if (!dialect) { return NULL; } - b_rope trait_name_rope = B_ROPE_CSTR(trait_name); + fx_rope trait_name_rope = FX_ROPE_CSTR(trait_name); mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_traits), &trait_name_rope); target = mie_id_map_get(&dialect->d_traits, &id); - return b_unbox(struct mie_trait_definition, target, tr_id); + return fx_unbox(struct mie_trait_definition, target, tr_id); } const struct mie_attribute_definition *mie_ctx_get_attribute_definition( const struct mie_ctx *ctx, const char *dialect_name, const char *attribute_name) { - b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); + fx_rope dialect_name_rope = FX_ROPE_CSTR(dialect_name); mie_id id; mie_id_init_ns( &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id); + struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id); if (!dialect) { return NULL; } - b_rope attribute_name_rope = B_ROPE_CSTR(attribute_name); + fx_rope attribute_name_rope = FX_ROPE_CSTR(attribute_name); mie_id_init_ns( &id, mie_id_map_get_ns(&dialect->d_attributes), &attribute_name_rope); target = mie_id_map_get(&dialect->d_attributes, &id); - return b_unbox(struct mie_attribute_definition, target, a_id); + return fx_unbox(struct mie_attribute_definition, target, a_id); } const struct mie_interface_definition *mie_ctx_get_interface_definition( const struct mie_ctx *ctx, const char *dialect_name, const char *interface_name) { - b_rope dialect_name_rope = B_ROPE_CSTR(dialect_name); + fx_rope dialect_name_rope = FX_ROPE_CSTR(dialect_name); mie_id id; mie_id_init_ns( &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); - struct mie_dialect *dialect = b_unbox(struct mie_dialect, target, d_id); + struct mie_dialect *dialect = fx_unbox(struct mie_dialect, target, d_id); if (!dialect) { return NULL; } - b_rope interface_name_rope = B_ROPE_CSTR(interface_name); + fx_rope interface_name_rope = FX_ROPE_CSTR(interface_name); mie_id_init_ns( &id, mie_id_map_get_ns(&dialect->d_interfaces), &interface_name_rope); target = mie_id_map_get(&dialect->d_interfaces, &id); - return b_unbox(struct mie_interface_definition, target, if_id); + return fx_unbox(struct mie_interface_definition, target, if_id); } struct mie_type *mie_ctx_get_type( @@ -264,13 +264,13 @@ struct mie_type *mie_ctx_get_type( { char full_name[256]; snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, type_name); - b_rope full_name_rope = B_ROPE_CSTR(full_name); + fx_rope full_name_rope = FX_ROPE_CSTR(full_name); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &full_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); - struct mie_type *type = b_unbox(struct mie_type, target, ty_id); + struct mie_type *type = fx_unbox(struct mie_type, target, ty_id); if (type) { return type; } @@ -295,7 +295,7 @@ struct mie_type *mie_ctx_get_type( memset(type, 0x0, sizeof *type); type->ty_def = type_info; - type->ty_name = b_bstr_fmt(NULL, "%s.%s", dialect_name, type_name); + type->ty_name = fx_bstr_fmt(NULL, "%s.%s", dialect_name, type_name); if (type_info->ty_init) { type_info->ty_init(type_info, type); @@ -311,13 +311,13 @@ const struct mie_trait *mie_ctx_get_trait( { char full_name[256]; snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, trait_name); - b_rope full_name_rope = B_ROPE_CSTR(full_name); + fx_rope full_name_rope = FX_ROPE_CSTR(full_name); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_traits), &full_name_rope); mie_id *target = mie_id_map_get(&ctx->ctx_traits, &id); - struct mie_trait *trait = b_unbox(struct mie_trait, target, tr_id); + struct mie_trait *trait = fx_unbox(struct mie_trait, target, tr_id); if (trait) { return trait; } @@ -342,7 +342,7 @@ const struct mie_trait *mie_ctx_get_trait( memset(trait, 0x0, sizeof trait_info->tr_data_size); trait->tr_def = trait_info; - trait->tr_name = b_bstr_fmt(NULL, "%s.%s", dialect_name, trait_name); + trait->tr_name = fx_bstr_fmt(NULL, "%s.%s", dialect_name, trait_name); if (trait_info->tr_init) { trait_info->tr_init(trait_info, trait); @@ -363,7 +363,7 @@ struct mie_type *mie_ctx_get_storage_type( mie_id_builder_end(&id_builder, &id); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); - struct mie_type *type = b_unbox(struct mie_type, target, ty_id); + struct mie_type *type = fx_unbox(struct mie_type, target, ty_id); if (type) { return type; } @@ -389,7 +389,7 @@ struct mie_type *mie_ctx_get_function_type( mie_id_builder_end(&id_builder, &id); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); - struct mie_type *type = b_unbox(struct mie_type, target, ty_id); + struct mie_type *type = fx_unbox(struct mie_type, target, ty_id); if (type) { return type; } @@ -456,7 +456,7 @@ enum mie_status mie_ctx_get_pass( } struct mie_pass_definition *pass_def - = b_unbox(struct mie_pass_definition, target, p_id); + = fx_unbox(struct mie_pass_definition, target, p_id); if (pass_def->p_data_size < sizeof(struct mie_pass)) { return MIE_ERR_BAD_STATE; @@ -511,17 +511,17 @@ struct mie_diag *mie_ctx_push_diag( diag->diag_parent = dialect; diag->diag_class = &dialect->d_diag_classes[diag_class]; - b_queue_push_back(&ctx->ctx_diag, &diag->diag_entry); + fx_queue_push_back(&ctx->ctx_diag, &diag->diag_entry); return diag; } struct mie_diag *mie_ctx_pop_diag(struct mie_ctx *ctx) { - b_queue_entry *entry = b_queue_pop_front(&ctx->ctx_diag); + fx_queue_entry *entry = fx_queue_pop_front(&ctx->ctx_diag); if (!entry) { return NULL; } - return b_unbox(struct mie_diag, entry, diag_entry); + return fx_unbox(struct mie_diag, entry, diag_entry); } diff --git a/mie/diag/diag.c b/mie/diag/diag.c index c533167..80127af 100644 --- a/mie/diag/diag.c +++ b/mie/diag/diag.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -19,7 +19,7 @@ struct mie_diag_c_msg *diag_msg_create(const struct mie_diag_msg *content) memset(out, 0x0, sizeof *out); out->msg_base.c_type = MIE_DIAG_COMPONENT_MSG; - out->msg_content = b_strdup(content->msg_content); + out->msg_content = fx_strdup(content->msg_content); return out; } @@ -91,7 +91,7 @@ void mie_diag_push_msg( return; } - b_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry); + fx_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry); } void mie_diag_push_string(struct mie_diag *diag, const char *str) @@ -103,9 +103,9 @@ void mie_diag_push_string(struct mie_diag *diag, const char *str) memset(c_msg, 0x0, sizeof *c_msg); c_msg->msg_base.c_type = MIE_DIAG_COMPONENT_MSG; - c_msg->msg_content = b_strdup(str); + c_msg->msg_content = fx_strdup(str); - b_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry); + fx_queue_push_back(&diag->diag_components, &c_msg->msg_base.c_entry); } void mie_diag_push_snippet( @@ -120,5 +120,5 @@ void mie_diag_push_snippet( return; } - b_queue_push_back(&diag->diag_components, &c_snippet->s_base.c_entry); + fx_queue_push_back(&diag->diag_components, &c_snippet->s_base.c_entry); } diff --git a/mie/diag/diag.h b/mie/diag/diag.h index d091022..9873912 100644 --- a/mie/diag/diag.h +++ b/mie/diag/diag.h @@ -1,6 +1,6 @@ #ifndef _DIAG_DIAG_H_ #define _DIAG_DIAG_H_ -#include +#include #endif diff --git a/mie/dialect/arith/float-cache.c b/mie/dialect/arith/float-cache.c index 2d6c16b..e8b9193 100644 --- a/mie/dialect/arith/float-cache.c +++ b/mie/dialect/arith/float-cache.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -10,19 +10,19 @@ typedef union float_key { } float_key; struct float_width_cache_entry { - b_btree_node e_node; + fx_bst_node e_node; float_key e_key; struct mie_float e_value; }; struct float_width_cache { - b_btree_node c_node; + fx_bst_node c_node; size_t c_width; - b_btree c_floats; + fx_bst c_floats; }; struct mie_float_cache { - b_btree c_widths; + fx_bst c_widths; }; static int float_key_compare(const float_key *a, const float_key *b) @@ -30,38 +30,38 @@ static int float_key_compare(const float_key *a, const float_key *b) return memcmp(a->i, b->i, sizeof a->i); } -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct float_width_cache, c_node, c_width, put_width_cache); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct float_width_cache, size_t, c_node, c_width, get_width_cache); -void put_float(b_btree *tree, struct float_width_cache_entry *node) +void put_float(fx_bst *tree, struct float_width_cache_entry *node) { - if (!tree->b_root) { - tree->b_root = &node->e_node; - b_btree_insert_fixup(tree, &node->e_node); + if (!tree->bst_root) { + tree->bst_root = &node->e_node; + fx_bst_insert_fixup(tree, &node->e_node); return; } - b_btree_node *cur = tree->b_root; + fx_bst_node *cur = tree->bst_root; while (1) { struct float_width_cache_entry *cur_node - = b_unbox(struct float_width_cache_entry, cur, e_node); - b_btree_node *next = NULL; + = fx_unbox(struct float_width_cache_entry, cur, e_node); + fx_bst_node *next = NULL; int cmp = float_key_compare(&node->e_key, &cur_node->e_key); if (cmp >= 0) { - next = b_btree_right(cur); + next = fx_bst_right(cur); if (!next) { - b_btree_put_right(cur, &node->e_node); + fx_bst_put_right(cur, &node->e_node); break; } } else if (cmp < 0) { - next = b_btree_left(cur); + next = fx_bst_left(cur); if (!next) { - b_btree_put_left(cur, &node->e_node); + fx_bst_put_left(cur, &node->e_node); break; } } else { @@ -71,20 +71,20 @@ void put_float(b_btree *tree, struct float_width_cache_entry *node) cur = next; } - b_btree_insert_fixup(tree, &node->e_node); + fx_bst_insert_fixup(tree, &node->e_node); } -static struct float_width_cache_entry *get_float(const b_btree *tree, float_key key) +static struct float_width_cache_entry *get_float(const fx_bst *tree, float_key key) { - b_btree_node *cur = tree->b_root; + fx_bst_node *cur = tree->bst_root; while (cur) { struct float_width_cache_entry *cur_node - = b_unbox(struct float_width_cache_entry, cur, e_node); + = fx_unbox(struct float_width_cache_entry, cur, e_node); int cmp = float_key_compare(&key, &cur_node->e_key); if (cmp > 0) { - cur = b_btree_right(cur); + cur = fx_bst_right(cur); } else if (cmp < 0) { - cur = b_btree_left(cur); + cur = fx_bst_left(cur); } else { return cur_node; } @@ -109,13 +109,13 @@ static struct float_width_cache *float_width_cache_create(size_t width) static void float_width_cache_destroy(struct float_width_cache *cache) { - b_btree_node *cur = b_btree_first(&cache->c_floats); + fx_bst_node *cur = fx_bst_first(&cache->c_floats); while (cur) { - b_btree_node *next = b_btree_next(cur); - b_btree_delete(&cache->c_floats, cur); + fx_bst_node *next = fx_bst_next(cur); + fx_bst_delete(&cache->c_floats, cur); struct float_width_cache_entry *entry - = b_unbox(struct float_width_cache_entry, cur, e_node); + = fx_unbox(struct float_width_cache_entry, cur, e_node); free(entry); cur = next; @@ -170,13 +170,13 @@ struct mie_float_cache *mie_float_cache_create(void) void mie_float_cache_destroy(struct mie_float_cache *cache) { - b_btree_node *cur = b_btree_first(&cache->c_widths); + fx_bst_node *cur = fx_bst_first(&cache->c_widths); while (cur) { - b_btree_node *next = b_btree_next(cur); - b_btree_delete(&cache->c_widths, cur); + fx_bst_node *next = fx_bst_next(cur); + fx_bst_delete(&cache->c_widths, cur); struct float_width_cache *width_cache - = b_unbox(struct float_width_cache, cur, c_node); + = fx_unbox(struct float_width_cache, cur, c_node); float_width_cache_destroy(width_cache); cur = next; diff --git a/mie/dialect/arith/int-cache.c b/mie/dialect/arith/int-cache.c index d769865..0ffe29b 100644 --- a/mie/dialect/arith/int-cache.c +++ b/mie/dialect/arith/int-cache.c @@ -1,32 +1,32 @@ -#include +#include #include #include #include #include struct int_width_cache_entry { - b_btree_node e_node; + fx_bst_node e_node; struct mie_int e_value; }; struct int_width_cache { - b_btree_node c_node; + fx_bst_node c_node; size_t c_width; - b_btree c_ints; + fx_bst c_ints; }; struct mie_int_cache { - b_btree c_widths; + fx_bst c_widths; }; -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct int_width_cache, c_node, c_width, put_width_cache); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct int_width_cache, size_t, c_node, c_width, get_width_cache); -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct int_width_cache_entry, e_node, e_value.i_val.v_small, put_int); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct int_width_cache_entry, uint64_t, e_node, e_value.i_val.v_small, get_int); @@ -46,13 +46,13 @@ static struct int_width_cache *int_width_cache_create(size_t width) static void int_width_cache_destroy(struct int_width_cache *cache) { - b_btree_node *cur = b_btree_first(&cache->c_ints); + fx_bst_node *cur = fx_bst_first(&cache->c_ints); while (cur) { - b_btree_node *next = b_btree_next(cur); - b_btree_delete(&cache->c_ints, cur); + fx_bst_node *next = fx_bst_next(cur); + fx_bst_delete(&cache->c_ints, cur); struct int_width_cache_entry *entry - = b_unbox(struct int_width_cache_entry, cur, e_node); + = fx_unbox(struct int_width_cache_entry, cur, e_node); free(entry); cur = next; @@ -96,13 +96,13 @@ struct mie_int_cache *mie_int_cache_create(void) void mie_int_cache_destroy(struct mie_int_cache *cache) { - b_btree_node *cur = b_btree_first(&cache->c_widths); + fx_bst_node *cur = fx_bst_first(&cache->c_widths); while (cur) { - b_btree_node *next = b_btree_next(cur); - b_btree_delete(&cache->c_widths, cur); + fx_bst_node *next = fx_bst_next(cur); + fx_bst_delete(&cache->c_widths, cur); struct int_width_cache *width_cache - = b_unbox(struct int_width_cache, cur, c_node); + = fx_unbox(struct int_width_cache, cur, c_node); int_width_cache_destroy(width_cache); cur = next; diff --git a/mie/dialect/arith/op/addf.c b/mie/dialect/arith/op/addf.c index 6d8d474..61e3686 100644 --- a/mie/dialect/arith/op/addf.c +++ b/mie/dialect/arith/op/addf.c @@ -17,11 +17,11 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o const struct mie_op_arg *left = &op->op_args.items[0]; const struct mie_op_arg *right = &op->op_args.items[1]; - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_op_arg(printer, left, false); - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); mie_printer_print_op_arg(printer, right, false); - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); mie_printer_print_type(printer, mie_op_arg_get_type(left)); return MIE_SUCCESS; diff --git a/mie/dialect/arith/op/addi.c b/mie/dialect/arith/op/addi.c index fa98a3e..6a185aa 100644 --- a/mie/dialect/arith/op/addi.c +++ b/mie/dialect/arith/op/addi.c @@ -19,11 +19,11 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o const struct mie_op_arg *left = &op->op_args.items[0]; const struct mie_op_arg *right = &op->op_args.items[1]; - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_op_arg(printer, left, false); - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); mie_printer_print_op_arg(printer, right, false); - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); mie_printer_print_type(printer, mie_op_arg_get_type(left)); return MIE_SUCCESS; diff --git a/mie/dialect/arith/op/cmpi.c b/mie/dialect/arith/op/cmpi.c index df9f20f..092be43 100644 --- a/mie/dialect/arith/op/cmpi.c +++ b/mie/dialect/arith/op/cmpi.c @@ -47,19 +47,19 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o return MIE_SUCCESS; } - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); if (pred < 0 || pred >= nr_predicates) { return MIE_ERR_BAD_STATE; } - b_stream_write_string(printer->p_stream, predicates[pred], NULL); + fx_stream_write_string(printer->p_stream, predicates[pred], NULL); - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_op_arg(printer, left, false); - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); mie_printer_print_op_arg(printer, right, false); - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); mie_printer_print_type(printer, mie_op_arg_get_type(left)); return MIE_SUCCESS; @@ -79,14 +79,14 @@ static enum mie_status parse( return MIE_ERR_BAD_SYNTAX; } - b_string *tmp = mie_parser_get_tempstr(parser); + fx_string *tmp = mie_parser_get_tempstr(parser); if (!mie_parser_parse_word(parser, tmp, &span)) { mie_parser_report_unexpected_token_s( parser, "predicate word", "comparison operation"); return MIE_ERR_BAD_SYNTAX; } - int pred = find_predicate(b_string_ptr(tmp)); + int pred = find_predicate(fx_string_ptr(tmp)); if (pred == -1) { struct mie_diag *diag = mie_parser_report_error_simple( parser, "arith", MIE_ARITH_E_INVALID_COMPARISON_PREDICATE, diff --git a/mie/dialect/arith/op/constant.c b/mie/dialect/arith/op/constant.c index c426048..862be57 100644 --- a/mie/dialect/arith/op/constant.c +++ b/mie/dialect/arith/op/constant.c @@ -21,14 +21,14 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o const struct mie_type *type = NULL; if (mie_attribute_check_name(value, "builtin", "int")) { const struct mie_int *i = (const struct mie_int *)value; - b_stream_write_fmt( + fx_stream_write_fmt( printer->p_stream, NULL, " %lld : ", i->i_val.v_small); type = i->i_type; } else if (mie_attribute_check_name(value, "builtin", "float")) { const struct mie_float *f = (const struct mie_float *)value; double d; mie_float_get_value(value, &d); - b_stream_write_fmt(printer->p_stream, NULL, " %g : ", d); + fx_stream_write_fmt(printer->p_stream, NULL, " %g : ", d); type = f->f_type; } else { return MIE_SUCCESS; diff --git a/mie/dialect/builtin/attribute/array.c b/mie/dialect/builtin/attribute/array.c index 76ae04c..0d74638 100644 --- a/mie/dialect/builtin/attribute/array.c +++ b/mie/dialect/builtin/attribute/array.c @@ -13,27 +13,27 @@ static enum mie_status print( const struct mie_array *array = (const struct mie_array *)value; if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_string(out->p_stream, "#builtin.array<", NULL); + fx_stream_write_string(out->p_stream, "#builtin.array<", NULL); } - b_stream_write_char(out->p_stream, '['); + fx_stream_write_char(out->p_stream, '['); for (size_t i = 0; i < MIE_VECTOR_COUNT(array->a_items); i++) { if (i > 0) { - b_stream_write_char(out->p_stream, ','); + fx_stream_write_char(out->p_stream, ','); } - b_stream_write_char(out->p_stream, ' '); + fx_stream_write_char(out->p_stream, ' '); mie_printer_print_attribute(out, array->a_items.items[i]); } if (MIE_VECTOR_COUNT(array->a_items) != 0) { - b_stream_write_char(out->p_stream, ' '); + fx_stream_write_char(out->p_stream, ' '); } - b_stream_write_char(out->p_stream, ']'); + fx_stream_write_char(out->p_stream, ']'); if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_char(out->p_stream, '>'); + fx_stream_write_char(out->p_stream, '>'); } return MIE_SUCCESS; diff --git a/mie/dialect/builtin/attribute/float.c b/mie/dialect/builtin/attribute/float.c index fc2564e..2791853 100644 --- a/mie/dialect/builtin/attribute/float.c +++ b/mie/dialect/builtin/attribute/float.c @@ -1,6 +1,6 @@ #include "../float.h" -#include +#include #include #include #include @@ -17,28 +17,28 @@ static enum mie_status print( const struct float_type *float_ty = (const struct float_type *)float_val->f_type; if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_string(out->p_stream, "#builtin.float<", NULL); + fx_stream_write_string(out->p_stream, "#builtin.float<", NULL); } switch (float_ty->f_width) { case MIE_FLOAT_32: - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "%f : f%zu", float_val->f_val.v_32, float_ty->f_width); break; case MIE_FLOAT_64: - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "%lf : f%zu", float_val->f_val.v_64, float_ty->f_width); break; default: - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "NaN : f%zu", float_ty->f_width); break; } if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_string(out->p_stream, ">", NULL); + fx_stream_write_string(out->p_stream, ">", NULL); } return MIE_SUCCESS; diff --git a/mie/dialect/builtin/attribute/int.c b/mie/dialect/builtin/attribute/int.c index 8902f2b..dbe08c3 100644 --- a/mie/dialect/builtin/attribute/int.c +++ b/mie/dialect/builtin/attribute/int.c @@ -1,6 +1,6 @@ #include "../int.h" -#include +#include #include #include #include @@ -18,32 +18,32 @@ static enum mie_status print( bool abbrev = ((out->p_flags & MIE_PRINT_F_ABBREVIATED) != 0); if (!abbrev) { - b_stream_write_string(out->p_stream, "#builtin.int<", NULL); + fx_stream_write_string(out->p_stream, "#builtin.int<", NULL); } if (int_ty->i_width <= 64) { - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "%zu", int_val->i_val.v_small, int_ty->i_width); } else { - b_stream_write_fmt(out->p_stream, NULL, "INF", int_ty->i_width); + fx_stream_write_fmt(out->p_stream, NULL, "INF", int_ty->i_width); } if (int_ty->i_width != 64 || !abbrev) { - b_stream_write_string(out->p_stream, " : ", NULL); + fx_stream_write_string(out->p_stream, " : ", NULL); if (abbrev) { - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "i%zu", int_ty->i_width); } else { - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "!builtin.int<%zu>", int_ty->i_width); } } if (!abbrev) { - b_stream_write_string(out->p_stream, ">", NULL); + fx_stream_write_string(out->p_stream, ">", NULL); } return MIE_SUCCESS; diff --git a/mie/dialect/builtin/attribute/string.c b/mie/dialect/builtin/attribute/string.c index b1df28d..380f955 100644 --- a/mie/dialect/builtin/attribute/string.c +++ b/mie/dialect/builtin/attribute/string.c @@ -11,9 +11,9 @@ static enum mie_status print( { const struct mie_string *str = (const struct mie_string *)value; if (out->p_flags & MIE_PRINT_F_ABBREVIATED) { - b_stream_write_fmt(out->p_stream, NULL, "\"%s\"", str->str_val); + fx_stream_write_fmt(out->p_stream, NULL, "\"%s\"", str->str_val); } else { - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "#builtin.string<\"%s\">", str->str_val); } @@ -23,14 +23,14 @@ static enum mie_status print( static enum mie_status parse( struct mie_parser *ctx, const struct mie_attribute **out) { - b_string *str = mie_parser_get_tempstr(ctx); + fx_string *str = mie_parser_get_tempstr(ctx); struct mie_file_span span; if (!mie_parser_parse_string(ctx, str, &span)) { return MIE_ERR_BAD_SYNTAX; } struct mie_attribute *v = mie_ctx_get_string( - mie_parser_get_mie_ctx(ctx), b_string_ptr(str)); + mie_parser_get_mie_ctx(ctx), fx_string_ptr(str)); if (!v) { return MIE_ERR_NO_MEMORY; diff --git a/mie/dialect/builtin/attribute/type.c b/mie/dialect/builtin/attribute/type.c index b0040c2..07590d2 100644 --- a/mie/dialect/builtin/attribute/type.c +++ b/mie/dialect/builtin/attribute/type.c @@ -30,13 +30,13 @@ static enum mie_status print( const struct mie_type_attr *ty = (const struct mie_type_attr *)value; if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_string(out->p_stream, "#builtin.type<", NULL); + fx_stream_write_string(out->p_stream, "#builtin.type<", NULL); } mie_printer_print_type(out, ty->ty_value); if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { - b_stream_write_char(out->p_stream, '>'); + fx_stream_write_char(out->p_stream, '>'); } return MIE_SUCCESS; diff --git a/mie/dialect/builtin/diag.c b/mie/dialect/builtin/diag.c index 70428f6..82d6ed1 100644 --- a/mie/dialect/builtin/diag.c +++ b/mie/dialect/builtin/diag.c @@ -31,6 +31,7 @@ MIE_DIAG_CLASS_LIST_END(mie_builtin_diag) MIE_DIAG_MSG_LIST_BEGIN(mie_builtin_msg) MIE_DIAG_MSG(UNRECOGNISED_TOKEN, "encountered an unrecognised token.") + MIE_DIAG_MSG(UNEXPECTED_TOKEN, "encountered an unexpected token.") MIE_DIAG_MSG(UNRESOLVED_VALUE, "cannot resolve this value reference.") MIE_DIAG_MSG( UNRESOLVED_BUILTIN_TYPE, diff --git a/mie/dialect/builtin/index-cache.c b/mie/dialect/builtin/index-cache.c index 3c6666c..0bedbe7 100644 --- a/mie/dialect/builtin/index-cache.c +++ b/mie/dialect/builtin/index-cache.c @@ -1,21 +1,21 @@ -#include +#include #include #include #include #include struct index_cache_entry { - b_btree_node e_node; + fx_bst_node e_node; struct mie_index e_value; }; struct mie_index_cache { - b_btree c_entries; + fx_bst c_entries; }; -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct index_cache_entry, e_node, e_value.i_value, put_index); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct index_cache_entry, size_t, e_node, e_value.i_value, get_index); static struct index_cache_entry *index_cache_entry_create( @@ -48,13 +48,13 @@ struct mie_index_cache *mie_index_cache_create(void) void mie_index_cache_destroy(struct mie_index_cache *cache) { - b_btree_node *cur = b_btree_first(&cache->c_entries); + fx_bst_node *cur = fx_bst_first(&cache->c_entries); while (cur) { - b_btree_node *next = b_btree_next(cur); - b_btree_delete(&cache->c_entries, cur); + fx_bst_node *next = fx_bst_next(cur); + fx_bst_delete(&cache->c_entries, cur); struct index_cache_entry *entry - = b_unbox(struct index_cache_entry, cur, e_node); + = fx_unbox(struct index_cache_entry, cur, e_node); free(entry); cur = next; diff --git a/mie/dialect/builtin/op/module.c b/mie/dialect/builtin/op/module.c index 6af7da0..d6e5b83 100644 --- a/mie/dialect/builtin/op/module.c +++ b/mie/dialect/builtin/op/module.c @@ -9,7 +9,7 @@ static enum mie_status print(struct mie_printer *out, const struct mie_op *op) { - b_stream_write_char(out->p_stream, ' '); + fx_stream_write_char(out->p_stream, ' '); struct mie_region *region = mie_op_get_first_region(op); if (region) { diff --git a/mie/dialect/builtin/string-cache.c b/mie/dialect/builtin/string-cache.c index 0106861..cce3d38 100644 --- a/mie/dialect/builtin/string-cache.c +++ b/mie/dialect/builtin/string-cache.c @@ -1,12 +1,12 @@ -#include -#include +#include +#include #include #include #include #include struct mie_string_cache { - b_hashmap *c_entries; + fx_hashmap *c_entries; }; static struct mie_string *mie_string_create( @@ -19,7 +19,7 @@ static struct mie_string *mie_string_create( out->str_base.a_def = mie_ctx_get_attribute_definition(ctx, "builtin", "string"); - out->str_val = b_strdup(s); + out->str_val = fx_strdup(s); if (!out->str_val) { return NULL; } @@ -42,8 +42,8 @@ struct mie_string_cache *mie_string_cache_create(void) memset(out, 0x0, sizeof *out); - out->c_entries = b_hashmap_create( - NULL, (b_hashmap_value_destructor)mie_string_destroy); + out->c_entries = fx_hashmap_create( + NULL, (fx_hashmap_value_destructor)mie_string_destroy); if (!out->c_entries) { free(out); return NULL; @@ -54,7 +54,7 @@ struct mie_string_cache *mie_string_cache_create(void) void mie_string_cache_destroy(struct mie_string_cache *cache) { - b_hashmap_unref(cache->c_entries); + fx_hashmap_unref(cache->c_entries); free(cache); } @@ -62,8 +62,8 @@ struct mie_string *mie_string_cache_get( struct mie_string_cache *cache, struct mie_ctx *ctx, const char *s) { size_t s_len = strlen(s); - b_hashmap_key key = {.key_data = s, .key_size = s_len}; - const b_hashmap_value *value = b_hashmap_get(cache->c_entries, &key); + fx_hashmap_key key = {.key_data = s, .key_size = s_len}; + const fx_hashmap_value *value = fx_hashmap_get(cache->c_entries, &key); if (value) { return value->value_data; } @@ -73,8 +73,8 @@ struct mie_string *mie_string_cache_get( return NULL; } - b_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str}; - b_hashmap_put(cache->c_entries, &key, &new_val); + fx_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str}; + fx_hashmap_put(cache->c_entries, &key, &new_val); return str; } diff --git a/mie/dialect/builtin/type/float.c b/mie/dialect/builtin/type/float.c index e44ddbd..2eca82e 100644 --- a/mie/dialect/builtin/type/float.c +++ b/mie/dialect/builtin/type/float.c @@ -1,6 +1,6 @@ #include "../float.h" -#include +#include #include #include #include @@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width) return NULL; } - b_rope rope_i = B_ROPE_CHAR('f'), rope_width = B_ROPE_UINT(bit_width); - b_rope type_name; - b_rope_concat(&type_name, &rope_i, &rope_width); + fx_rope rope_i = FX_ROPE_CHAR('f'), rope_width = FX_ROPE_UINT(bit_width); + fx_rope type_name; + fx_rope_concat(&type_name, &rope_i, &rope_width); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); if (target) { - return b_unbox(struct mie_type, target, ty_id); + return fx_unbox(struct mie_type, target, ty_id); } struct float_type *type = (struct float_type *)mie_type_create(type_info); @@ -34,7 +34,7 @@ struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width) return NULL; } - type->f_base.ty_name = b_bstr_fmt(NULL, "builtin.float<%zu>", bit_width); + type->f_base.ty_name = fx_bstr_fmt(NULL, "builtin.float<%zu>", bit_width); type->f_base.ty_instance_size = sizeof(struct mie_float); type->f_width = bit_width; @@ -59,7 +59,7 @@ size_t mie_float_type_get_width(const struct mie_type *type) static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { const struct float_type *float_type = (const struct float_type *)ty; - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" : "!builtin.float<%zu>", float_type->f_width); diff --git a/mie/dialect/builtin/type/int.c b/mie/dialect/builtin/type/int.c index b58b605..783ab89 100644 --- a/mie/dialect/builtin/type/int.c +++ b/mie/dialect/builtin/type/int.c @@ -1,6 +1,6 @@ #include "../int.h" -#include +#include #include #include #include @@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width) return NULL; } - b_rope rope_i = B_ROPE_CHAR('i'), rope_width = B_ROPE_UINT(bit_width); - b_rope type_name; - b_rope_concat(&type_name, &rope_i, &rope_width); + fx_rope rope_i = FX_ROPE_CHAR('i'), rope_width = FX_ROPE_UINT(bit_width); + fx_rope type_name; + fx_rope_concat(&type_name, &rope_i, &rope_width); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); if (target) { - return b_unbox(struct mie_type, target, ty_id); + return fx_unbox(struct mie_type, target, ty_id); } struct int_type *type = (struct int_type *)mie_type_create(type_info); @@ -34,7 +34,7 @@ struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width) return NULL; } - type->i_base.ty_name = b_bstr_fmt(NULL, "builtin.int<%zu>", bit_width); + type->i_base.ty_name = fx_bstr_fmt(NULL, "builtin.int<%zu>", bit_width); type->i_base.ty_instance_size = sizeof(struct mie_int); type->i_width = bit_width; @@ -59,7 +59,7 @@ size_t mie_int_type_get_width(const struct mie_type *type) static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { const struct int_type *int_type = (const struct int_type *)ty; - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu" : "!builtin.int<%zu>", diff --git a/mie/dialect/builtin/type/memref.c b/mie/dialect/builtin/type/memref.c index 3ddcbbb..d53d5a6 100644 --- a/mie/dialect/builtin/type/memref.c +++ b/mie/dialect/builtin/type/memref.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -48,7 +48,7 @@ struct mie_type *mie_ctx_get_memref_type( mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); if (target) { - return b_unbox(struct mie_type, target, ty_id); + return fx_unbox(struct mie_type, target, ty_id); } struct memref_type *type @@ -57,40 +57,40 @@ struct mie_type *mie_ctx_get_memref_type( return NULL; } - b_bstr type_name; - b_bstr_begin_dynamic(&type_name); - b_bstr_write_cstr(&type_name, "builtin.memref<", NULL); + fx_bstr type_name; + fx_bstr_begin_dynamic(&type_name); + fx_bstr_write_cstr(&type_name, "builtin.memref<", NULL); struct mie_printer printer; mie_printer_init( - &printer, ctx, (b_stream *)&type_name, MIE_PRINT_F_ABBREVIATED); + &printer, ctx, (fx_stream *)&type_name, MIE_PRINT_F_ABBREVIATED); for (size_t i = 0; i < nr_ranks; i++) { mie_vector_push_back(type->m_rank, &ranks[i], NULL); if (i > 0) { - b_bstr_write_char(&type_name, '*'); + fx_bstr_write_char(&type_name, '*'); } switch (ranks[i].r_ranktype) { case MIE_MEMREF_RANK_UNKNOWN: - b_bstr_write_char(&type_name, '?'); + fx_bstr_write_char(&type_name, '?'); break; case MIE_MEMREF_RANK_TYPE: mie_printer_print_type(&printer, ranks[i].r_type); break; case MIE_MEMREF_RANK_STATIC: - b_bstr_write_fmt(&type_name, NULL, "%zu", ranks[i].r_static); + fx_bstr_write_fmt(&type_name, NULL, "%zu", ranks[i].r_static); break; default: break; } } - b_bstr_write_char(&type_name, '>'); - type->m_base.ty_name = b_bstr_end(&type_name); + fx_bstr_write_char(&type_name, '>'); + type->m_base.ty_name = fx_bstr_end(&type_name); type->m_base.ty_instance_size = 0; - b_rope name_rope = B_ROPE_CSTR(type->m_base.ty_name); + fx_rope name_rope = FX_ROPE_CSTR(type->m_base.ty_name); mie_id_map_put(&ctx->ctx_types, &type->m_base.ty_id, &name_rope); return (struct mie_type *)type; @@ -104,36 +104,36 @@ static void type_init( static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { const struct memref_type *memref_ty = (const struct memref_type *)ty; - b_stream_write_string( + fx_stream_write_string( out->p_stream, (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "memref" : "builtin.memref", NULL); - b_stream_write_char(out->p_stream, '<'); + fx_stream_write_char(out->p_stream, '<'); for (size_t i = 0; i < MIE_VECTOR_COUNT(memref_ty->m_rank); i++) { const struct mie_memref_rank *rank = &memref_ty->m_rank.items[i]; if (i > 0) { - b_stream_write_char(out->p_stream, '*'); + fx_stream_write_char(out->p_stream, '*'); } switch (rank->r_ranktype) { case MIE_MEMREF_RANK_UNKNOWN: - b_stream_write_char(out->p_stream, '?'); + fx_stream_write_char(out->p_stream, '?'); break; case MIE_MEMREF_RANK_TYPE: mie_printer_print_type(out, rank->r_type); break; case MIE_MEMREF_RANK_STATIC: - b_stream_write_fmt( + fx_stream_write_fmt( out->p_stream, NULL, "%zu", rank->r_static); break; default: break; } } - b_stream_write_char(out->p_stream, '>'); + fx_stream_write_char(out->p_stream, '>'); return MIE_SUCCESS; } diff --git a/mie/dialect/builtin/type/string.c b/mie/dialect/builtin/type/string.c index 0545d43..45c728f 100644 --- a/mie/dialect/builtin/type/string.c +++ b/mie/dialect/builtin/type/string.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -15,7 +15,7 @@ static void type_init( static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) { - b_stream_write_string( + fx_stream_write_string( out->p_stream, (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "str" : "!builtin.string", NULL); diff --git a/mie/dialect/cf/op/br-cond.c b/mie/dialect/cf/op/br-cond.c index 98a7b48..cfeac2f 100644 --- a/mie/dialect/cf/op/br-cond.c +++ b/mie/dialect/cf/op/br-cond.c @@ -21,11 +21,11 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o const struct mie_op_successor *if_true = &op->op_successors.items[0]; const struct mie_op_successor *if_false = &op->op_successors.items[1]; - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_op_arg(printer, cond, false); - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); mie_printer_print_op_successor(printer, if_true, true); - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); mie_printer_print_op_successor(printer, if_false, true); return MIE_SUCCESS; @@ -34,7 +34,7 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out) { memset(out, 0x0, sizeof *out); - b_string *str = mie_parser_get_tempstr(ctx); + fx_string *str = mie_parser_get_tempstr(ctx); bool result = false; if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { @@ -43,7 +43,7 @@ static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out return false; } - out->s_block_name = b_string_steal(str); + out->s_block_name = fx_string_steal(str); if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED || mie_parser_peek_symbol(ctx) == MIE_SYM_COMMA) { diff --git a/mie/dialect/cf/op/br.c b/mie/dialect/cf/op/br.c index 2101e81..0746ca9 100644 --- a/mie/dialect/cf/op/br.c +++ b/mie/dialect/cf/op/br.c @@ -9,7 +9,7 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); const struct mie_op_successor *successor = &op->op_successors.items[0]; mie_printer_print_op_successor(printer, successor, true); @@ -20,7 +20,7 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out) { memset(out, 0x0, sizeof *out); - b_string *str = mie_parser_get_tempstr(ctx); + fx_string *str = mie_parser_get_tempstr(ctx); bool result = false; if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { @@ -29,7 +29,7 @@ static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out return false; } - out->s_block_name = b_string_steal(str); + out->s_block_name = fx_string_steal(str); if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED) { goto ok; diff --git a/mie/dialect/dialect.c b/mie/dialect/dialect.c index 6c74a3b..7a8a19f 100644 --- a/mie/dialect/dialect.c +++ b/mie/dialect/dialect.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -37,7 +37,7 @@ struct mie_dialect *mie_dialect_create( memset(out, 0x0, size); - out->d_name = b_strdup(name); + out->d_name = fx_strdup(name); if (!out->d_name) { free(out); return NULL; @@ -58,7 +58,7 @@ struct mie_dialect *mie_dialect_create( mie_id interface_ns = INTERFACE_NS_ID; mie_id_map_init(&out->d_interfaces, &interface_ns); - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&ctx->ctx_dialects, &out->d_id, &name_rope); return out; @@ -67,21 +67,21 @@ struct mie_dialect *mie_dialect_create( const struct mie_op_definition *mie_dialect_get_op( const struct mie_dialect *dialect, const char *name) { - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &name_rope); mie_id *target = mie_id_map_get(&dialect->d_ops, &id); - return b_unbox(struct mie_op_definition, target, op_id); + return fx_unbox(struct mie_op_definition, target, op_id); } const struct mie_type_definition *mie_dialect_get_type( const struct mie_dialect *dialect, const char *name) { - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id id; mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &name_rope); mie_id *target = mie_id_map_get(&dialect->d_types, &id); - return b_unbox(struct mie_type_definition, target, ty_id); + return fx_unbox(struct mie_type_definition, target, ty_id); } diff --git a/mie/dialect/func/op/func.c b/mie/dialect/func/op/func.c index 4a4531d..b1e54c0 100644 --- a/mie/dialect/func/op/func.c +++ b/mie/dialect/func/op/func.c @@ -28,14 +28,14 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o const struct mie_function_type *function_ty = (const struct mie_function_type *)function_type_g; - b_stream_write_fmt(printer->p_stream, NULL, " @%s(", sym_name_cstr); + fx_stream_write_fmt(printer->p_stream, NULL, " @%s(", sym_name_cstr); const struct mie_region *code = mie_op_get_first_region(op); const struct mie_block *entry = mie_region_get_first_block(code); for (size_t i = 0; i < MIE_VECTOR_COUNT(entry->b_params); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } const struct mie_register *param = &entry->b_params.items[i]; @@ -43,15 +43,15 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o mie_printer_print_register(printer, param, MIE_PRINT_F_INCLUDE_TYPE); } - b_stream_write_string(printer->p_stream, ") -> ", NULL); + fx_stream_write_string(printer->p_stream, ") -> ", NULL); if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) { - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); } for (size_t i = 0; i < MIE_VECTOR_COUNT(function_ty->func_out); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } const struct mie_type *ty = function_ty->func_out.items[i]; @@ -60,10 +60,10 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o } if (MIE_VECTOR_COUNT(function_ty->func_out) != 1) { - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_region( printer, code, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER); @@ -107,7 +107,7 @@ static enum mie_status parse( return MIE_ERR_BAD_SYNTAX; } - b_string *temp = mie_parser_get_tempstr(parser); + fx_string *temp = mie_parser_get_tempstr(parser); if (!mie_parser_parse_symname(parser, temp, NULL)) { mie_parser_report_unexpected_token( parser, MIE_TOK_SYMNAME, "function signature"); @@ -115,7 +115,7 @@ static enum mie_status parse( } struct mie_attribute *sym_name = mie_ctx_get_string( - mie_parser_get_mie_ctx(parser), b_string_ptr(temp)); + mie_parser_get_mie_ctx(parser), fx_string_ptr(temp)); if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_PAREN)) { mie_parser_report_unexpected_token( diff --git a/mie/dialect/func/op/return.c b/mie/dialect/func/op/return.c index 6933dd8..77afb5e 100644 --- a/mie/dialect/func/op/return.c +++ b/mie/dialect/func/op/return.c @@ -15,21 +15,21 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_arg(printer, &op->op_args.items[i], false); } - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_type( diff --git a/mie/dialect/memref/op/load.c b/mie/dialect/memref/op/load.c index 7667ffb..5875bd8 100644 --- a/mie/dialect/memref/op/load.c +++ b/mie/dialect/memref/op/load.c @@ -13,26 +13,26 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); const struct mie_type *memref_type = NULL; if (MIE_VECTOR_COUNT(op->op_args) > 0) { mie_printer_print_op_arg(printer, &op->op_args.items[0], false); memref_type = mie_op_arg_get_type(&op->op_args.items[0]); } - b_stream_write_char(printer->p_stream, '['); + fx_stream_write_char(printer->p_stream, '['); for (size_t i = 1; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 1) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_arg(printer, &op->op_args.items[i], false); } - b_stream_write_char(printer->p_stream, ']'); + fx_stream_write_char(printer->p_stream, ']'); if (memref_type) { - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); mie_printer_print_type(printer, memref_type); } @@ -43,14 +43,14 @@ static bool parse_param_name( struct mie_parser *ctx, struct mie_op_arg *out, const char *context) { memset(out, 0x0, sizeof *out); - b_string *str = mie_parser_get_tempstr(ctx); + fx_string *str = mie_parser_get_tempstr(ctx); struct mie_file_span loc; if (mie_parser_parse_vregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL; } else if (mie_parser_parse_mregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE; } else { struct mie_parser_item required[] = { diff --git a/mie/dialect/scf/op/for.c b/mie/dialect/scf/op/for.c index e52fe4f..8ba958b 100644 --- a/mie/dialect/scf/op/for.c +++ b/mie/dialect/scf/op/for.c @@ -40,35 +40,35 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o ub = &op->op_args.items[1]; step = &op->op_args.items[2]; - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_register(printer, iv, 0); - b_stream_write_string(printer->p_stream, " = ", NULL); + fx_stream_write_string(printer->p_stream, " = ", NULL); mie_printer_print_op_arg(printer, lb, 0); - b_stream_write_string(printer->p_stream, " to ", NULL); + fx_stream_write_string(printer->p_stream, " to ", NULL); mie_printer_print_op_arg(printer, ub, 0); - b_stream_write_string(printer->p_stream, " step ", NULL); + fx_stream_write_string(printer->p_stream, " step ", NULL); mie_printer_print_op_arg(printer, step, 0); if (MIE_VECTOR_COUNT(entry->b_params) > 1) { - b_stream_write_string(printer->p_stream, " iter-args(", NULL); + fx_stream_write_string(printer->p_stream, " iter-args(", NULL); for (size_t i = 1; i < MIE_VECTOR_COUNT(entry->b_params); i++) { if (i > 1) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_register( printer, &entry->b_params.items[i], 0); - b_stream_write_string(printer->p_stream, " = ", NULL); + fx_stream_write_string(printer->p_stream, " = ", NULL); mie_printer_print_op_arg( printer, &op->op_args.items[i + 2], false); } - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } if (MIE_VECTOR_COUNT(op->op_result) > 0) { - b_stream_write_string(printer->p_stream, " -> ", NULL); + fx_stream_write_string(printer->p_stream, " -> ", NULL); if (MIE_VECTOR_COUNT(op->op_result) > 1) { - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); } for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { @@ -77,11 +77,11 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o } if (MIE_VECTOR_COUNT(op->op_result) > 1) { - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } } - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_region( printer, body, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER); diff --git a/mie/dialect/scf/op/if.c b/mie/dialect/scf/op/if.c index 52cbc9a..5504a78 100644 --- a/mie/dialect/scf/op/if.c +++ b/mie/dialect/scf/op/if.c @@ -8,30 +8,30 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); mie_printer_print_op_arg(printer, &op->op_args.items[0], false); if (MIE_VECTOR_COUNT(op->op_result) > 0) { - b_stream_write_string(printer->p_stream, " -> ", NULL); + fx_stream_write_string(printer->p_stream, " -> ", NULL); if (MIE_VECTOR_COUNT(op->op_result) > 1) { - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); } } for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_type(printer, op->op_result.items[i].reg_type); } if (MIE_VECTOR_COUNT(op->op_result) > 1) { - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); } - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); struct mie_region *if_region = mie_op_get_first_region(op); struct mie_region *else_region = mie_op_get_next_region(op, if_region); @@ -39,7 +39,7 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o mie_printer_print_region(printer, if_region, 0); if (else_region) { - b_stream_write_string(printer->p_stream, " else ", NULL); + fx_stream_write_string(printer->p_stream, " else ", NULL); mie_printer_print_region(printer, else_region, 0); } diff --git a/mie/dialect/scf/op/yield.c b/mie/dialect/scf/op/yield.c index cf66be9..9d37684 100644 --- a/mie/dialect/scf/op/yield.c +++ b/mie/dialect/scf/op/yield.c @@ -9,20 +9,20 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, ' '); + fx_stream_write_char(printer->p_stream, ' '); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_arg(printer, &op->op_args.items[i], false); } - b_stream_write_string(printer->p_stream, " : ", NULL); + fx_stream_write_string(printer->p_stream, " : ", NULL); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_type( diff --git a/mie/id.c b/mie/id.c index 6b9329e..f48ff21 100644 --- a/mie/id.c +++ b/mie/id.c @@ -1,7 +1,7 @@ -#include -#include -#include -#include +#include +#include +#include +#include #include #include @@ -10,18 +10,18 @@ static inline int id_memcmp(const uint8_t *a, const uint8_t *b) return memcmp(a, b, MIE_ID_NR_BYTES); } -static mie_id *get_id(const b_btree *tree, mie_id *key) +static mie_id *get_id(const fx_bst *tree, mie_id *key) { - b_btree_node *cur = tree->b_root; + fx_bst_node *cur = tree->bst_root; while (cur) { - mie_id *cur_node = b_unbox(mie_id, cur, e_node); + mie_id *cur_node = fx_unbox(mie_id, cur, e_node); int cmp = memcmp( key->id_bytes, cur_node->id_bytes, sizeof key->id_bytes); if (cmp > 0) { - cur = b_btree_right(cur); + cur = fx_bst_right(cur); } else if (cmp < 0) { - cur = b_btree_left(cur); + cur = fx_bst_left(cur); } else { return cur_node; } @@ -30,33 +30,33 @@ static mie_id *get_id(const b_btree *tree, mie_id *key) return NULL; } -void put_id(b_btree *tree, mie_id *node) +void put_id(fx_bst *tree, mie_id *node) { - if (!tree->b_root) { - tree->b_root = &node->e_node; - b_btree_insert_fixup(tree, &node->e_node); + if (!tree->bst_root) { + tree->bst_root = &node->e_node; + fx_bst_insert_fixup(tree, &node->e_node); return; } - b_btree_node *cur = tree->b_root; + fx_bst_node *cur = tree->bst_root; while (1) { - mie_id *cur_node = b_unbox(mie_id, cur, e_node); - b_btree_node *next = NULL; + mie_id *cur_node = fx_unbox(mie_id, cur, e_node); + fx_bst_node *next = NULL; int cmp = memcmp( node->id_bytes, cur_node->id_bytes, sizeof node->id_bytes); if (cmp > 0) { - next = b_btree_right(cur); + next = fx_bst_right(cur); if (!next) { - b_btree_put_right(cur, &node->e_node); + fx_bst_put_right(cur, &node->e_node); break; } } else if (cmp < 0) { - next = b_btree_left(cur); + next = fx_bst_left(cur); if (!next) { - b_btree_put_left(cur, &node->e_node); + fx_bst_put_left(cur, &node->e_node); break; } } else { @@ -66,17 +66,17 @@ void put_id(b_btree *tree, mie_id *node) cur = next; } - b_btree_insert_fixup(tree, &node->e_node); + fx_bst_insert_fixup(tree, &node->e_node); } void mie_id_init( mie_id *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d, uint64_t e) { - b_i32 x_a = b_i32_htob(a); - b_i16 x_b = b_i16_htob(b); - b_i16 x_c = b_i16_htob(c); - b_i16 x_d = b_i16_htob(d); - b_i64 x_e = b_i64_htob(e); + fx_i32 x_a = fx_i32_htob(a); + fx_i16 x_b = fx_i16_htob(b); + fx_i16 x_c = fx_i16_htob(c); + fx_i16 x_d = fx_i16_htob(d); + fx_i64 x_e = fx_i64_htob(e); memcpy(&out->id_bytes[0], x_a.i_bytes, sizeof x_a.i_bytes); memcpy(&out->id_bytes[4], x_b.i_bytes, sizeof x_b.i_bytes); @@ -92,12 +92,12 @@ void mie_id_init_zero(mie_id *out) void mie_id_init_random(mie_id *out) { - b_random_ctx *random = b_random_global_ctx(); - b_random_next_bytes( + fx_random_ctx *random = fx_random_global_ctx(); + fx_random_next_bytes( random, (unsigned char *)out->id_bytes, sizeof out->id_bytes); } -void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name) +void mie_id_init_ns(mie_id *out, const mie_id *ns, const fx_rope *name) { struct mie_id_builder ctx; mie_id_builder_begin(&ctx, ns); @@ -107,45 +107,45 @@ void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name) void mie_id_to_string(const mie_id *id, char *out, size_t max) { - b_bstr str; - b_bstr_begin(&str, out, max); + fx_bstr str; + fx_bstr_begin(&str, out, max); for (size_t i = 0; i < sizeof id->id_bytes; i++) { if (i == 4 || i == 6 || i == 8 || i == 10) { - b_bstr_write_char(&str, '-'); + fx_bstr_write_char(&str, '-'); } - b_bstr_write_fmt(&str, NULL, "%02x", id->id_bytes[i]); + fx_bstr_write_fmt(&str, NULL, "%02x", id->id_bytes[i]); } } void mie_id_builder_begin(struct mie_id_builder *builder, const mie_id *ns) { memset(builder, 0x0, sizeof *builder); - b_hash_ctx_init(&builder->b_hash, B_HASH_SHA1); - b_hash_ctx_update(&builder->b_hash, ns->id_bytes, sizeof ns->id_bytes); + fx_hash_ctx_init(&builder->b_hash, FX_HASH_SHA1); + fx_hash_ctx_update(&builder->b_hash, ns->id_bytes, sizeof ns->id_bytes); } void mie_id_builder_add(struct mie_id_builder *builder, const void *p, size_t len) { - b_hash_ctx_update(&builder->b_hash, p, len); + fx_hash_ctx_update(&builder->b_hash, p, len); } -void mie_id_builder_add_rope(struct mie_id_builder *builder, const b_rope *rope) +void mie_id_builder_add_rope(struct mie_id_builder *builder, const fx_rope *rope) { - b_hash_ctx_update_rope(&builder->b_hash, rope); + fx_hash_ctx_update_rope(&builder->b_hash, rope); } void mie_id_builder_add_marker( struct mie_id_builder *builder, enum mie_id_builder_marker marker) { unsigned char c = marker; - b_hash_ctx_update(&builder->b_hash, &c, sizeof c); + fx_hash_ctx_update(&builder->b_hash, &c, sizeof c); } void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out) { memset(out, 0x0, sizeof *out); - b_hash_ctx_finish(&builder->b_hash, out->id_bytes, sizeof out->id_bytes); + fx_hash_ctx_finish(&builder->b_hash, out->id_bytes, sizeof out->id_bytes); out->id_bytes[6] &= 0x0F; out->id_bytes[6] |= 0x50; @@ -166,7 +166,7 @@ const mie_id *mie_id_map_get_ns(const struct mie_id_map *map) return &map->map_ns_id; } -void mie_id_map_put(struct mie_id_map *map, mie_id *id, const b_rope *name) +void mie_id_map_put(struct mie_id_map *map, mie_id *id, const fx_rope *name) { mie_id_init_ns(id, &map->map_ns_id, name); put_id(&map->map_entries, id); @@ -187,13 +187,13 @@ enum mie_status mie_id_map_iterator_begin( { memset(it, 0x0, sizeof *it); - it->_n = b_btree_first(&map->map_entries); + it->_n = fx_bst_first(&map->map_entries); if (!it->_n) { return MIE_ERR_NO_DATA; } - it->it_id = b_unbox(mie_id, it->_n, e_node); + it->it_id = fx_unbox(mie_id, it->_n, e_node); return MIE_SUCCESS; } @@ -205,13 +205,13 @@ enum mie_status mie_id_map_iterator_move_next(struct mie_id_map_iterator *it) return MIE_ERR_NO_DATA; } - it->_n = b_btree_next(it->_n); + it->_n = fx_bst_next(it->_n); if (!it->_n) { it->it_id = NULL; return MIE_ERR_NO_DATA; } - it->it_id = b_unbox(mie_id, it->_n, e_node); + it->it_id = fx_unbox(mie_id, it->_n, e_node); return MIE_SUCCESS; } diff --git a/mie/include/mie/attribute/attribute-map.h b/mie/include/mie/attribute/attribute-map.h index aba6ac0..a35a6f9 100644 --- a/mie/include/mie/attribute/attribute-map.h +++ b/mie/include/mie/attribute/attribute-map.h @@ -1,14 +1,14 @@ #ifndef MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_ #define MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_ -#include +#include #include #include -struct b_queue_entry; +struct fx_queue_entry; struct mie_attribute_map { - b_btree m_entries; + fx_bst m_entries; }; enum mie_attribute_map_flags { @@ -18,8 +18,8 @@ enum mie_attribute_map_flags { struct mie_attribute_map_iterator { const char *it_name; const struct mie_attribute *it_value; - b_btree_node *_n; - struct b_queue_entry *_e; + fx_bst_node *_n; + struct fx_queue_entry *_e; }; MIE_API void mie_attribute_map_init(struct mie_attribute_map *map); @@ -27,7 +27,7 @@ MIE_API void mie_attribute_map_cleanup(struct mie_attribute_map *map); static inline bool mie_attribute_map_empty(const struct mie_attribute_map *map) { - return b_btree_empty(&map->m_entries); + return fx_bst_empty(&map->m_entries); } MIE_API const struct mie_attribute *mie_attribute_map_get( diff --git a/mie/include/mie/ctx.h b/mie/include/mie/ctx.h index d5f6a69..2b5b83c 100644 --- a/mie/include/mie/ctx.h +++ b/mie/include/mie/ctx.h @@ -1,8 +1,8 @@ #ifndef MIE_CTX_H_ #define MIE_CTX_H_ -#include -#include +#include +#include #include struct mie_op; @@ -21,8 +21,8 @@ struct mie_ctx { struct mie_const *ctx_true, *ctx_false; struct mie_value *ctx_null; struct mie_type *ctx_types[__MIE_TYPE_COUNT]; - b_hashmap *ctx_sel_cache; - b_hashmap *ctx_string_cache; + fx_hashmap *ctx_sel_cache; + fx_hashmap *ctx_string_cache; #endif /* map of struct mie_dialect */ struct mie_id_map ctx_dialects; @@ -35,7 +35,7 @@ struct mie_ctx { /* map of struct mie_pass_definition */ struct mie_id_map ctx_passes; /* queue of struct mie_diag */ - b_queue ctx_diag; + fx_queue ctx_diag; }; MIE_API struct mie_ctx *mie_ctx_create(void); diff --git a/mie/include/mie/diag/component.h b/mie/include/mie/diag/component.h index 01a3fc1..384d067 100644 --- a/mie/include/mie/diag/component.h +++ b/mie/include/mie/diag/component.h @@ -1,7 +1,7 @@ #ifndef MIE_DIAG_COMPONENT_H_ #define MIE_DIAG_COMPONENT_H_ -#include +#include #include enum mie_diag_component_type { @@ -12,7 +12,7 @@ enum mie_diag_component_type { struct mie_diag_component { enum mie_diag_component_type c_type; - b_queue_entry c_entry; + fx_queue_entry c_entry; }; struct mie_diag_c_snippet { diff --git a/mie/include/mie/diag/diag.h b/mie/include/mie/diag/diag.h index 913ba76..479bdd7 100644 --- a/mie/include/mie/diag/diag.h +++ b/mie/include/mie/diag/diag.h @@ -1,7 +1,7 @@ #ifndef MIE_DIAG_DIAG_H_ #define MIE_DIAG_DIAG_H_ -#include +#include #include #define MIE_DIAG_HL(type, span) \ @@ -55,8 +55,8 @@ struct mie_diag { struct mie_line_source *diag_src; struct mie_file_cell diag_loc; - b_queue_entry diag_entry; - b_queue diag_components; + fx_queue_entry diag_entry; + fx_queue diag_components; }; MIE_API void mie_diag_set_location( diff --git a/mie/include/mie/dialect/builtin.h b/mie/include/mie/dialect/builtin.h index 74f3838..37528f1 100644 --- a/mie/include/mie/dialect/builtin.h +++ b/mie/include/mie/dialect/builtin.h @@ -1,7 +1,7 @@ #ifndef MIE_DIALECT_BUILTIN_H_ #define MIE_DIALECT_BUILTIN_H_ -#include +#include #include #include #include diff --git a/mie/include/mie/dialect/dialect.h b/mie/include/mie/dialect/dialect.h index e154e98..636a45c 100644 --- a/mie/include/mie/dialect/dialect.h +++ b/mie/include/mie/dialect/dialect.h @@ -1,8 +1,8 @@ #ifndef MIE_DIALECT_DIALECT_H_ #define MIE_DIALECT_DIALECT_H_ -#include -#include +#include +#include #include #include #include diff --git a/mie/include/mie/id.h b/mie/include/mie/id.h index 4f59bf7..c6922f8 100644 --- a/mie/include/mie/id.h +++ b/mie/include/mie/id.h @@ -1,9 +1,9 @@ #ifndef MIE_ID_H_ #define MIE_ID_H_ -#include -#include -#include +#include +#include +#include #include #include #include @@ -42,30 +42,30 @@ typedef struct mie_id { }; union { - b_btree_node e_node; - b_queue_entry e_entry; + fx_bst_node e_node; + fx_queue_entry e_entry; }; } mie_id; struct mie_id_builder { - b_hash_ctx b_hash; + fx_hash_ctx b_hash; }; struct mie_id_map { mie_id map_ns_id; - b_btree map_entries; + fx_bst map_entries; }; struct mie_id_map_iterator { mie_id *it_id; - b_btree_node *_n; + fx_bst_node *_n; }; MIE_API void mie_id_init( mie_id *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d, uint64_t e); MIE_API void mie_id_init_zero(mie_id *out); MIE_API void mie_id_init_random(mie_id *out); -MIE_API void mie_id_init_ns(mie_id *out, const mie_id *ns, const b_rope *name); +MIE_API void mie_id_init_ns(mie_id *out, const mie_id *ns, const fx_rope *name); static inline int mie_id_compare(const mie_id *a, const mie_id *b) { @@ -99,7 +99,7 @@ static inline void mie_id_builder_add_int( mie_id_builder_add(builder, s, len); } MIE_API void mie_id_builder_add_rope( - struct mie_id_builder *builder, const b_rope *rope); + struct mie_id_builder *builder, const fx_rope *rope); MIE_API void mie_id_builder_add_marker( struct mie_id_builder *builder, enum mie_id_builder_marker marker); MIE_API void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out); @@ -107,12 +107,12 @@ MIE_API void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out); MIE_API void mie_id_map_init(struct mie_id_map *map, const mie_id *ns); static inline bool mie_id_map_empty(const struct mie_id_map *map) { - return b_btree_empty(&map->map_entries); + return fx_bst_empty(&map->map_entries); } MIE_API const mie_id *mie_id_map_get_ns(const struct mie_id_map *map); MIE_API void mie_id_map_put( - struct mie_id_map *map, mie_id *node, const b_rope *name); + struct mie_id_map *map, mie_id *node, const fx_rope *name); MIE_API void mie_id_map_put_id(struct mie_id_map *map, mie_id *node); MIE_API mie_id *mie_id_map_get(const struct mie_id_map *map, mie_id *id); diff --git a/mie/include/mie/ir/block.h b/mie/include/mie/ir/block.h index 0455784..9eba360 100644 --- a/mie/include/mie/ir/block.h +++ b/mie/include/mie/ir/block.h @@ -1,7 +1,7 @@ #ifndef MIE_IR_BLOCK_H_ #define MIE_IR_BLOCK_H_ -#include +#include #include #include #include @@ -26,11 +26,11 @@ struct mie_block { unsigned int b_id; struct mie_block *b_idom; // struct mie_block *b_sdom, *b_dfs_parent; - b_queue_entry b_entry; + fx_queue_entry b_entry; MIE_VECTOR_DECLARE(struct mie_register, b_params); /* queue of struct mie_op */ - b_queue b_ops; + fx_queue b_ops; }; extern struct mie_vector_ops mie_block_vector_ops; diff --git a/mie/include/mie/ir/op-definition.h b/mie/include/mie/ir/op-definition.h index c7a08ab..014bee9 100644 --- a/mie/include/mie/ir/op-definition.h +++ b/mie/include/mie/ir/op-definition.h @@ -1,8 +1,8 @@ #ifndef MIE_IR_OP_DEFINITION_H_ #define MIE_IR_OP_DEFINITION_H_ -#include -#include +#include +#include #include #include #include diff --git a/mie/include/mie/ir/op.h b/mie/include/mie/ir/op.h index 4ea346c..c56dc79 100644 --- a/mie/include/mie/ir/op.h +++ b/mie/include/mie/ir/op.h @@ -52,7 +52,7 @@ struct mie_op_successor { struct mie_op { enum mie_op_flags op_flags; /* used by struct mie_block */ - b_queue_entry op_entry; + fx_queue_entry op_entry; struct mie_line_source *op_src; /* this pointer is only valid if the F_OP_RESOLVED flag is set */ @@ -63,7 +63,7 @@ struct mie_op { /* only valid if the F_RESOLVED flag is NOT set */ char *op_name; - b_queue op_regions; + fx_queue op_regions; MIE_VECTOR_DECLARE(struct mie_op_successor, op_successors); struct mie_attribute_map op_attrib; diff --git a/mie/include/mie/ir/region.h b/mie/include/mie/ir/region.h index 557357b..9574ef0 100644 --- a/mie/include/mie/ir/region.h +++ b/mie/include/mie/ir/region.h @@ -1,8 +1,8 @@ #ifndef MIE_IR_REGION_H_ #define MIE_IR_REGION_H_ -#include -#include +#include +#include #include #include #include @@ -15,12 +15,12 @@ struct mie_region { struct mie_name_map *r_names; struct mie_op *r_parent; /* used by struct mie_op */ - b_queue_entry r_entry; + fx_queue_entry r_entry; /* queue of struct mie_block */ - b_queue r_blocks; + fx_queue r_blocks; /* bst of struct mie_block, as numbered by a depth-first search. * this ordering is recalculated by mie_region_refresh_dominance */ - b_btree r_blocks_s; + fx_bst r_blocks_s; }; MIE_API struct mie_block *mie_region_get_first_block( @@ -45,8 +45,8 @@ MIE_API struct mie_register *mie_region_find_register( * this function populates the following attributes of every block in the * region: * b_id - * b_node - * b_parent + * fx_node + * fx_parent * as well as the following attributes of the region itself: * r_blocks_s * only top-level blocks and ops are considered by this function. if an op diff --git a/mie/include/mie/ir/register.h b/mie/include/mie/ir/register.h index d24f240..51fffdc 100644 --- a/mie/include/mie/ir/register.h +++ b/mie/include/mie/ir/register.h @@ -30,7 +30,7 @@ struct mie_register_ref { /* represents a use of/resolved reference to a mie_register */ struct mie_register_use { - b_queue_entry u_entry; + fx_queue_entry u_entry; struct mie_op *u_user; struct mie_register *u_reg; }; @@ -59,7 +59,7 @@ struct mie_register { struct mie_op *reg_op; /* list of struct mie_register_use, representing all the places * where this register is used. */ - b_queue reg_use; + fx_queue reg_use; }; extern struct mie_vector_ops mie_register_vector_ops; diff --git a/mie/include/mie/ir/walk.h b/mie/include/mie/ir/walk.h index 0b2ee40..58976f8 100644 --- a/mie/include/mie/ir/walk.h +++ b/mie/include/mie/ir/walk.h @@ -1,7 +1,7 @@ #ifndef MIE_IR_WALK_H_ #define MIE_IR_WALK_H_ -#include +#include #include #include #include @@ -35,7 +35,7 @@ enum mie_walk_item_type { struct mie_walk_item { int _f; - b_queue_entry _e; + fx_queue_entry _e; enum mie_walk_item_type i_type; // size_t i_index; size_t i_depth; @@ -50,7 +50,7 @@ struct mie_walker { enum mie_walker_flags w_flags; union { /* used for recursive walks */ - b_queue w_stack; + fx_queue w_stack; /* used for non-recursive walks */ struct { struct mie_walk_item w_region, w_block, w_op; diff --git a/mie/include/mie/name.h b/mie/include/mie/name.h index 1c06410..8ba534d 100644 --- a/mie/include/mie/name.h +++ b/mie/include/mie/name.h @@ -1,8 +1,8 @@ #ifndef MIE_NAME_H_ #define MIE_NAME_H_ -#include -#include +#include +#include #include #include @@ -30,14 +30,14 @@ struct mie_name_map_entry { enum mie_name_map_entry_type e_type; uint64_t e_hash; union { - b_queue_entry e_entry; - b_btree_node e_node; + fx_queue_entry e_entry; + fx_bst_node e_node; }; }; struct mie_name_bucket { struct mie_name_map_entry b_base; - b_queue b_names; + fx_queue b_names; }; /* stores a unique name, and forms a binary tree of similar entries. @@ -64,7 +64,7 @@ struct mie_name { struct mie_name_map { const struct mie_name_map *m_parent; - b_btree m_entries; + fx_bst m_entries; size_t m_next_id; }; diff --git a/mie/include/mie/parse/lex.h b/mie/include/mie/parse/lex.h index 7c37101..4167799 100644 --- a/mie/include/mie/parse/lex.h +++ b/mie/include/mie/parse/lex.h @@ -1,8 +1,8 @@ #ifndef MIE_PARSE_LEX_H_ #define MIE_PARSE_LEX_H_ -#include -#include +#include +#include #include #include diff --git a/mie/include/mie/parse/line-source.h b/mie/include/mie/parse/line-source.h index abbb7e0..d2d3859 100644 --- a/mie/include/mie/parse/line-source.h +++ b/mie/include/mie/parse/line-source.h @@ -1,34 +1,34 @@ #ifndef MIE_PARSE_LINE_SOURCE_H_ #define MIE_PARSE_LINE_SOURCE_H_ -#include -#include -#include +#include +#include +#include #include #include #include struct mie_line_source { - b_stream *s_stream; + fx_stream *s_stream; const char *s_path; - b_string *s_linebuf; - b_iterator *s_linebuf_ptr; - b_array *s_lines; + fx_string *s_linebuf; + fx_iterator *s_linebuf_ptr; + fx_array *s_lines; struct mie_file_cell s_cursor; }; MIE_API enum mie_status mie_line_source_init( - struct mie_line_source *src, const char *path, b_stream *stream); + struct mie_line_source *src, const char *path, fx_stream *stream); MIE_API void mie_line_source_cleanup(struct mie_line_source *src); MIE_API const char *mie_line_source_get_path(const struct mie_line_source *src); MIE_API const struct mie_file_cell *mie_line_source_get_cursor( const struct mie_line_source *src); -MIE_API b_wchar mie_line_source_peekc(struct mie_line_source *src); -MIE_API b_wchar mie_line_source_getc(struct mie_line_source *src); +MIE_API fx_wchar mie_line_source_peekc(struct mie_line_source *src); +MIE_API fx_wchar mie_line_source_getc(struct mie_line_source *src); MIE_API enum mie_status mie_line_source_get_row( - struct mie_line_source *src, size_t row, const b_string **out); + struct mie_line_source *src, size_t row, const fx_string **out); MIE_API bool mie_line_source_input_available(struct mie_line_source *src); diff --git a/mie/include/mie/parse/parser.h b/mie/include/mie/parse/parser.h index 885fc41..30f3fee 100644 --- a/mie/include/mie/parse/parser.h +++ b/mie/include/mie/parse/parser.h @@ -1,7 +1,7 @@ #ifndef MIE_PARSE_PARSER_H_ #define MIE_PARSE_PARSER_H_ -#include +#include #include #include #include @@ -57,7 +57,7 @@ MIE_API struct mie_ctx *mie_parser_get_mie_ctx(struct mie_parser *ctx); MIE_API struct mie_lex *mie_parser_get_lexer(struct mie_parser *ctx); MIE_API enum mie_status mie_parser_get_status(const struct mie_parser *ctx); MIE_API void mie_parser_set_status(struct mie_parser *ctx, enum mie_status status); -MIE_API b_string *mie_parser_get_tempstr(struct mie_parser *ctx); +MIE_API fx_string *mie_parser_get_tempstr(struct mie_parser *ctx); MIE_API struct mie_token *mie_parser_peek(struct mie_parser *ctx); MIE_API enum mie_token_type mie_parser_peek_type(struct mie_parser *ctx); @@ -74,29 +74,29 @@ MIE_API bool mie_parser_parse_int( MIE_API bool mie_parser_parse_float( struct mie_parser *ctx, double *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_word( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_name( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_instname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_graphname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_opname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_vregname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_mregname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_blockname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_attribname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_typename( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_symname( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_string( - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc); + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc); MIE_API bool mie_parser_parse_keyword( struct mie_parser *ctx, const char *kw, struct mie_file_span *loc); MIE_API bool mie_parser_parse_symbol( @@ -126,7 +126,7 @@ MIE_API bool mie_parser_parse_parameter_list( struct mie_parser *ctx, bool include_type, MIE_VECTOR_REF_PARAM(struct mie_op_arg, out), const char *context); -MIE_API bool mie_parser_parse_unknown_keyword(struct mie_parser *ctx, b_string *out); +MIE_API bool mie_parser_parse_unknown_keyword(struct mie_parser *ctx, fx_string *out); MIE_API bool mie_parser_parse_unknown_symbol( struct mie_parser *ctx, enum mie_token_symbol sym); diff --git a/mie/include/mie/parse/token.h b/mie/include/mie/parse/token.h index 07eedc0..d1196e7 100644 --- a/mie/include/mie/parse/token.h +++ b/mie/include/mie/parse/token.h @@ -1,7 +1,7 @@ #ifndef MIE_PARSE_TOKEN_H_ #define MIE_PARSE_TOKEN_H_ -#include +#include #include #include @@ -82,7 +82,7 @@ struct mie_token { struct mie_file_span tok_location; enum mie_token_type tok_type; enum mie_token_value_type tok_value_type; - b_queue_entry tok_entry; + fx_queue_entry tok_entry; union { char *tok_str; diff --git a/mie/include/mie/print/printer.h b/mie/include/mie/print/printer.h index 3128c9f..ab6dd7f 100644 --- a/mie/include/mie/print/printer.h +++ b/mie/include/mie/print/printer.h @@ -1,7 +1,7 @@ #ifndef MIE_PRINT_PRINTER_H_ #define MIE_PRINT_PRINTER_H_ -#include +#include #include #include @@ -30,11 +30,11 @@ enum mie_print_flags { struct mie_printer { enum mie_print_flags p_flags; struct mie_ctx *p_mie; - b_stream *p_stream; + fx_stream *p_stream; }; MIE_API enum mie_status mie_printer_init( - struct mie_printer *printer, struct mie_ctx *ctx, b_stream *out, + struct mie_printer *printer, struct mie_ctx *ctx, fx_stream *out, enum mie_print_flags flags); MIE_API void mie_printer_print_module( diff --git a/mie/include/mie/status.h b/mie/include/mie/status.h index ed8d0c1..fa3909b 100644 --- a/mie/include/mie/status.h +++ b/mie/include/mie/status.h @@ -5,7 +5,7 @@ #define MIE_ERROR_VENDOR (ivy_error_vendor()) -struct b_error_vendor; +struct fx_error_vendor; enum mie_status { MIE_SUCCESS = 0, @@ -23,6 +23,6 @@ enum mie_status { MIE_ERR_INTERNAL_FAILURE, }; -MIE_API const struct b_error_vendor *mie_error_vendor(void); +MIE_API const struct fx_error_vendor *mie_error_vendor(void); #endif diff --git a/mie/include/mie/trait/trait-definition.h b/mie/include/mie/trait/trait-definition.h index 99b78d3..9ef009d 100644 --- a/mie/include/mie/trait/trait-definition.h +++ b/mie/include/mie/trait/trait-definition.h @@ -1,7 +1,7 @@ #ifndef MIE_TRAIT_TRAIT_DEFINITION_H_ #define MIE_TRAIT_TRAIT_DEFINITION_H_ -#include +#include #include #include @@ -50,7 +50,7 @@ struct mie_trait_definition { struct mie_id_builder *); enum mie_status (*tr_print)( const struct mie_trait_definition *, const struct mie_trait *, - b_stream *); + fx_stream *); enum mie_status (*tr_cleanup)( const struct mie_trait_definition *, struct mie_trait *); enum mie_status (*tr_validate)( diff --git a/mie/include/mie/trait/trait-table.h b/mie/include/mie/trait/trait-table.h index 4936a10..290663d 100644 --- a/mie/include/mie/trait/trait-table.h +++ b/mie/include/mie/trait/trait-table.h @@ -1,7 +1,7 @@ #ifndef MIE_TRAIT_TRAIT_TABLE_H_ #define MIE_TRAIT_TRAIT_TABLE_H_ -#include +#include #include #include #include @@ -18,7 +18,7 @@ struct mie_trait_table_iterator { int _f; struct mie_id_map_iterator _n; const struct mie_trait_table *_m; - b_queue_entry *_e; + fx_queue_entry *_e; }; MIE_API void mie_trait_table_init(struct mie_trait_table *out); diff --git a/mie/include/mie/trait/trait.h b/mie/include/mie/trait/trait.h index 1cd1cee..8fb893c 100644 --- a/mie/include/mie/trait/trait.h +++ b/mie/include/mie/trait/trait.h @@ -15,6 +15,6 @@ struct mie_trait { const struct mie_trait_definition *tr_def; }; -MIE_API void mie_trait_print(const struct mie_trait *type, b_stream *out); +MIE_API void mie_trait_print(const struct mie_trait *type, fx_stream *out); #endif diff --git a/mie/include/mie/type/function.h b/mie/include/mie/type/function.h index f4bdf6d..a5e7be8 100644 --- a/mie/include/mie/type/function.h +++ b/mie/include/mie/type/function.h @@ -1,7 +1,7 @@ #ifndef MIE_TYPE_FUNCTION_H_ #define MIE_TYPE_FUNCTION_H_ -#include +#include #include #include diff --git a/mie/include/mie/type/storage.h b/mie/include/mie/type/storage.h index 7b43945..dcea7ac 100644 --- a/mie/include/mie/type/storage.h +++ b/mie/include/mie/type/storage.h @@ -1,7 +1,7 @@ #ifndef MIE_TYPE_STORAGE_H_ #define MIE_TYPE_STORAGE_H_ -#include +#include #include #include diff --git a/mie/include/mie/type/type.h b/mie/include/mie/type/type.h index adaa078..77fb9f2 100644 --- a/mie/include/mie/type/type.h +++ b/mie/include/mie/type/type.h @@ -1,8 +1,8 @@ #ifndef MIE_TYPE_TYPE_H_ #define MIE_TYPE_TYPE_H_ -#include -#include +#include +#include #include #include #include diff --git a/mie/interface/interface-definition.c b/mie/interface/interface-definition.c index f647de3..afa9a75 100644 --- a/mie/interface/interface-definition.c +++ b/mie/interface/interface-definition.c @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -12,7 +12,7 @@ struct mie_interface_definition *mie_interface_definition_create( memset(out, 0x0, sizeof *out); - out->if_name = b_strdup(name); + out->if_name = fx_strdup(name); if (!out->if_name) { free(out); return NULL; @@ -21,7 +21,7 @@ struct mie_interface_definition *mie_interface_definition_create( out->if_parent = parent; out->if_size = 0; - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&parent->d_interfaces, &out->if_id, &name_rope); return out; diff --git a/mie/interface/interface-map.c b/mie/interface/interface-map.c index 3f05a1f..31be146 100644 --- a/mie/interface/interface-map.c +++ b/mie/interface/interface-map.c @@ -49,6 +49,6 @@ const struct mie_interface *mie_interface_map_get( const mie_id *result = mie_id_map_get(&map->m_entries, &id); const struct mie_interface *iface - = b_unbox(const struct mie_interface, result, if_id); + = fx_unbox(const struct mie_interface, result, if_id); return iface; } diff --git a/mie/ir/block.c b/mie/ir/block.c index 0a91324..c0d1357 100644 --- a/mie/ir/block.c +++ b/mie/ir/block.c @@ -4,12 +4,12 @@ struct mie_op *mie_block_get_first_op(const struct mie_block *block) { - b_queue_entry *entry = b_queue_first(&block->b_ops); + fx_queue_entry *entry = fx_queue_first(&block->b_ops); if (!entry) { return NULL; } - return b_unbox(struct mie_op, entry, op_entry); + return fx_unbox(struct mie_op, entry, op_entry); } struct mie_op *mie_block_get_prev_op( @@ -19,12 +19,12 @@ struct mie_op *mie_block_get_prev_op( return NULL; } - b_queue_entry *entry = b_queue_prev(&before->op_entry); + fx_queue_entry *entry = fx_queue_prev(&before->op_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_op, entry, op_entry); + return fx_unbox(struct mie_op, entry, op_entry); } struct mie_op *mie_block_get_next_op( @@ -34,28 +34,28 @@ struct mie_op *mie_block_get_next_op( return NULL; } - b_queue_entry *entry = b_queue_next(&after->op_entry); + fx_queue_entry *entry = fx_queue_next(&after->op_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_op, entry, op_entry); + return fx_unbox(struct mie_op, entry, op_entry); } struct mie_op *mie_block_get_last_op(const struct mie_block *block) { - b_queue_entry *entry = b_queue_last(&block->b_ops); + fx_queue_entry *entry = fx_queue_last(&block->b_ops); if (!entry) { return NULL; } - return b_unbox(struct mie_op, entry, op_entry); + return fx_unbox(struct mie_op, entry, op_entry); } struct mie_op *mie_block_get_terminator(const struct mie_block *block) { - b_queue_entry *op_entry = b_queue_last(&block->b_ops); - return b_unbox(struct mie_op, op_entry, op_entry); + fx_queue_entry *op_entry = fx_queue_last(&block->b_ops); + return fx_unbox(struct mie_op, op_entry, op_entry); } struct mie_op_successor *mie_block_get_first_successor(const struct mie_block *block) @@ -200,7 +200,7 @@ struct mie_op *mie_block_add_op(struct mie_block *block) mie_op_init(op); op->op_container = block; - b_queue_push_back(&block->b_ops, &op->op_entry); + fx_queue_push_back(&block->b_ops, &op->op_entry); return op; } @@ -220,9 +220,9 @@ struct mie_op *mie_block_add_op_after(struct mie_block *block, struct mie_op *af op->op_container = block; if (after) { - b_queue_insert_after(&block->b_ops, &op->op_entry, &after->op_entry); + fx_queue_insert_after(&block->b_ops, &op->op_entry, &after->op_entry); } else { - b_queue_push_back(&block->b_ops, &op->op_entry); + fx_queue_push_back(&block->b_ops, &op->op_entry); } return op; @@ -243,7 +243,7 @@ struct mie_register *mie_block_find_register( const struct mie_block *block, const char *name, const struct mie_op *start_point) { - const b_queue_entry *entry = b_queue_last(&block->b_ops); + const fx_queue_entry *entry = fx_queue_last(&block->b_ops); if (start_point) { entry = &start_point->op_entry; } @@ -255,13 +255,13 @@ struct mie_register *mie_block_find_register( } while (entry) { - struct mie_op *op = b_unbox(struct mie_op, entry, op_entry); + struct mie_op *op = fx_unbox(struct mie_op, entry, op_entry); struct mie_register *reg = mie_op_get_result_with_name(op, name); if (reg) { return reg; } - entry = b_queue_prev(entry); + entry = fx_queue_prev(entry); } return NULL; diff --git a/mie/ir/builder.c b/mie/ir/builder.c index 8b4aae4..1557ab7 100644 --- a/mie/ir/builder.c +++ b/mie/ir/builder.c @@ -7,7 +7,7 @@ #include struct builder_scope { - b_queue_entry s_entry; + fx_queue_entry s_entry; struct mie_op *s_op; struct mie_region *s_region; struct mie_block *s_block; @@ -16,7 +16,7 @@ struct builder_scope { struct mie_builder { struct mie_emitter b_base; struct mie_ctx *b_ctx; - b_queue b_scope_stack; + fx_queue b_scope_stack; struct mie_op *b_root; struct mie_op *b_prev_op; }; @@ -50,16 +50,16 @@ struct mie_ctx *mie_builder_get_ctx(struct mie_builder *builder) static struct mie_name_map *get_current_name_map(struct mie_builder *builder) { - b_queue_entry *cur = b_queue_last(&builder->b_scope_stack); + fx_queue_entry *cur = fx_queue_last(&builder->b_scope_stack); while (cur) { struct builder_scope *scope - = b_unbox(struct builder_scope, cur, s_entry); + = fx_unbox(struct builder_scope, cur, s_entry); if (scope->s_region && scope->s_region->r_names) { return scope->s_region->r_names; } - cur = b_queue_prev(cur); + cur = fx_queue_prev(cur); } return NULL; @@ -67,13 +67,13 @@ static struct mie_name_map *get_current_name_map(struct mie_builder *builder) struct mie_block *mie_builder_get_current_block(struct mie_builder *builder) { - b_queue_entry *entry = b_queue_last(&builder->b_scope_stack); + fx_queue_entry *entry = fx_queue_last(&builder->b_scope_stack); if (!entry) { return NULL; } struct builder_scope *scope - = b_unbox(struct builder_scope, entry, s_entry); + = fx_unbox(struct builder_scope, entry, s_entry); return scope->s_block; } @@ -114,19 +114,19 @@ void mie_builder_step_into_block(struct mie_builder *builder, struct mie_block * scope->s_region = block->b_parent; scope->s_op = scope->s_region->r_parent; - b_queue_push_back(&builder->b_scope_stack, &scope->s_entry); + fx_queue_push_back(&builder->b_scope_stack, &scope->s_entry); } void mie_builder_step_out(struct mie_builder *builder) { - b_queue_entry *entry = b_queue_last(&builder->b_scope_stack); + fx_queue_entry *entry = fx_queue_last(&builder->b_scope_stack); if (!entry) { return; } struct builder_scope *scope - = b_unbox(struct builder_scope, entry, s_entry); - b_queue_delete(&builder->b_scope_stack, entry); + = fx_unbox(struct builder_scope, entry, s_entry); + fx_queue_delete(&builder->b_scope_stack, entry); free(scope); } @@ -151,7 +151,7 @@ struct mie_op *mie_builder_put_op( arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_value.u_reg = args[i]; arg->arg_value.u_user = op; - b_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); } return op; diff --git a/mie/ir/op-definition.c b/mie/ir/op-definition.c index a9fc34b..4cc71f8 100644 --- a/mie/ir/op-definition.c +++ b/mie/ir/op-definition.c @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -10,7 +10,7 @@ struct mie_op_definition *mie_op_definition_create( return NULL; } - out->op_name = b_strdup(name); + out->op_name = fx_strdup(name); if (!out->op_name) { free(out); return NULL; @@ -20,7 +20,7 @@ struct mie_op_definition *mie_op_definition_create( mie_trait_table_init(&out->op_traits); mie_interface_map_init(&out->op_iface); - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&parent->d_ops, &out->op_id, &name_rope); return out; diff --git a/mie/ir/op.c b/mie/ir/op.c index a365a87..eaf04c5 100644 --- a/mie/ir/op.c +++ b/mie/ir/op.c @@ -15,7 +15,7 @@ static enum mie_status op_arg_cleanup(void *p) struct mie_op_arg *arg = p; if (arg->arg_flags & MIE_OP_F_ARG_RESOLVED) { - b_queue_delete( + fx_queue_delete( &arg->arg_value.u_reg->reg_use, &arg->arg_value.u_entry); } @@ -115,7 +115,7 @@ struct mie_op_successor *mie_op_add_successor( arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_value.u_reg = args[i]; arg->arg_value.u_user = op; - b_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); } return s; @@ -147,7 +147,7 @@ struct mie_region *mie_op_add_region(struct mie_op *op) region->r_names = mie_name_map_create(NULL); } - b_queue_push_back(&op->op_regions, ®ion->r_entry); + fx_queue_push_back(&op->op_regions, ®ion->r_entry); return region; } @@ -202,12 +202,12 @@ bool mie_op_has_interface( struct mie_region *mie_op_get_first_region(const struct mie_op *op) { - b_queue_entry *entry = b_queue_first(&op->op_regions); + fx_queue_entry *entry = fx_queue_first(&op->op_regions); if (!entry) { return NULL; } - return b_unbox(struct mie_region, entry, r_entry); + return fx_unbox(struct mie_region, entry, r_entry); } struct mie_region *mie_op_get_prev_region( @@ -217,12 +217,12 @@ struct mie_region *mie_op_get_prev_region( return NULL; } - b_queue_entry *entry = b_queue_prev(&before->r_entry); + fx_queue_entry *entry = fx_queue_prev(&before->r_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_region, entry, r_entry); + return fx_unbox(struct mie_region, entry, r_entry); } struct mie_region *mie_op_get_next_region( @@ -232,22 +232,22 @@ struct mie_region *mie_op_get_next_region( return NULL; } - b_queue_entry *entry = b_queue_next(&after->r_entry); + fx_queue_entry *entry = fx_queue_next(&after->r_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_region, entry, r_entry); + return fx_unbox(struct mie_region, entry, r_entry); } struct mie_region *mie_op_get_last_region(const struct mie_op *op) { - b_queue_entry *entry = b_queue_last(&op->op_regions); + fx_queue_entry *entry = fx_queue_last(&op->op_regions); if (!entry) { return NULL; } - return b_unbox(struct mie_region, entry, r_entry); + return fx_unbox(struct mie_region, entry, r_entry); } struct mie_register *mie_op_get_arg(const struct mie_op *op, size_t index) diff --git a/mie/ir/region.c b/mie/ir/region.c index 6a70b37..0e5870b 100644 --- a/mie/ir/region.c +++ b/mie/ir/region.c @@ -10,12 +10,12 @@ struct mie_block *mie_region_get_first_block(const struct mie_region *region) { - b_queue_entry *entry = b_queue_first(®ion->r_blocks); + fx_queue_entry *entry = fx_queue_first(®ion->r_blocks); if (!entry) { return NULL; } - return b_unbox(struct mie_block, entry, b_entry); + return fx_unbox(struct mie_block, entry, b_entry); } struct mie_block *mie_region_get_prev_block( @@ -25,12 +25,12 @@ struct mie_block *mie_region_get_prev_block( return NULL; } - b_queue_entry *entry = b_queue_prev(&before->b_entry); + fx_queue_entry *entry = fx_queue_prev(&before->b_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_block, entry, b_entry); + return fx_unbox(struct mie_block, entry, b_entry); } struct mie_block *mie_region_get_next_block( @@ -40,22 +40,22 @@ struct mie_block *mie_region_get_next_block( return NULL; } - b_queue_entry *entry = b_queue_next(&after->b_entry); + fx_queue_entry *entry = fx_queue_next(&after->b_entry); if (!entry) { return NULL; } - return b_unbox(struct mie_block, entry, b_entry); + return fx_unbox(struct mie_block, entry, b_entry); } struct mie_block *mie_region_get_last_block(const struct mie_region *region) { - b_queue_entry *entry = b_queue_last(®ion->r_blocks); + fx_queue_entry *entry = fx_queue_last(®ion->r_blocks); if (!entry) { return NULL; } - return b_unbox(struct mie_block, entry, b_entry); + return fx_unbox(struct mie_block, entry, b_entry); } struct mie_block *mie_region_add_block(struct mie_region *region) @@ -70,7 +70,7 @@ struct mie_block *mie_region_add_block(struct mie_region *region) block->b_parent = region; block->b_id = MIE_BLOCK_ID_INVALID; - b_queue_push_back(®ion->r_blocks, &block->b_entry); + fx_queue_push_back(®ion->r_blocks, &block->b_entry); return block; } @@ -91,7 +91,7 @@ struct mie_block *mie_region_add_block_before( memset(block, 0x0, sizeof *block); block->b_parent = region; - b_queue_insert_before(®ion->r_blocks, &block->b_entry, &before->b_entry); + fx_queue_insert_before(®ion->r_blocks, &block->b_entry, &before->b_entry); return block; } @@ -112,7 +112,7 @@ struct mie_block *mie_region_add_block_after( memset(block, 0x0, sizeof *block); block->b_parent = region; - b_queue_insert_after(®ion->r_blocks, &block->b_entry, &after->b_entry); + fx_queue_insert_after(®ion->r_blocks, &block->b_entry, &after->b_entry); return block; } @@ -120,15 +120,15 @@ struct mie_block *mie_region_add_block_after( struct mie_block *mie_region_find_block( const struct mie_region *region, const char *name) { - b_queue_entry *cur = b_queue_first(®ion->r_blocks); + fx_queue_entry *cur = fx_queue_first(®ion->r_blocks); while (cur) { - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); const char *block_name = block->b_name.n_str; if (block_name && !strcmp(block_name, name)) { return block; } - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } return NULL; @@ -137,17 +137,17 @@ struct mie_block *mie_region_find_block( struct mie_register *mie_region_find_register( const struct mie_region *region, const char *name) { - b_queue_entry *cur = b_queue_first(®ion->r_blocks); + fx_queue_entry *cur = fx_queue_first(®ion->r_blocks); while (cur) { - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); struct mie_register *reg = mie_block_find_register(block, name, NULL); if (reg) { return reg; } - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } return NULL; diff --git a/mie/ir/register.c b/mie/ir/register.c index 4ca3732..229eb31 100644 --- a/mie/ir/register.c +++ b/mie/ir/register.c @@ -1,5 +1,5 @@ #include -#include +#include #include static enum mie_status reg_cleanup(void *p) @@ -57,13 +57,13 @@ void mie_register_use_move( memmove(dest, src, sizeof *dest); if (src->u_reg) { - b_queue_move(&src->u_reg->reg_use, &src->u_entry, &dest->u_entry); + fx_queue_move(&src->u_reg->reg_use, &src->u_entry, &dest->u_entry); } } void mie_register_use_cleanup(struct mie_register_use *use) { if (use->u_reg) { - b_queue_delete(&use->u_reg->reg_use, &use->u_entry); + fx_queue_delete(&use->u_reg->reg_use, &use->u_entry); } } diff --git a/mie/ir/resolve.c b/mie/ir/resolve.c index 507f4fd..6728e44 100644 --- a/mie/ir/resolve.c +++ b/mie/ir/resolve.c @@ -120,7 +120,7 @@ static bool resolve_arg( memset(&arg->arg_value, 0x0, sizeof arg->arg_value); arg->arg_value.u_reg = reg; arg->arg_value.u_user = op; - b_queue_push_back(®->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(®->reg_use, &arg->arg_value.u_entry); return true; } @@ -135,7 +135,7 @@ static bool resolve_arg( memset(&arg->arg_value, 0x0, sizeof arg->arg_value); arg->arg_value.u_reg = reg; arg->arg_value.u_user = op; - b_queue_push_back(®->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(®->reg_use, &arg->arg_value.u_entry); return true; } diff --git a/mie/ir/walk.c b/mie/ir/walk.c index e128f62..c528762 100644 --- a/mie/ir/walk.c +++ b/mie/ir/walk.c @@ -35,15 +35,15 @@ static void push_walk_item( } memcpy(i, item, sizeof *i); - b_queue_push_back(&walker->w_stack, &i->_e); + fx_queue_push_back(&walker->w_stack, &i->_e); } static void pop_walk_item(struct mie_walker *walker) { - b_queue_entry *entry = b_queue_pop_back(&walker->w_stack); + fx_queue_entry *entry = fx_queue_pop_back(&walker->w_stack); if (entry) { struct mie_walk_item *item - = b_unbox(struct mie_walk_item, entry, _e); + = fx_unbox(struct mie_walk_item, entry, _e); free(item); } } @@ -65,12 +65,12 @@ static struct mie_walk_item *current_item(struct mie_walker *walker) return eof ? item : NULL; } - b_queue_entry *entry = b_queue_last(&walker->w_stack); + fx_queue_entry *entry = fx_queue_last(&walker->w_stack); if (!entry) { return NULL; } - item = b_unbox(struct mie_walk_item, entry, _e); + item = fx_unbox(struct mie_walk_item, entry, _e); return item->i_type != MIE_WALK_ITEM_NONE ? item : NULL; } @@ -144,7 +144,7 @@ static bool walk_item_get_first_child( struct mie_walk_item *child) { bool ok = false; - b_queue_entry *entry = NULL; + fx_queue_entry *entry = NULL; switch (item->i_type) { case MIE_WALK_ITEM_OP: @@ -184,7 +184,7 @@ static bool walk_item_get_last_child( struct mie_walk_item *child) { bool ok = false; - b_queue_entry *entry = NULL; + fx_queue_entry *entry = NULL; switch (item->i_type) { case MIE_WALK_ITEM_OP: @@ -230,7 +230,7 @@ static bool walk_item_get_next_sibling( sibling->i_type = item->i_type; size_t index = 0; - b_queue_entry *entry = NULL; + fx_queue_entry *entry = NULL; struct mie_region *parent_r = NULL; struct mie_block *parent_b = NULL; struct mie_op *parent_o = NULL; @@ -316,11 +316,11 @@ static bool walk_item_get_prev_sibling( static void print_stack(struct mie_walker *walker) { - b_queue_entry *entry = b_queue_last(&walker->w_stack); + fx_queue_entry *entry = fx_queue_last(&walker->w_stack); while (entry) { struct mie_walk_item *item - = b_unbox(struct mie_walk_item, entry, _e); + = fx_unbox(struct mie_walk_item, entry, _e); switch (item->i_type) { case MIE_WALK_ITEM_OP: @@ -347,7 +347,7 @@ static void print_stack(struct mie_walker *walker) printf("\n"); - entry = b_queue_prev(entry); + entry = fx_queue_prev(entry); } } diff --git a/mie/lt-idom.c b/mie/lt-idom.c index 86fa787..45cd8eb 100644 --- a/mie/lt-idom.c +++ b/mie/lt-idom.c @@ -26,9 +26,9 @@ struct lt_ctx { }; #if 0 -static B_BTREE_DEFINE_SIMPLE_INSERT(struct mie_block, b_node, b_id, put_block_by_id); -static B_BTREE_DEFINE_SIMPLE_GET( - struct mie_block, size_t, b_node, b_id, get_block_by_id); +static FX_BST_DEFINE_SIMPLE_INSERT(struct mie_block, fx_node, b_id, put_block_by_id); +static FX_BST_DEFINE_SIMPLE_GET( + struct mie_block, size_t, fx_node, b_id, get_block_by_id); #endif static void set_add(struct set *set, unsigned int val) @@ -148,16 +148,16 @@ static unsigned int eval(struct lt_ctx *ctx, unsigned int v) static void reset_block_relationship_metadata(struct mie_region *region) { - b_queue_entry *cur = b_queue_first(®ion->r_blocks); + fx_queue_entry *cur = fx_queue_first(®ion->r_blocks); while (cur) { - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); block->b_id = MIE_BLOCK_ID_INVALID; block->b_idom = NULL; // block->b_sdom = block->b_dfs_parent = NULL; mie_vector_destroy(block->b_ipred, NULL); - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } memset(®ion->r_blocks_s, 0x0, sizeof region->r_blocks_s); @@ -191,7 +191,7 @@ static void lt_ctx_cleanup(struct lt_ctx *ctx) void mie_region_refresh_dominance(struct mie_region *region) { struct lt_ctx ctx; - size_t nr_nodes = b_queue_length(®ion->r_blocks); + size_t nr_nodes = fx_queue_length(®ion->r_blocks); lt_ctx_init(&ctx, nr_nodes); struct mie_block *root = mie_region_get_first_block(region); diff --git a/mie/name.c b/mie/name.c index 36d8a12..b3ca72a 100644 --- a/mie/name.c +++ b/mie/name.c @@ -1,12 +1,12 @@ -#include -#include +#include +#include #include #include #include -static B_BTREE_DEFINE_SIMPLE_INSERT( +static FX_BST_DEFINE_SIMPLE_INSERT( struct mie_name_map_entry, e_node, e_hash, put_entry); -static B_BTREE_DEFINE_SIMPLE_GET( +static FX_BST_DEFINE_SIMPLE_GET( struct mie_name_map_entry, uint64_t, e_node, e_hash, get_entry); static struct mie_name_bucket *create_bucket(void) @@ -26,11 +26,11 @@ static struct mie_name_bucket *create_bucket(void) static void destroy_bucket(struct mie_name_bucket *bucket) { - b_queue_entry *entry = b_queue_first(&bucket->b_names); + fx_queue_entry *entry = fx_queue_first(&bucket->b_names); while (entry) { - b_queue_entry *next = b_queue_next(entry); - b_queue_delete(&bucket->b_names, entry); + fx_queue_entry *next = fx_queue_next(entry); + fx_queue_delete(&bucket->b_names, entry); entry = next; } @@ -52,13 +52,13 @@ struct mie_name_map *mie_name_map_create(const struct mie_name_map *parent) void mie_name_map_destroy(struct mie_name_map *map) { - b_btree_node *node = b_btree_first(&map->m_entries); + fx_bst_node *node = fx_bst_first(&map->m_entries); while (node) { struct mie_name_map_entry *entry - = 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); + = fx_unbox(struct mie_name_map_entry, node, e_node); + fx_bst_node *next = fx_bst_next(node); + fx_bst_delete(&map->m_entries, node); if (entry->e_type == MIE_NAME_MAP_E_BUCKET) { struct mie_name_bucket *bucket = (struct mie_name_bucket *)entry; @@ -71,36 +71,36 @@ void mie_name_map_destroy(struct mie_name_map *map) free(map); } -static b_status put_name_in_bucket( +static fx_status put_name_in_bucket( struct mie_name_bucket *bucket, struct mie_name *name) { - b_queue_entry *entry = b_queue_first(&bucket->b_names); + fx_queue_entry *entry = fx_queue_first(&bucket->b_names); while (entry) { - struct mie_name *cur = (struct mie_name *)b_unbox( + struct mie_name *cur = (struct mie_name *)fx_unbox( struct mie_name_map_entry, entry, e_entry); if (!strcmp(cur->n_str, name->n_str)) { - return B_ERR_NAME_EXISTS; + return FX_ERR_NAME_EXISTS; } - entry = b_queue_next(entry); + entry = fx_queue_next(entry); } - b_queue_push_back(&bucket->b_names, &name->n_base.e_entry); + fx_queue_push_back(&bucket->b_names, &name->n_base.e_entry); name->n_bucket = bucket; - return B_SUCCESS; + return FX_SUCCESS; } -static b_status put_name(struct mie_name_map *map, struct mie_name *name) +static fx_status put_name(struct mie_name_map *map, struct mie_name *name) { struct mie_name_map_entry *entry = get_entry(&map->m_entries, name->n_base.e_hash); if (!entry) { put_entry(&map->m_entries, &name->n_base); - return B_SUCCESS; + return FX_SUCCESS; } if (entry->e_type == MIE_NAME_MAP_E_BUCKET) { @@ -111,26 +111,26 @@ static b_status put_name(struct mie_name_map *map, struct mie_name *name) struct mie_name *existing_name = (struct mie_name *)entry; if (!strcmp(existing_name->n_str, name->n_str)) { - return B_ERR_NAME_EXISTS; + return FX_ERR_NAME_EXISTS; } struct mie_name_bucket *bucket = create_bucket(); if (!bucket) { - return B_ERR_NO_MEMORY; + return FX_ERR_NO_MEMORY; } - b_btree_delete(&map->m_entries, &entry->e_node); - entry->e_entry = B_QUEUE_ENTRY_INIT; + fx_bst_delete(&map->m_entries, &entry->e_node); + entry->e_entry = FX_QUEUE_ENTRY_INIT; bucket->b_base.e_hash = name->n_base.e_hash; - b_queue_push_back(&bucket->b_names, &existing_name->n_base.e_entry); - b_queue_push_back(&bucket->b_names, &name->n_base.e_entry); + fx_queue_push_back(&bucket->b_names, &existing_name->n_base.e_entry); + fx_queue_push_back(&bucket->b_names, &name->n_base.e_entry); existing_name->n_bucket = name->n_bucket = bucket; put_entry(&map->m_entries, &bucket->b_base); - return B_SUCCESS; + return FX_SUCCESS; } static bool check_name(const struct mie_name *name, const char *s, uint64_t hash) @@ -141,16 +141,16 @@ static bool check_name(const struct mie_name *name, const char *s, uint64_t hash static const struct mie_name *find_name_in_bucket( const struct mie_name_bucket *bucket, const char *s, uint64_t hash) { - b_queue_entry *entry = b_queue_first(&bucket->b_names); + fx_queue_entry *entry = fx_queue_first(&bucket->b_names); while (entry) { struct mie_name_map_entry *map_entry - = b_unbox(struct mie_name_map_entry, entry, e_entry); + = fx_unbox(struct mie_name_map_entry, entry, e_entry); struct mie_name *name = (struct mie_name *)map_entry; if (check_name(name, s, hash)) { return name; } - entry = b_queue_next(entry); + entry = fx_queue_next(entry); } return NULL; @@ -194,7 +194,7 @@ const struct mie_name *mie_name_map_get( const struct mie_name_map *map, const char *name, enum mie_name_map_flags flags) { - uint64_t name_hash = b_hash_cstr(name); + uint64_t name_hash = fx_hash_cstr(name); while (map) { const struct mie_name *result = name_map_get(map, name, name_hash); if (result) { @@ -214,24 +214,24 @@ struct mie_name *mie_name_map_put( memset(entry, 0x0, sizeof *entry); entry->n_base.e_type = MIE_NAME_MAP_E_NAME; - b_rope base = {}; + fx_rope base = {}; if (hint) { - b_rope_init_cstr_borrowed(&base, hint); + fx_rope_init_cstr_borrowed(&base, hint); } char str[256]; if (hint) { /* first try just the hint on its own */ - b_rope_to_cstr(&base, str, sizeof str); + fx_rope_to_cstr(&base, str, sizeof str); entry->n_str = str; entry->n_base.e_hash = base.r_v.v_cstr.hash; - b_status status = put_name(map, entry); + fx_status status = put_name(map, entry); - if (B_OK(status)) { + if (FX_OK(status)) { entry->n_parent = map; - entry->n_str = b_strdup(str); + entry->n_str = fx_strdup(str); return entry; } } @@ -244,15 +244,15 @@ struct mie_name *mie_name_map_put( /* that name already exists, use a suffix to make the name unique. * alternately, no hint was specified, so it's up to us to generate the name */ - b_rope dot = B_ROPE_CHAR('.'); - b_rope suffix = B_ROPE_UINT(0); - b_rope unique_name; + fx_rope dot = FX_ROPE_CHAR('.'); + fx_rope suffix = FX_ROPE_UINT(0); + fx_rope unique_name; if (hint) { - const b_rope *parts[] = {&base, &dot, &suffix}; - b_rope_join(&unique_name, parts, sizeof parts / sizeof parts[0]); + const fx_rope *parts[] = {&base, &dot, &suffix}; + fx_rope_join(&unique_name, parts, sizeof parts / sizeof parts[0]); } else { - b_rope_concat(&unique_name, &base, &suffix); + fx_rope_concat(&unique_name, &base, &suffix); } size_t i = 0; @@ -263,21 +263,21 @@ struct mie_name *mie_name_map_put( for (;; i++) { suffix.r_v.v_uint = i; - b_rope_to_cstr(&unique_name, str, sizeof str); + fx_rope_to_cstr(&unique_name, str, sizeof str); entry->n_str = str; - entry->n_base.e_hash = b_hash_cstr(str); - b_status status = put_name(map, entry); + entry->n_base.e_hash = fx_hash_cstr(str); + fx_status status = put_name(map, entry); - if (B_OK(status)) { + if (FX_OK(status)) { entry->n_parent = map; - entry->n_str = b_strdup(str); - b_rope_destroy(&unique_name); + entry->n_str = fx_strdup(str); + fx_rope_destroy(&unique_name); return entry; } } - b_rope_destroy(&unique_name); + fx_rope_destroy(&unique_name); return NULL; } @@ -292,11 +292,11 @@ void mie_name_move(struct mie_name *dst, struct mie_name *src) memmove(dst, src, sizeof *src); if (src->n_bucket) { - b_queue_move( + fx_queue_move( &src->n_bucket->b_names, &dst->n_base.e_entry, &src->n_base.e_entry); } else { - b_btree_move( + fx_bst_move( &src->n_parent->m_entries, &dst->n_base.e_node, &src->n_base.e_node); } @@ -318,11 +318,11 @@ void mie_name_destroy(struct mie_name *name) switch (entry->e_type) { case MIE_NAME_MAP_E_NAME: - b_btree_delete(&parent->m_entries, &entry->e_node); + fx_bst_delete(&parent->m_entries, &entry->e_node); break; case MIE_NAME_MAP_E_BUCKET: - bucket = b_unbox(struct mie_name_bucket, entry, b_base); - b_queue_delete(&bucket->b_names, &name->n_base.e_entry); + bucket = fx_unbox(struct mie_name_bucket, entry, b_base); + fx_queue_delete(&bucket->b_names, &name->n_base.e_entry); break; default: abort(); diff --git a/mie/parse/lex.c b/mie/parse/lex.c index 2c6f4c4..d135997 100644 --- a/mie/parse/lex.c +++ b/mie/parse/lex.c @@ -1,11 +1,11 @@ #include "lex.h" -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -22,10 +22,10 @@ #define LEX_TOKEN_DEF(i, n) {.id = (i), .name = (n)} #define IS_VALID_IDENT_CHAR(c) \ - (b_wchar_is_alnum(c) || c == '.' || c == '-' || c == '_') + (fx_wchar_is_alnum(c) || c == '.' || c == '-' || c == '_') #define IS_VALID_IDENT_START_CHAR(c) \ - (b_wchar_is_alpha(c) || c == '.' || c == '_') -#define IS_VALID_REG_START_CHAR(c) (b_wchar_is_alnum(c) || c == '.' || c == '_') + (fx_wchar_is_alpha(c) || c == '.' || c == '_') +#define IS_VALID_REG_START_CHAR(c) (fx_wchar_is_alnum(c) || c == '.' || c == '_') static struct lex_token_def symbols[] = { LEX_TOKEN_DEF(MIE_SYM_COLON, ":"), @@ -57,15 +57,15 @@ static const size_t nr_symbols = sizeof symbols / sizeof symbols[0]; static struct mie_lex_symbol_node *get_symbol_node( struct mie_lex_symbol_node *node, char c) { - b_queue_entry *entry = b_queue_first(&node->s_children); + fx_queue_entry *entry = fx_queue_first(&node->s_children); while (entry) { struct mie_lex_symbol_node *child - = b_unbox(struct mie_lex_symbol_node, entry, s_entry); + = fx_unbox(struct mie_lex_symbol_node, entry, s_entry); if (child->s_char == c) { return child; } - entry = b_queue_next(entry); + entry = fx_queue_next(entry); } return NULL; @@ -79,13 +79,13 @@ static struct mie_diag *push_diag(struct mie_lex *lex, unsigned long diag_class) diag_class); } -static b_string *get_temp_string(struct mie_lex *lex) +static fx_string *get_temp_string(struct mie_lex *lex) { if (!lex->lex_temp) { - lex->lex_temp = b_string_create(); + lex->lex_temp = fx_string_create(); } - b_string_clear(lex->lex_temp); + fx_string_clear(lex->lex_temp); return lex->lex_temp; } @@ -110,7 +110,7 @@ static enum mie_status put_symbol( child->s_def = NULL; child->s_char = c; - b_queue_push_back(&tree->s_children, &child->s_entry); + fx_queue_push_back(&tree->s_children, &child->s_entry); tree = child; } @@ -120,12 +120,12 @@ static enum mie_status put_symbol( static void destroy_symbol_tree(struct mie_lex_symbol_node *tree) { - b_queue_entry *entry = b_queue_first(&tree->s_children); + fx_queue_entry *entry = fx_queue_first(&tree->s_children); while (entry) { struct mie_lex_symbol_node *node - = b_unbox(struct mie_lex_symbol_node, entry, s_entry); - b_queue_entry *next = b_queue_next(entry); - b_queue_delete(&tree->s_children, entry); + = fx_unbox(struct mie_lex_symbol_node, entry, s_entry); + fx_queue_entry *next = fx_queue_next(entry); + fx_queue_delete(&tree->s_children, entry); destroy_symbol_tree(node); @@ -183,13 +183,13 @@ struct mie_lex *mie_lex_create(struct mie_line_source *src, struct mie_ctx *ctx) void mie_lex_destroy(struct mie_lex *lex) { - b_queue_entry *entry = b_queue_first(&lex->lex_queue); + fx_queue_entry *entry = fx_queue_first(&lex->lex_queue); while (entry) { struct mie_token *tok - = b_unbox(struct mie_token, entry, tok_entry); - b_queue_entry *next = b_queue_next(entry); - b_queue_delete(&lex->lex_queue, entry); + = fx_unbox(struct mie_token, entry, tok_entry); + fx_queue_entry *next = fx_queue_next(entry); + fx_queue_delete(&lex->lex_queue, entry); mie_token_destroy(tok); @@ -201,7 +201,7 @@ void mie_lex_destroy(struct mie_lex *lex) } if (lex->lex_temp) { - b_string_unref(lex->lex_temp); + fx_string_unref(lex->lex_temp); } free(lex); @@ -261,7 +261,7 @@ static enum mie_status push_token(struct mie_lex *lex, struct mie_token *tok) tok->tok_location.s_start = lex->lex_token_start; tok->tok_location.s_end = lex->lex_token_end; - b_queue_push_back(&lex->lex_queue, &tok->tok_entry); + fx_queue_push_back(&lex->lex_queue, &tok->tok_entry); return MIE_SUCCESS; } @@ -354,7 +354,7 @@ static enum mie_status push_float(struct mie_lex *lex, double v) static enum mie_status read_line_comment(struct mie_lex *lex) { while (true) { - b_wchar c = mie_line_source_getc(lex->lex_source); + fx_wchar c = mie_line_source_getc(lex->lex_source); if (c == -MIE_ERR_EOF || c == '\n') { break; @@ -373,14 +373,14 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate) int token_len = 0; int base = 10; int dots = 0; - b_string *str = get_temp_string(lex); + fx_string *str = get_temp_string(lex); if (!negate) { set_token_start(lex); } while (true) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); if (c == -MIE_ERR_EOF) { break; } @@ -408,13 +408,13 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate) token_len++; dots++; char s[] = {c, 0}; - b_string_append_cstr(str, s); + fx_string_append_cstr(str, s); set_token_end(lex); mie_line_source_getc(lex->lex_source); continue; } - if (b_wchar_is_space(c) || b_wchar_is_punct(c)) { + if (fx_wchar_is_space(c) || fx_wchar_is_punct(c)) { break; } @@ -446,7 +446,7 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate) return MIE_ERR_BAD_SYNTAX; } - b_string_append_wc(str, c); + fx_string_append_wc(str, c); set_token_end(lex); mie_line_source_getc(lex->lex_source); token_len++; @@ -456,7 +456,7 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate) return push_int(lex, 0); } - const char *s = b_string_ptr(str); + const char *s = fx_string_ptr(str); char *ep = NULL; /* negative numbers will be lexed as a hyphen followed by a positive @@ -492,15 +492,15 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate) static enum mie_status read_ident(struct mie_lex *lex, enum mie_token_type type) { int dots = 0; - b_string *str = get_temp_string(lex); - b_wchar prev = 0; + fx_string *str = get_temp_string(lex); + fx_wchar prev = 0; if (type == MIE_TOK_NONE) { set_token_start(lex); } while (1) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); if ((c == '.' || c == '-') && prev == c) { return MIE_ERR_BAD_SYNTAX; @@ -515,7 +515,7 @@ static enum mie_status read_ident(struct mie_lex *lex, enum mie_token_type type) } prev = c; - b_string_append_wc(str, c); + fx_string_append_wc(str, c); set_token_end(lex); mie_line_source_getc(lex->lex_source); } @@ -524,7 +524,7 @@ static enum mie_status read_ident(struct mie_lex *lex, enum mie_token_type type) type = dots > 0 ? MIE_TOK_NAME : MIE_TOK_WORD; } - char *s = b_string_steal(str); + char *s = fx_string_steal(str); switch (type) { case MIE_TOK_INSTNAME: @@ -543,9 +543,9 @@ static enum mie_status read_ident(struct mie_lex *lex, enum mie_token_type type) static enum mie_status read_string(struct mie_lex *lex) { - b_string *str = get_temp_string(lex); + fx_string *str = get_temp_string(lex); - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); bool esc = false; if (c != '"') { @@ -555,13 +555,13 @@ static enum mie_status read_string(struct mie_lex *lex) mie_line_source_getc(lex->lex_source); while (1) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); if (esc) { switch (c) { case '\\': case '"': - b_string_append_wc(str, c); + fx_string_append_wc(str, c); break; default: return MIE_ERR_BAD_SYNTAX; @@ -583,11 +583,11 @@ static enum mie_status read_string(struct mie_lex *lex) break; } - b_string_append_wc(str, c); + fx_string_append_wc(str, c); mie_line_source_getc(lex->lex_source); } - char *s = b_string_steal(str); + char *s = fx_string_steal(str); return push_string_token(lex, MIE_TOK_STRING, s); } @@ -595,10 +595,10 @@ static enum mie_status read_symbol(struct mie_lex *lex) { struct mie_lex_symbol_node *node = lex->lex_sym_tree; set_token_start(lex); - b_wchar prev = 0; + fx_wchar prev = 0; while (true) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); if (c < 0) { break; } @@ -667,17 +667,17 @@ static enum mie_status read_symbol(struct mie_lex *lex) static void skip_whitespace(struct mie_lex *lex) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); - while (b_wchar_is_space(c)) { + while (fx_wchar_is_space(c)) { mie_line_source_getc(lex->lex_source); c = mie_line_source_peekc(lex->lex_source); } } -static bool should_skip(b_wchar c, bool skip_linefeeds) +static bool should_skip(fx_wchar c, bool skip_linefeeds) { - bool skip = b_wchar_is_space(c); + bool skip = fx_wchar_is_space(c); if (!skip_linefeeds) { skip = (skip && c != '\n'); @@ -688,7 +688,7 @@ static bool should_skip(b_wchar c, bool skip_linefeeds) static void skip_ignored_chars(struct mie_lex *lex, bool include_linefeeds) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); while (1) { while (should_skip(c, include_linefeeds)) { @@ -715,14 +715,14 @@ static void skip_ignored_chars(struct mie_lex *lex, bool include_linefeeds) static enum mie_status pump_tokens(struct mie_lex *lex) { - b_wchar c = mie_line_source_peekc(lex->lex_source); + fx_wchar c = mie_line_source_peekc(lex->lex_source); if (c < 0) { return -c; } while (1) { - if (c == ';' || (b_wchar_is_space(c) && c != '\n')) { + if (c == ';' || (fx_wchar_is_space(c) && c != '\n')) { skip_ignored_chars(lex, false); } else { break; @@ -758,7 +758,7 @@ static enum mie_status pump_tokens(struct mie_lex *lex) return push_linefeed(lex); } - while (b_wchar_is_space(c) && c != '\n') { + while (fx_wchar_is_space(c) && c != '\n') { mie_line_source_getc(lex->lex_source); c = mie_line_source_peekc(lex->lex_source); } @@ -800,7 +800,7 @@ struct mie_token *mie_lex_peek(struct mie_lex *lex) { enum mie_status status = MIE_SUCCESS; - while (b_queue_empty(&lex->lex_queue)) { + while (fx_queue_empty(&lex->lex_queue)) { status = pump_tokens(lex); if (status != MIE_SUCCESS) { @@ -811,8 +811,8 @@ struct mie_token *mie_lex_peek(struct mie_lex *lex) lex->lex_status = status; - b_queue_entry *entry = b_queue_first(&lex->lex_queue); - struct mie_token *tok = b_unbox(struct mie_token, entry, tok_entry); + fx_queue_entry *entry = fx_queue_first(&lex->lex_queue); + struct mie_token *tok = fx_unbox(struct mie_token, entry, tok_entry); return tok; } @@ -820,7 +820,7 @@ void mie_lex_advance(struct mie_lex *lex) { enum mie_status status = MIE_SUCCESS; - while (b_queue_empty(&lex->lex_queue)) { + while (fx_queue_empty(&lex->lex_queue)) { status = pump_tokens(lex); if (status != MIE_SUCCESS) { @@ -829,14 +829,14 @@ void mie_lex_advance(struct mie_lex *lex) } } - b_queue_entry *entry = b_queue_pop_front(&lex->lex_queue); - struct mie_token *tok = b_unbox(struct mie_token, entry, tok_entry); + fx_queue_entry *entry = fx_queue_pop_front(&lex->lex_queue); + struct mie_token *tok = fx_unbox(struct mie_token, entry, tok_entry); mie_token_destroy(tok); } bool mie_lex_tokens_available(struct mie_lex *lex) { - if (!b_queue_empty(&lex->lex_queue)) { + if (!fx_queue_empty(&lex->lex_queue)) { return true; } diff --git a/mie/parse/lex.h b/mie/parse/lex.h index 1d1a96b..9648044 100644 --- a/mie/parse/lex.h +++ b/mie/parse/lex.h @@ -1,9 +1,9 @@ #ifndef _PARSE_LEX_H_ #define _PARSE_LEX_H_ -#include -#include -#include +#include +#include +#include #include #include #include @@ -16,10 +16,10 @@ struct mie_lex { enum mie_status lex_status; struct mie_ctx *lex_ctx; - b_queue lex_queue; + fx_queue lex_queue; - b_string *lex_temp; - b_queue lex_state; + fx_string *lex_temp; + fx_queue lex_state; unsigned int lex_brace_depth; struct mie_file_cell lex_token_start, lex_token_end; @@ -29,8 +29,8 @@ struct mie_lex_symbol_node { char s_char; struct lex_token_def *s_def; - b_queue_entry s_entry; - b_queue s_children; + fx_queue_entry s_entry; + fx_queue s_children; }; struct lex_token_def { diff --git a/mie/parse/line-source.c b/mie/parse/line-source.c index f8e2e8d..f2f976a 100644 --- a/mie/parse/line-source.c +++ b/mie/parse/line-source.c @@ -1,11 +1,11 @@ #include enum mie_status mie_line_source_init( - struct mie_line_source *src, const char *path, b_stream *stream) + struct mie_line_source *src, const char *path, fx_stream *stream) { memset(src, 0x0, sizeof *src); - src->s_lines = b_array_create(); + src->s_lines = fx_array_create(); if (!src->s_lines) { return MIE_ERR_NO_MEMORY; @@ -22,11 +22,11 @@ enum mie_status mie_line_source_init( void mie_line_source_cleanup(struct mie_line_source *src) { if (src->s_linebuf_ptr) { - b_iterator_unref(src->s_linebuf_ptr); + fx_iterator_unref(src->s_linebuf_ptr); } if (src->s_lines) { - b_array_unref(src->s_lines); + fx_array_unref(src->s_lines); } memset(src, 0x0, sizeof *src); @@ -50,31 +50,31 @@ static enum mie_status refill_linebuf(struct mie_line_source *src) } if (src->s_linebuf_ptr) { - b_iterator_unref(src->s_linebuf_ptr); + fx_iterator_unref(src->s_linebuf_ptr); src->s_linebuf_ptr = NULL; } - b_stringstream *s = b_stringstream_create(); + fx_stringstream *s = fx_stringstream_create(); - b_status status = b_stream_read_line_s(src->s_stream, s); + fx_status status = fx_stream_read_line_s(src->s_stream, s); - if (status == B_ERR_NO_DATA) { + if (status == FX_ERR_NO_DATA) { return MIE_ERR_EOF; } - if (!B_OK(status)) { + if (!FX_OK(status)) { return MIE_ERR_INTERNAL_FAILURE; } - b_string *line = b_string_create(); - b_string_replace_all_with_stringstream(line, s); - b_stringstream_unref(s); + fx_string *line = fx_string_create(); + fx_string_replace_all_with_stringstream(line, s); + fx_stringstream_unref(s); - b_array_append(src->s_lines, line); - b_string_unref(line); + fx_array_append(src->s_lines, line); + fx_string_unref(line); src->s_linebuf = line; - src->s_linebuf_ptr = b_iterator_begin(src->s_linebuf); + src->s_linebuf_ptr = fx_iterator_begin(src->s_linebuf); return MIE_SUCCESS; } @@ -83,7 +83,7 @@ static int peek(struct mie_line_source *src) { enum mie_status status = MIE_SUCCESS; - if (!src->s_linebuf_ptr || !b_iterator_is_valid(src->s_linebuf_ptr)) { + if (!src->s_linebuf_ptr || !fx_iterator_is_valid(src->s_linebuf_ptr)) { status = refill_linebuf(src); } @@ -91,11 +91,11 @@ static int peek(struct mie_line_source *src) return -status; } - if (b_string_get_size(src->s_linebuf, B_STRLEN_NORMAL) == 0) { + if (fx_string_get_size(src->s_linebuf, FX_STRLEN_NORMAL) == 0) { return -MIE_ERR_EOF; } - b_wchar c = b_iterator_get_value(src->s_linebuf_ptr).v_int; + fx_wchar c = fx_iterator_get_value(src->s_linebuf_ptr).v_int; return c; } @@ -103,7 +103,7 @@ static int advance(struct mie_line_source *src) { enum mie_status status = MIE_SUCCESS; - if (!b_iterator_is_valid(src->s_linebuf_ptr)) { + if (!fx_iterator_is_valid(src->s_linebuf_ptr)) { status = refill_linebuf(src); } @@ -111,12 +111,12 @@ static int advance(struct mie_line_source *src) return -status; } - if (b_string_get_size(src->s_linebuf, B_STRLEN_NORMAL) == 0) { + if (fx_string_get_size(src->s_linebuf, FX_STRLEN_NORMAL) == 0) { return -MIE_ERR_EOF; } - b_wchar c = b_iterator_get_value(src->s_linebuf_ptr).v_int; - b_iterator_move_next(src->s_linebuf_ptr); + fx_wchar c = fx_iterator_get_value(src->s_linebuf_ptr).v_int; + fx_iterator_move_next(src->s_linebuf_ptr); src->s_cursor.c_col++; if (c == '\n') { @@ -126,18 +126,18 @@ static int advance(struct mie_line_source *src) return c; } -b_wchar mie_line_source_peekc(struct mie_line_source *src) +fx_wchar mie_line_source_peekc(struct mie_line_source *src) { return peek(src); } -b_wchar mie_line_source_getc(struct mie_line_source *src) +fx_wchar mie_line_source_getc(struct mie_line_source *src) { return advance(src); } enum mie_status mie_line_source_get_row( - struct mie_line_source *src, size_t row, const b_string **out) + struct mie_line_source *src, size_t row, const fx_string **out) { if (row == 0) { return MIE_ERR_INVALID_ARGUMENT; @@ -145,11 +145,11 @@ enum mie_status mie_line_source_get_row( row--; - if (row >= b_array_size(src->s_lines)) { + if (row >= fx_array_size(src->s_lines)) { return MIE_ERR_EOF; } - b_string *line = b_array_at(src->s_lines, row); + fx_string *line = fx_array_at(src->s_lines, row); *out = line; return MIE_SUCCESS; @@ -157,5 +157,5 @@ enum mie_status mie_line_source_get_row( bool mie_line_source_input_available(struct mie_line_source *src) { - return src->s_linebuf_ptr && b_iterator_is_valid(src->s_linebuf_ptr); + return src->s_linebuf_ptr && fx_iterator_is_valid(src->s_linebuf_ptr); } diff --git a/mie/parse/parser.c b/mie/parse/parser.c index cab3ddd..b3f9a39 100644 --- a/mie/parse/parser.c +++ b/mie/parse/parser.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -25,49 +25,49 @@ struct mie_parser { struct mie_ctx *p_ctx; struct mie_lex *p_lex; enum mie_status p_status; - b_string *s_tmp; + fx_string *s_tmp; }; -static b_string *get_temp_string(struct mie_parser *parser) +static fx_string *get_temp_string(struct mie_parser *parser) { - b_string_clear(parser->s_tmp); + fx_string_clear(parser->s_tmp); return parser->s_tmp; } #define GET_SOMETHING_BY_FULL_NAME(thing) \ static const struct mie_##thing##_definition *get_##thing##_by_full_name( \ - struct mie_parser *ctx, b_string *name) \ + struct mie_parser *ctx, fx_string *name) \ { \ - b_string *dialect = b_string_create(); \ - b_string *item = b_string_create(); \ + fx_string *dialect = fx_string_create(); \ + fx_string *item = fx_string_create(); \ const char *delim[] = {"."}; \ size_t i = 0; \ - b_iterator *it = b_string_tokenise( \ - name, delim, 1, B_STRING_TOK_F_NORMAL); \ - while (b_iterator_is_valid(it)) { \ - const char *tok = b_iterator_get_cvalue(it).v_cptr; \ + fx_iterator *it = fx_string_tokenise( \ + name, delim, 1, FX_STRING_TOK_F_NORMAL); \ + while (fx_iterator_is_valid(it)) { \ + const char *tok = fx_iterator_get_cvalue(it).v_cptr; \ switch (i) { \ case 0: \ - b_string_append_cstr(dialect, tok); \ + fx_string_append_cstr(dialect, tok); \ break; \ case 1: \ - b_string_append_cstr(item, tok); \ + fx_string_append_cstr(item, tok); \ break; \ default: \ - b_string_append_c(item, '.'); \ - b_string_append_cstr(item, tok); \ + fx_string_append_c(item, '.'); \ + fx_string_append_cstr(item, tok); \ break; \ } \ - b_iterator_move_next(it); \ + fx_iterator_move_next(it); \ i++; \ } \ - b_iterator_unref(it); \ + fx_iterator_unref(it); \ const struct mie_##thing##_definition *def \ = mie_ctx_get_##thing##_definition( \ - ctx->p_ctx, b_string_ptr(dialect), \ - b_string_ptr(item)); \ - b_string_unref(dialect); \ - b_string_unref(item); \ + ctx->p_ctx, fx_string_ptr(dialect), \ + fx_string_ptr(item)); \ + fx_string_unref(dialect); \ + fx_string_unref(item); \ return def; \ } @@ -84,7 +84,7 @@ struct mie_parser *mie_parser_create(struct mie_ctx *ctx, struct mie_lex *lex) memset(out, 0x0, sizeof *out); - out->s_tmp = b_string_create(); + out->s_tmp = fx_string_create(); if (!out->s_tmp) { free(out); return NULL; @@ -100,7 +100,7 @@ struct mie_parser *mie_parser_create(struct mie_ctx *ctx, struct mie_lex *lex) void mie_parser_destroy(struct mie_parser *ctx) { if (ctx->s_tmp) { - b_string_unref(ctx->s_tmp); + fx_string_unref(ctx->s_tmp); } free(ctx); @@ -126,7 +126,7 @@ void mie_parser_set_status(struct mie_parser *ctx, enum mie_status status) ctx->p_status = status; } -b_string *mie_parser_get_tempstr(struct mie_parser *ctx) +fx_string *mie_parser_get_tempstr(struct mie_parser *ctx) { return get_temp_string(ctx); } @@ -217,7 +217,7 @@ bool mie_parser_parse_float( #define TOKEN_PARSER(name, id) \ bool mie_parser_parse_##name( \ - struct mie_parser *ctx, b_string *out, struct mie_file_span *loc) \ + struct mie_parser *ctx, fx_string *out, struct mie_file_span *loc) \ { \ if (!mie_parser_check_type(ctx, id)) { \ return false; \ @@ -225,10 +225,10 @@ bool mie_parser_parse_float( struct mie_token *tok = mie_lex_peek(ctx->p_lex); \ switch (tok->tok_value_type) { \ case MIE_TOK_V_STRING: \ - b_string_append_cstr(out, tok->tok_str); \ + fx_string_append_cstr(out, tok->tok_str); \ break; \ case MIE_TOK_V_INT: \ - b_string_append_cstrf(out, "%lld", tok->tok_int); \ + fx_string_append_cstrf(out, "%lld", tok->tok_int); \ break; \ default: \ return false; \ @@ -256,12 +256,12 @@ TOKEN_PARSER(string, MIE_TOK_STRING); bool mie_parser_parse_keyword( struct mie_parser *ctx, const char *kw, struct mie_file_span *loc) { - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); if (!mie_parser_parse_word(ctx, str, loc)) { return false; } - return strcmp(b_string_ptr(str), kw) == 0; + return strcmp(fx_string_ptr(str), kw) == 0; } bool mie_parser_parse_symbol(struct mie_parser *ctx, enum mie_token_symbol sym) @@ -294,7 +294,7 @@ static bool parse_builtin_type_name( struct mie_parser *ctx, const char *context, const struct mie_type **out, struct mie_file_span *out_span) { - b_string *name = get_temp_string(ctx); + fx_string *name = get_temp_string(ctx); struct mie_file_span loc; if (!mie_parser_parse_word(ctx, name, &loc)) { return false; @@ -315,7 +315,7 @@ static bool parse_builtin_type_name( FLOAT } base_type = NONE; - const char *name_cstr = b_string_ptr(name); + const char *name_cstr = fx_string_ptr(name); if (!strcmp(name_cstr, "memref")) { type_info = mie_ctx_get_type_definition( @@ -381,7 +381,7 @@ static bool parse_type_name( struct mie_parser *ctx, const char *context, const struct mie_type **out, struct mie_file_span *out_span) { - b_string *name = get_temp_string(ctx); + fx_string *name = get_temp_string(ctx); struct mie_file_span loc; if (!mie_parser_parse_typename(ctx, name, &loc)) { return false; @@ -625,16 +625,16 @@ MIE_API bool mie_parser_parse_function_type( bool mie_parser_parse_operand(struct mie_parser *ctx, struct mie_op_arg *out) { memset(out, 0x0, sizeof *out); - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); bool result = false; struct mie_file_span loc; if (mie_parser_parse_vregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL; result = true; } else if (mie_parser_parse_mregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE; result = true; } @@ -698,14 +698,14 @@ bool mie_parser_parse_parameter( const char *context) { memset(out, 0x0, sizeof *out); - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span loc; if (mie_parser_parse_vregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL; } else if (mie_parser_parse_mregname(ctx, str, &loc)) { - out->arg_unresolved.reg_name = b_string_steal(str); + out->arg_unresolved.reg_name = fx_string_steal(str); out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE; } else { struct mie_parser_item required[] = { @@ -823,16 +823,16 @@ bool mie_parser_parse_register( } struct mie_name *name = NULL; - b_string *tmp = get_temp_string(ctx); + fx_string *tmp = get_temp_string(ctx); switch (tok->tok_value_type) { case MIE_TOK_V_STRING: name = mie_parser_scope_put_name( scope, &out->reg_name, tok->tok_str, MIE_NAME_MAP_F_STRICT); break; case MIE_TOK_V_INT: - b_string_append_cstrf(tmp, "%lld", tok->tok_int); + fx_string_append_cstrf(tmp, "%lld", tok->tok_int); name = mie_parser_scope_put_name( - scope, &out->reg_name, b_string_ptr(tmp), + scope, &out->reg_name, fx_string_ptr(tmp), MIE_NAME_MAP_F_STRICT); break; default: @@ -1070,7 +1070,7 @@ bool mie_parser_parse_block( return NULL; } - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span span; if (!mie_parser_parse_blockname(ctx, str, &span)) { @@ -1078,7 +1078,7 @@ bool mie_parser_parse_block( } if (!mie_parser_scope_put_name( - scope, &block->b_name, b_string_ptr(str), + scope, &block->b_name, fx_string_ptr(str), MIE_NAME_MAP_F_STRICT)) { return false; } @@ -1120,14 +1120,14 @@ bool mie_parser_parse_block( bool mie_parser_parse_successor(struct mie_parser *ctx, struct mie_op_successor *out) { memset(out, 0x0, sizeof *out); - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); bool result = false; if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { return false; } - out->s_block_name = b_string_steal(str); + out->s_block_name = fx_string_steal(str); if (!mie_parser_parse_symbol(ctx, MIE_SYM_COLON)) { return true; @@ -1203,13 +1203,13 @@ bool mie_parser_parse_successor_list( static bool parse_custom_op( struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) { - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span loc; if (!mie_parser_parse_name(ctx, str, &dest->op_name_span)) { return false; } - dest->op_name = b_string_steal(str); + dest->op_name = fx_string_steal(str); if (!mie_resolve_op_self(dest, ctx->p_ctx)) { struct mie_diag *diag = mie_ctx_push_diag( @@ -1267,13 +1267,13 @@ static bool parse_custom_op( static bool parse_builtin_op( struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) { - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span loc; if (!mie_parser_parse_word(ctx, str, &loc)) { return false; } - dest->op_name = b_bstr_fmt(NULL, "builtin.%s", b_string_ptr(str)); + dest->op_name = fx_bstr_fmt(NULL, "builtin.%s", fx_string_ptr(str)); if (!mie_resolve_op_self(dest, ctx->p_ctx)) { struct mie_diag *diag = mie_ctx_push_diag( @@ -1331,13 +1331,13 @@ static bool parse_builtin_op( static bool parse_generic_op( struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) { - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span loc; if (!mie_parser_parse_opname(ctx, str, &loc)) { return false; } - dest->op_name = b_string_steal(str); + dest->op_name = fx_string_steal(str); /* resolve the op now. we need to know if the op is isolated-from-above * in order to add register/block names to the correct region name maps. */ @@ -1479,7 +1479,7 @@ bool mie_parser_parse_attribute( { enum mie_token_type type = mie_parser_peek_type(ctx); const struct mie_attribute_definition *attribute = NULL; - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span span; bool need_angle_delim = false; @@ -1554,13 +1554,13 @@ static bool parse_attribute_map_entry( struct mie_parser *ctx, char **out_name, const struct mie_attribute **out_value) { - b_string *str = get_temp_string(ctx); + fx_string *str = get_temp_string(ctx); struct mie_file_span span; if (!mie_parser_parse_word(ctx, str, &span)) { return false; } - char *name = b_string_steal(str); + char *name = fx_string_steal(str); if (!mie_parser_parse_symbol(ctx, MIE_SYM_EQUAL)) { free(name); @@ -1691,29 +1691,29 @@ void mie_parser_report_unexpected_token_v( struct mie_parser *parser, const struct mie_parser_item expected_tokens[], const char *context) { - b_bstr str; - b_bstr_begin_dynamic(&str); + fx_bstr str; + fx_bstr_begin_dynamic(&str); struct mie_token *tok = mie_lex_peek(parser->p_lex); - b_bstr_write_cstr(&str, "expected ", NULL); + fx_bstr_write_cstr(&str, "expected ", NULL); for (size_t i = 0; expected_tokens[i].i_type != MIE_PARSER_ITEM_NONE; i++) { bool end = expected_tokens[i + 1].i_type == MIE_PARSER_ITEM_NONE; if (end && i > 0) { - b_bstr_write_cstr(&str, " or ", NULL); + fx_bstr_write_cstr(&str, " or ", NULL); } else if (i > 0) { - b_bstr_write_cstr(&str, ", ", NULL); + fx_bstr_write_cstr(&str, ", ", NULL); } switch (expected_tokens[i].i_type) { case MIE_PARSER_ITEM_TOK: - b_bstr_write_fmt( + fx_bstr_write_fmt( &str, NULL, "[blue]%s[reset]", token_diag_string(expected_tokens[i].i_tok)); break; case MIE_PARSER_ITEM_CSTR: - b_bstr_write_fmt( + fx_bstr_write_fmt( &str, NULL, "[blue]%s[reset]", expected_tokens[i].i_cstr); break; @@ -1723,22 +1723,22 @@ void mie_parser_report_unexpected_token_v( } if (context) { - b_bstr_write_fmt( + fx_bstr_write_fmt( &str, NULL, " while parsing [cyan]%s[reset]", context); } - b_bstr_write_cstr(&str, "; found [red]", NULL); + fx_bstr_write_cstr(&str, "; found [red]", NULL); if (MIE_TOKEN_TYPE(tok) == MIE_TOK_SYMBOL) { - b_bstr_write_cstr(&str, token_diag_string(tok->tok_sym), NULL); + fx_bstr_write_cstr(&str, token_diag_string(tok->tok_sym), NULL); } else if (tok != NULL) { - b_bstr_write_cstr(&str, token_diag_string(tok->tok_type), NULL); + fx_bstr_write_cstr(&str, token_diag_string(tok->tok_type), NULL); } else { - b_bstr_write_cstr(&str, "end of file", NULL); + fx_bstr_write_cstr(&str, "end of file", NULL); } - b_bstr_write_cstr(&str, "[reset]", NULL); - b_bstr_write_cstr(&str, ".", NULL); + fx_bstr_write_cstr(&str, "[reset]", NULL); + fx_bstr_write_cstr(&str, ".", NULL); - char *s = b_bstr_end(&str); + char *s = fx_bstr_end(&str); const struct mie_file_cell *loc = tok ? &tok->tok_location.s_start : mie_lex_get_cursor(parser->p_lex); @@ -1766,28 +1766,28 @@ void mie_parser_report_unexpected_token_v( void mie_parser_report_unexpected_token_s( struct mie_parser *parser, const char *expected_token, const char *context) { - b_bstr str; - b_bstr_begin_dynamic(&str); + fx_bstr str; + fx_bstr_begin_dynamic(&str); struct mie_token *tok = mie_lex_peek(parser->p_lex); - b_bstr_write_fmt(&str, NULL, "expected [blue]%s[reset]", expected_token); + fx_bstr_write_fmt(&str, NULL, "expected [blue]%s[reset]", expected_token); if (context) { - b_bstr_write_fmt( + fx_bstr_write_fmt( &str, NULL, " while parsing [cyan]%s[reset]", context); } - b_bstr_write_cstr(&str, "; found [red]", NULL); + fx_bstr_write_cstr(&str, "; found [red]", NULL); if (MIE_TOKEN_TYPE(tok) == MIE_TOK_SYMBOL) { - b_bstr_write_cstr(&str, token_diag_string(tok->tok_sym), NULL); + fx_bstr_write_cstr(&str, token_diag_string(tok->tok_sym), NULL); } else if (tok != NULL) { - b_bstr_write_cstr(&str, token_diag_string(tok->tok_type), NULL); + fx_bstr_write_cstr(&str, token_diag_string(tok->tok_type), NULL); } else { - b_bstr_write_cstr(&str, "end of file", NULL); + fx_bstr_write_cstr(&str, "end of file", NULL); } - b_bstr_write_cstr(&str, "[reset].", NULL); + fx_bstr_write_cstr(&str, "[reset].", NULL); - char *s = b_bstr_end(&str); + char *s = fx_bstr_end(&str); const struct mie_file_cell *loc = tok ? &tok->tok_location.s_start : mie_lex_get_cursor(parser->p_lex); diff --git a/mie/pass/builtin/convert-scf-to-cf.c b/mie/pass/builtin/convert-scf-to-cf.c index fcdf24d..7fd9d2e 100644 --- a/mie/pass/builtin/convert-scf-to-cf.c +++ b/mie/pass/builtin/convert-scf-to-cf.c @@ -52,7 +52,7 @@ static struct mie_rewrite_result if_rewrite( struct mie_register *old_reg = &op->op_result.items[i]; struct mie_register *new_reg = mie_block_add_param(end_block); new_reg->reg_type = old_reg->reg_type; - char *name = b_strdup(old_reg->reg_name.n_str); + char *name = fx_strdup(old_reg->reg_name.n_str); mie_name_destroy(&old_reg->reg_name); mie_rewriter_rename_register(rewriter, new_reg, name); @@ -163,7 +163,7 @@ static struct mie_rewrite_result for_rewrite( struct mie_register *old_reg = &op->op_result.items[i]; struct mie_register *new_reg = mie_block_add_param(end_block); new_reg->reg_type = old_reg->reg_type; - char *name = b_strdup(old_reg->reg_name.n_str); + char *name = fx_strdup(old_reg->reg_name.n_str); mie_name_destroy(&old_reg->reg_name); mie_rewriter_rename_register(rewriter, new_reg, name); diff --git a/mie/pass/pass-manager.c b/mie/pass/pass-manager.c index 878badb..e25bf3a 100644 --- a/mie/pass/pass-manager.c +++ b/mie/pass/pass-manager.c @@ -1,4 +1,4 @@ -#include +#include #include #include #include @@ -16,13 +16,13 @@ struct pass_sched { struct mie_op *s_op; - b_queue_entry s_entry; + fx_queue_entry s_entry; /* queue of struct pass_sched_item */ - b_queue s_items; + fx_queue s_items; }; struct pass_sched_item { - b_queue_entry i_entry; + fx_queue_entry i_entry; struct mie_pass *i_pass; }; @@ -181,10 +181,10 @@ void mie_pass_manager_add_pass(struct mie_pass_manager *pm, struct mie_pass *pas } static void schedule_passes( - struct mie_pass_manager *pm, b_queue *schedule, struct mie_op *op, + struct mie_pass_manager *pm, fx_queue *schedule, struct mie_op *op, size_t depth) { - b_queue passes = B_QUEUE_INIT; + fx_queue passes = FX_QUEUE_INIT; if (!filter_check_op(&pm->pm_filter, op) || depth > pm->pm_depth) { return; } @@ -196,13 +196,13 @@ static void schedule_passes( } struct pass_sched_item *item = pass_sched_item_create(pass); - b_queue_push_back(&passes, &item->i_entry); + fx_queue_push_back(&passes, &item->i_entry); } - if (!b_queue_empty(&passes)) { + if (!fx_queue_empty(&passes)) { struct pass_sched *sched = pass_sched_create(op); sched->s_items = passes; - b_queue_push_back(schedule, &sched->s_entry); + fx_queue_push_back(schedule, &sched->s_entry); } struct mie_walker walker; @@ -236,14 +236,14 @@ static void sched_execute( struct pass_sched *sched, struct mie_pass_args *args, struct mie_pass_result *result) { - b_queue_entry *cur_item = NULL, *next_item = NULL; + fx_queue_entry *cur_item = NULL, *next_item = NULL; struct pass_sched_item *sched_item = NULL; - cur_item = b_queue_first(&sched->s_items); + cur_item = fx_queue_first(&sched->s_items); while (cur_item) { - sched_item = b_unbox(struct pass_sched_item, cur_item, i_entry); - next_item = b_queue_next(cur_item); - b_queue_delete(&sched->s_items, cur_item); + sched_item = fx_unbox(struct pass_sched_item, cur_item, i_entry); + next_item = fx_queue_next(cur_item); + fx_queue_delete(&sched->s_items, cur_item); sched_item_execute(sched_item, sched->s_op, args, result); @@ -255,10 +255,10 @@ static void sched_execute( struct mie_pass_result mie_pass_manager_run( struct mie_pass_manager *pm, struct mie_op *target) { - b_queue schedule = B_QUEUE_INIT; + fx_queue schedule = FX_QUEUE_INIT; schedule_passes(pm, &schedule, target, 0); - b_queue_entry *cur_sched = b_queue_first(&schedule), *next_sched = NULL; + fx_queue_entry *cur_sched = fx_queue_first(&schedule), *next_sched = NULL; struct pass_sched *sched = NULL; struct mie_pass_result result = MIE_PASS_CONTINUE; @@ -267,9 +267,9 @@ struct mie_pass_result mie_pass_manager_run( }; while (cur_sched) { - sched = b_unbox(struct pass_sched, cur_sched, s_entry); - next_sched = b_queue_next(cur_sched); - b_queue_delete(&schedule, cur_sched); + sched = fx_unbox(struct pass_sched, cur_sched, s_entry); + next_sched = fx_queue_next(cur_sched); + fx_queue_delete(&schedule, cur_sched); sched_execute(sched, &args, &result); diff --git a/mie/print/block.c b/mie/print/block.c index 779453c..eb6b6c2 100644 --- a/mie/print/block.c +++ b/mie/print/block.c @@ -31,42 +31,42 @@ static void print_block_header_params( return; } - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(block->b_params); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_register(printer, &block->b_params.items[i], 0); - b_stream_write_string(printer->p_stream, ": ", NULL); + fx_stream_write_string(printer->p_stream, ": ", NULL); mie_printer_print_type(printer, block->b_params.items[i].reg_type); } - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } static void print_block_header( struct mie_printer *printer, const struct mie_block *block) { - bool first_block = b_queue_prev(&block->b_entry) == NULL; + bool first_block = fx_queue_prev(&block->b_entry) == NULL; if (first_block && !block->b_name.n_str) { return; } - b_stream_write_char(printer->p_stream, '^'); + fx_stream_write_char(printer->p_stream, '^'); if (block->b_name.n_str) { - b_stream_write_string(printer->p_stream, block->b_name.n_str, NULL); + fx_stream_write_string(printer->p_stream, block->b_name.n_str, NULL); } else { - b_stream_write_string(printer->p_stream, "", NULL); + fx_stream_write_string(printer->p_stream, "", NULL); } print_block_header_params(printer, block); - b_stream_write_string(printer->p_stream, ":\n", NULL); + fx_stream_write_string(printer->p_stream, ":\n", NULL); } void mie_printer_print_block( @@ -77,16 +77,16 @@ void mie_printer_print_block( print_block_header(printer, block); } - b_stream_push_indent(printer->p_stream, 4); + fx_stream_push_indent(printer->p_stream, 4); struct mie_op *op = mie_block_get_first_op(block); while (op) { mie_printer_print_op(printer, op); - b_stream_write_char(printer->p_stream, '\n'); + fx_stream_write_char(printer->p_stream, '\n'); op = mie_block_get_next_op(block, op); } - b_stream_pop_indent(printer->p_stream); + fx_stream_pop_indent(printer->p_stream); } void mie_printer_print_block_ref( diff --git a/mie/print/op.c b/mie/print/op.c index 95cd306..46394c7 100644 --- a/mie/print/op.c +++ b/mie/print/op.c @@ -33,28 +33,28 @@ void mie_printer_print_op_arg( } if (arg_flags & MIE_REGISTER_F_MACHINE) { - b_stream_write_char(printer->p_stream, '$'); + fx_stream_write_char(printer->p_stream, '$'); } else { - b_stream_write_char(printer->p_stream, '%'); + fx_stream_write_char(printer->p_stream, '%'); } if (!arg_name) { arg_name = ""; } - b_stream_write_string(printer->p_stream, arg_name, NULL); + fx_stream_write_string(printer->p_stream, arg_name, NULL); if (!resolved && MIE_TEST_FLAGS( printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { - b_stream_write_char(printer->p_stream, '?'); + fx_stream_write_char(printer->p_stream, '?'); } if (!include_type || !arg_type) { return; } - b_stream_write_string(printer->p_stream, ": ", NULL); + fx_stream_write_string(printer->p_stream, ": ", NULL); mie_printer_print_type(printer, arg_type); } @@ -63,7 +63,7 @@ void mie_printer_print_op_successor( struct mie_printer *printer, const struct mie_op_successor *successor, bool compact) { - b_stream_write_char(printer->p_stream, '^'); + fx_stream_write_char(printer->p_stream, '^'); bool resolved = false; const char *name = NULL; @@ -78,12 +78,12 @@ void mie_printer_print_op_successor( name = ""; } - b_stream_write_string(printer->p_stream, name, NULL); + fx_stream_write_string(printer->p_stream, name, NULL); if (!resolved && MIE_TEST_FLAGS( printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { - b_stream_write_char(printer->p_stream, '?'); + fx_stream_write_char(printer->p_stream, '?'); } if (MIE_VECTOR_COUNT(successor->s_args) == 0) { @@ -91,20 +91,20 @@ void mie_printer_print_op_successor( } if (!compact) { - b_stream_write_char(printer->p_stream, ':'); + fx_stream_write_char(printer->p_stream, ':'); } - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(successor->s_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_arg(printer, &successor->s_args.items[i], true); } - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } static void print_successor_list( @@ -114,34 +114,34 @@ static void print_successor_list( return; } - b_stream_write_string(printer->p_stream, " [ ", NULL); + fx_stream_write_string(printer->p_stream, " [ ", NULL); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_successor( printer, &op->op_successors.items[i], false); } - b_stream_write_string(printer->p_stream, " ]", NULL); + fx_stream_write_string(printer->p_stream, " ]", NULL); } static void print_region_list(struct mie_printer *printer, const struct mie_op *op) { - if (b_queue_empty(&op->op_regions)) { + if (fx_queue_empty(&op->op_regions)) { return; } - b_stream_write_string(printer->p_stream, " (", NULL); + fx_stream_write_string(printer->p_stream, " (", NULL); struct mie_region *region = mie_op_get_first_region(op); size_t i = 0; while (region) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_region(printer, region, 0); @@ -150,13 +150,13 @@ static void print_region_list(struct mie_printer *printer, const struct mie_op * i++; } - b_stream_write_string(printer->p_stream, ")", NULL); + fx_stream_write_string(printer->p_stream, ")", NULL); } static void print_attribute( struct mie_printer *printer, const struct mie_attribute_map_iterator *attrib) { - b_stream_write_fmt(printer->p_stream, NULL, "%s = ", attrib->it_name); + fx_stream_write_fmt(printer->p_stream, NULL, "%s = ", attrib->it_name); mie_printer_print_attribute(printer, attrib->it_value); } @@ -167,7 +167,7 @@ static void print_attribute_list( return; } - b_stream_write_string(printer->p_stream, " { ", NULL); + fx_stream_write_string(printer->p_stream, " { ", NULL); struct mie_attribute_map_iterator it; enum mie_status status @@ -176,7 +176,7 @@ static void print_attribute_list( while (status == MIE_SUCCESS) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } print_attribute(printer, &it); @@ -184,18 +184,18 @@ static void print_attribute_list( i++; } - b_stream_write_string(printer->p_stream, " }", NULL); + fx_stream_write_string(printer->p_stream, " }", NULL); } static void print_type_signature( struct mie_printer *printer, const struct mie_op *op) { const struct mie_type *type = NULL; - b_stream_write_string(printer->p_stream, " : (", NULL); + fx_stream_write_string(printer->p_stream, " : (", NULL); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } const struct mie_op_arg *arg = &op->op_args.items[i]; @@ -208,15 +208,15 @@ static void print_type_signature( mie_printer_print_type(printer, type); } - b_stream_write_string(printer->p_stream, ") -> ", NULL); + fx_stream_write_string(printer->p_stream, ") -> ", NULL); if (MIE_VECTOR_COUNT(op->op_result) != 1) { - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); } for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } type = op->op_result.items[i].reg_type; @@ -224,38 +224,38 @@ static void print_type_signature( } if (MIE_VECTOR_COUNT(op->op_result) != 1) { - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); } } static void print_generic_op(struct mie_printer *printer, const struct mie_op *op) { - b_stream_write_char(printer->p_stream, '~'); + fx_stream_write_char(printer->p_stream, '~'); if (op->op_flags & MIE_OP_F_OP_RESOLVED) { - b_stream_write_fmt( + fx_stream_write_fmt( printer->p_stream, NULL, "%s.%s", op->op_info->op_parent->d_name, op->op_info->op_name); } else { - b_stream_write_string(printer->p_stream, op->op_name, NULL); + fx_stream_write_string(printer->p_stream, op->op_name, NULL); if (MIE_TEST_FLAGS( printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { - b_stream_write_char(printer->p_stream, '?'); + fx_stream_write_char(printer->p_stream, '?'); } } - b_stream_write_char(printer->p_stream, '('); + fx_stream_write_char(printer->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_op_arg(printer, &op->op_args.items[i], false); } - b_stream_write_char(printer->p_stream, ')'); + fx_stream_write_char(printer->p_stream, ')'); print_successor_list(printer, op); print_region_list(printer, op); @@ -267,14 +267,14 @@ void mie_printer_print_op(struct mie_printer *printer, const struct mie_op *op) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { if (i > 0) { - b_stream_write_string(printer->p_stream, ", ", NULL); + fx_stream_write_string(printer->p_stream, ", ", NULL); } mie_printer_print_register(printer, &op->op_result.items[i], 0); } if (MIE_VECTOR_COUNT(op->op_result) > 0) { - b_stream_write_string(printer->p_stream, " = ", NULL); + fx_stream_write_string(printer->p_stream, " = ", NULL); } bool use_generic = !op->op_info || !op->op_info->op_print @@ -307,23 +307,23 @@ void mie_printer_print_op_name(struct mie_printer *printer, const struct mie_op if (printer->p_flags & MIE_PRINT_F_GENERIC) { generic = true; - b_stream_write_char(printer->p_stream, '~'); + fx_stream_write_char(printer->p_stream, '~'); } else if (!strcmp(op->op_info->op_parent->d_name, "builtin")) { builtin = true; } if (!resolved) { - b_stream_write_string(printer->p_stream, op->op_name, NULL); + fx_stream_write_string(printer->p_stream, op->op_name, NULL); return; } if (generic || !builtin || !abbreviate) { - b_stream_write_fmt( + fx_stream_write_fmt( printer->p_stream, NULL, "%s.", op->op_info->op_parent->d_name); } - b_stream_write_string(printer->p_stream, op->op_info->op_name, NULL); + fx_stream_write_string(printer->p_stream, op->op_info->op_name, NULL); return; } diff --git a/mie/print/printer.c b/mie/print/printer.c index 9391658..1144c5f 100644 --- a/mie/print/printer.c +++ b/mie/print/printer.c @@ -1,7 +1,7 @@ #include enum mie_status mie_printer_init( - struct mie_printer *printer, struct mie_ctx *ctx, b_stream *out, + struct mie_printer *printer, struct mie_ctx *ctx, fx_stream *out, enum mie_print_flags flags) { memset(printer, 0x0, sizeof *printer); diff --git a/mie/print/region.c b/mie/print/region.c index 5d73e41..f975c66 100644 --- a/mie/print/region.c +++ b/mie/print/region.c @@ -6,7 +6,7 @@ void mie_printer_print_region( struct mie_printer *printer, const struct mie_region *region, enum mie_print_flags flags) { - b_stream_write_string(printer->p_stream, "{\n", NULL); + fx_stream_write_string(printer->p_stream, "{\n", NULL); struct mie_block *block = mie_region_get_first_block(region); size_t i = 0; @@ -24,5 +24,5 @@ void mie_printer_print_region( i++; } - b_stream_write_string(printer->p_stream, "}", NULL); + fx_stream_write_string(printer->p_stream, "}", NULL); } diff --git a/mie/print/register.c b/mie/print/register.c index 5c6c57d..6463fc9 100644 --- a/mie/print/register.c +++ b/mie/print/register.c @@ -6,18 +6,18 @@ void mie_printer_print_register( enum mie_print_flags flags) { if (reg->reg_flags & MIE_REGISTER_F_VIRTUAL) { - b_stream_write_fmt( + fx_stream_write_fmt( printer->p_stream, NULL, "%%%s", reg->reg_name.n_str); } else if (reg->reg_flags & MIE_REGISTER_F_MACHINE) { // TODO this shouldnt use reg_name - b_stream_write_fmt( + fx_stream_write_fmt( printer->p_stream, NULL, "$%s", reg->reg_name.n_str); } else { - b_stream_write_string(printer->p_stream, "?REG", NULL); + fx_stream_write_string(printer->p_stream, "?REG", NULL); } if (flags & MIE_PRINT_F_INCLUDE_TYPE) { - b_stream_write_string(printer->p_stream, ": ", NULL); + fx_stream_write_string(printer->p_stream, ": ", NULL); mie_printer_print_type(printer, reg->reg_type); } } diff --git a/mie/print/type.c b/mie/print/type.c index 96fcef1..c2daaed 100644 --- a/mie/print/type.c +++ b/mie/print/type.c @@ -13,23 +13,23 @@ void mie_printer_print_type(struct mie_printer *printer, const struct mie_type *type) { if (!type) { - b_stream_write_string(printer->p_stream, "", NULL); + fx_stream_write_string(printer->p_stream, "", NULL); return; } if (TYPE_HAS_PRINT_CALLBACK(type)) { type->ty_def->ty_print(type, printer); } else if (TYPE_IS_BUILTIN(type)) { - b_stream_write_string( + fx_stream_write_string( printer->p_stream, type->ty_def->ty_name, NULL); } else if (TYPE_HAS_NAME(type)) { - b_stream_write_char(printer->p_stream, '!'); - b_stream_write_string(printer->p_stream, type->ty_name, NULL); + fx_stream_write_char(printer->p_stream, '!'); + fx_stream_write_string(printer->p_stream, type->ty_name, NULL); } else if (TYPE_DEF_HAS_NAME(type)) { - b_stream_write_char(printer->p_stream, '!'); - b_stream_write_string( + fx_stream_write_char(printer->p_stream, '!'); + fx_stream_write_string( printer->p_stream, type->ty_def->ty_name, NULL); } else { - b_stream_write_string(printer->p_stream, "", NULL); + fx_stream_write_string(printer->p_stream, "", NULL); } } diff --git a/mie/rewrite/rewriter.c b/mie/rewrite/rewriter.c index b6afc60..070bf6e 100644 --- a/mie/rewrite/rewriter.c +++ b/mie/rewrite/rewriter.c @@ -93,12 +93,12 @@ struct mie_block *mie_rewriter_split_block( struct mie_block *new_block = mie_region_add_block_after(region, block); mie_name_map_put(names, &new_block->b_name, name, 0); - b_queue_entry *cur = &before->op_entry; + fx_queue_entry *cur = &before->op_entry; while (cur) { - struct mie_op *cur_op = b_unbox(struct mie_op, cur, op_entry); - b_queue_entry *next = b_queue_next(cur); - b_queue_delete(&block->b_ops, cur); - b_queue_push_back(&new_block->b_ops, cur); + struct mie_op *cur_op = fx_unbox(struct mie_op, cur, op_entry); + fx_queue_entry *next = fx_queue_next(cur); + fx_queue_delete(&block->b_ops, cur); + fx_queue_push_back(&new_block->b_ops, cur); cur_op->op_container = new_block; cur = next; @@ -142,8 +142,8 @@ enum mie_status mie_rewriter_move_block_to_start( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->r_blocks, &block->b_entry); - b_queue_push_front(&to->r_blocks, &block->b_entry); + fx_queue_delete(&from->r_blocks, &block->b_entry); + fx_queue_push_front(&to->r_blocks, &block->b_entry); block->b_parent = to; @@ -158,8 +158,8 @@ enum mie_status mie_rewriter_move_block_to_end( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->r_blocks, &block->b_entry); - b_queue_push_back(&to->r_blocks, &block->b_entry); + fx_queue_delete(&from->r_blocks, &block->b_entry); + fx_queue_push_back(&to->r_blocks, &block->b_entry); block->b_parent = to; @@ -178,8 +178,8 @@ enum mie_status mie_rewriter_move_block_before( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->r_blocks, &block->b_entry); - b_queue_insert_before(&to->r_blocks, &block->b_entry, &before->b_entry); + fx_queue_delete(&from->r_blocks, &block->b_entry); + fx_queue_insert_before(&to->r_blocks, &block->b_entry, &before->b_entry); block->b_parent = to; @@ -198,8 +198,8 @@ enum mie_status mie_rewriter_move_block_after( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->r_blocks, &block->b_entry); - b_queue_insert_after(&to->r_blocks, &block->b_entry, &after->b_entry); + fx_queue_delete(&from->r_blocks, &block->b_entry); + fx_queue_insert_after(&to->r_blocks, &block->b_entry, &after->b_entry); block->b_parent = to; @@ -221,18 +221,18 @@ enum mie_status mie_rewriter_rename_block( enum mie_status mie_rewriter_move_blocks_to_start( struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to) { - b_queue_entry *cur = b_queue_first(&from->r_blocks); - b_queue_entry *insert_point = NULL; + fx_queue_entry *cur = fx_queue_first(&from->r_blocks); + fx_queue_entry *insert_point = NULL; while (cur) { - b_queue_entry *next = b_queue_next(cur); + fx_queue_entry *next = fx_queue_next(cur); - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); - b_queue_delete(&from->r_blocks, cur); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); + fx_queue_delete(&from->r_blocks, cur); if (insert_point) { - b_queue_insert_after(&to->r_blocks, cur, insert_point); + fx_queue_insert_after(&to->r_blocks, cur, insert_point); } else { - b_queue_push_front(&to->r_blocks, cur); + fx_queue_push_front(&to->r_blocks, cur); } block->b_parent = to; @@ -246,13 +246,13 @@ enum mie_status mie_rewriter_move_blocks_to_start( enum mie_status mie_rewriter_move_blocks_to_end( struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to) { - b_queue_entry *cur = b_queue_first(&from->r_blocks); + fx_queue_entry *cur = fx_queue_first(&from->r_blocks); while (cur) { - b_queue_entry *next = b_queue_next(cur); + fx_queue_entry *next = fx_queue_next(cur); - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); - b_queue_delete(&from->r_blocks, cur); - b_queue_push_back(&to->r_blocks, cur); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); + fx_queue_delete(&from->r_blocks, cur); + fx_queue_push_back(&to->r_blocks, cur); block->b_parent = to; cur = next; @@ -269,13 +269,13 @@ enum mie_status mie_rewriter_move_blocks_before( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_entry *cur = b_queue_last(&from->r_blocks); + fx_queue_entry *cur = fx_queue_last(&from->r_blocks); while (cur) { - b_queue_entry *next = b_queue_prev(cur); + fx_queue_entry *next = fx_queue_prev(cur); - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); - b_queue_delete(&from->r_blocks, cur); - b_queue_insert_before(&to->r_blocks, cur, &before->b_entry); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); + fx_queue_delete(&from->r_blocks, cur); + fx_queue_insert_before(&to->r_blocks, cur, &before->b_entry); block->b_parent = to; cur = next; @@ -292,15 +292,15 @@ enum mie_status mie_rewriter_move_blocks_after( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_entry *cur = b_queue_first(&from->r_blocks); - b_queue_entry *insert_point = &after->b_entry; + fx_queue_entry *cur = fx_queue_first(&from->r_blocks); + fx_queue_entry *insert_point = &after->b_entry; while (cur) { - b_queue_entry *next = b_queue_next(cur); + fx_queue_entry *next = fx_queue_next(cur); - struct mie_block *block = b_unbox(struct mie_block, cur, b_entry); - b_queue_delete(&from->r_blocks, cur); - b_queue_insert_after(&to->r_blocks, cur, insert_point); + struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry); + fx_queue_delete(&from->r_blocks, cur); + fx_queue_insert_after(&to->r_blocks, cur, insert_point); block->b_parent = to; insert_point = cur; @@ -318,8 +318,8 @@ enum mie_status mie_rewriter_move_region_to_start( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->op_regions, ®ion->r_entry); - b_queue_push_front(&to->op_regions, ®ion->r_entry); + fx_queue_delete(&from->op_regions, ®ion->r_entry); + fx_queue_push_front(&to->op_regions, ®ion->r_entry); region->r_parent = to; @@ -334,8 +334,8 @@ enum mie_status mie_rewriter_move_region_to_end( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->op_regions, ®ion->r_entry); - b_queue_push_back(&to->op_regions, ®ion->r_entry); + fx_queue_delete(&from->op_regions, ®ion->r_entry); + fx_queue_push_back(&to->op_regions, ®ion->r_entry); region->r_parent = to; @@ -354,8 +354,8 @@ enum mie_status mie_rewriter_move_region_before( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->op_regions, ®ion->r_entry); - b_queue_insert_before(&to->op_regions, ®ion->r_entry, &before->r_entry); + fx_queue_delete(&from->op_regions, ®ion->r_entry); + fx_queue_insert_before(&to->op_regions, ®ion->r_entry, &before->r_entry); region->r_parent = to; @@ -374,8 +374,8 @@ enum mie_status mie_rewriter_move_region_after( return MIE_ERR_INVALID_ARGUMENT; } - b_queue_delete(&from->op_regions, ®ion->r_entry); - b_queue_insert_after(&to->op_regions, ®ion->r_entry, &after->r_entry); + fx_queue_delete(&from->op_regions, ®ion->r_entry); + fx_queue_insert_after(&to->op_regions, ®ion->r_entry, &after->r_entry); region->r_parent = to; @@ -410,7 +410,7 @@ struct mie_op *mie_rewriter_put_op( arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_value.u_reg = args[i]; arg->arg_value.u_user = op; - b_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&args[i]->reg_use, &arg->arg_value.u_entry); } return op; @@ -439,7 +439,7 @@ struct mie_op_arg *mie_rewriter_add_op_arg( arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_value.u_reg = value; arg->arg_value.u_user = op; - b_queue_push_back(&value->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&value->reg_use, &arg->arg_value.u_entry); return arg; } @@ -452,7 +452,7 @@ MIE_API struct mie_op_arg *mie_rewriter_add_op_successor_arg( arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_value.u_reg = value; arg->arg_value.u_user = op; - b_queue_push_back(&value->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&value->reg_use, &arg->arg_value.u_entry); return arg; } @@ -471,7 +471,7 @@ enum mie_status mie_rewriter_erase_op(struct mie_rewriter *rw, struct mie_op *op return MIE_ERR_BAD_STATE; } - b_queue_delete(&parent->b_ops, &op->op_entry); + fx_queue_delete(&parent->b_ops, &op->op_entry); for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) { struct mie_op_successor *s = &op->op_successors.items[i]; @@ -481,7 +481,7 @@ enum mie_status mie_rewriter_erase_op(struct mie_rewriter *rw, struct mie_op *op continue; } - b_queue_delete( + fx_queue_delete( &arg->arg_value.u_reg->reg_use, &arg->arg_value.u_entry); } @@ -493,21 +493,21 @@ enum mie_status mie_rewriter_erase_op(struct mie_rewriter *rw, struct mie_op *op continue; } - b_queue_delete( + fx_queue_delete( &arg->arg_value.u_reg->reg_use, &arg->arg_value.u_entry); } for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) { struct mie_register *reg = &op->op_result.items[i]; - b_queue_entry *cur = b_queue_first(®->reg_use); + fx_queue_entry *cur = fx_queue_first(®->reg_use); while (cur) { - b_queue_entry *next = b_queue_next(cur); + fx_queue_entry *next = fx_queue_next(cur); struct mie_register_use *use - = b_unbox(struct mie_register_use, cur, u_entry); + = fx_unbox(struct mie_register_use, cur, u_entry); - b_queue_delete(®->reg_use, &use->u_entry); + fx_queue_delete(®->reg_use, &use->u_entry); use->u_reg = NULL; cur = next; } @@ -529,14 +529,14 @@ enum mie_status mie_rewriter_move_op_args_to_successor( struct mie_register *reg = NULL; if (src->arg_flags & MIE_OP_F_ARG_RESOLVED) { reg = src->arg_value.u_reg; - b_queue_delete(®->reg_use, &src->arg_value.u_entry); + fx_queue_delete(®->reg_use, &src->arg_value.u_entry); } memcpy(dest, src, sizeof *src); if (reg) { memset(&dest->arg_value.u_entry, 0x0, sizeof dest->arg_value.u_entry); - b_queue_push_back(®->reg_use, &dest->arg_value.u_entry); + fx_queue_push_back(®->reg_use, &dest->arg_value.u_entry); } } @@ -558,9 +558,9 @@ static enum mie_status replace_register_usage( continue; } - b_queue_delete(&old->reg_use, &arg->arg_value.u_entry); + fx_queue_delete(&old->reg_use, &arg->arg_value.u_entry); arg->arg_value.u_reg = new; - b_queue_push_back(&new->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&new->reg_use, &arg->arg_value.u_entry); } for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) { @@ -575,9 +575,9 @@ static enum mie_status replace_register_usage( continue; } - b_queue_delete(&old->reg_use, &arg->arg_value.u_entry); + fx_queue_delete(&old->reg_use, &arg->arg_value.u_entry); arg->arg_value.u_reg = new; - b_queue_push_back(&new->reg_use, &arg->arg_value.u_entry); + fx_queue_push_back(&new->reg_use, &arg->arg_value.u_entry); } } @@ -587,17 +587,17 @@ static enum mie_status replace_register_usage( enum mie_status mie_rewriter_replace_register( struct mie_rewriter *rw, struct mie_register *old, struct mie_register *new) { - b_queue_entry *cur = b_queue_first(&old->reg_use); + fx_queue_entry *cur = fx_queue_first(&old->reg_use); while (cur) { struct mie_register_use *use - = b_unbox(struct mie_register_use, cur, u_entry); + = fx_unbox(struct mie_register_use, cur, u_entry); struct mie_op *op = use->u_user; if (use->u_reg == old) { replace_register_usage(op, old, new); } - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } return MIE_SUCCESS; diff --git a/mie/status.c b/mie/status.c index 454fb71..a0a0af7 100644 --- a/mie/status.c +++ b/mie/status.c @@ -1,31 +1,31 @@ -#include +#include #include #include -static const b_error_definition error_defs[] = { - B_ERROR_DEFINITION(MIE_SUCCESS, "SUCCESS", "Success"), - B_ERROR_DEFINITION(MIE_ERR_EOF, "EOF", "Unexpected end of file"), - B_ERROR_DEFINITION(MIE_ERR_BAD_SYNTAX, "BAD_SYNTAX", "Invalid syntax"), - B_ERROR_DEFINITION(MIE_ERR_NO_MEMORY, "NO_MEMORY", "Out of memory"), - B_ERROR_DEFINITION( +static const fx_error_definition error_defs[] = { + FX_ERROR_DEFINITION(MIE_SUCCESS, "SUCCESS", "Success"), + FX_ERROR_DEFINITION(MIE_ERR_EOF, "EOF", "Unexpected end of file"), + FX_ERROR_DEFINITION(MIE_ERR_BAD_SYNTAX, "BAD_SYNTAX", "Invalid syntax"), + FX_ERROR_DEFINITION(MIE_ERR_NO_MEMORY, "NO_MEMORY", "Out of memory"), + FX_ERROR_DEFINITION( MIE_ERR_NOT_SUPPORTED, "NOT_SUPPORTED", "Operation not supported"), - B_ERROR_DEFINITION( + FX_ERROR_DEFINITION( MIE_ERR_INTERNAL_FAILURE, "INTERNAL_FAILURE", "Internal failure"), - B_ERROR_DEFINITION( + FX_ERROR_DEFINITION( MIE_ERR_INVALID_VALUE, "INVALID_VALUE", "Invalid value"), - B_ERROR_DEFINITION(MIE_ERR_NO_ENTRY, "NO_ENTRY", "Name does not exist"), - B_ERROR_DEFINITION(MIE_ERR_BAD_FORMAT, "BAD_FORMAT", "Bad format"), + FX_ERROR_DEFINITION(MIE_ERR_NO_ENTRY, "NO_ENTRY", "Name does not exist"), + FX_ERROR_DEFINITION(MIE_ERR_BAD_FORMAT, "BAD_FORMAT", "Bad format"), }; -static const b_error_vendor error_vendor = { +static const fx_error_vendor error_vendor = { .v_name = "Mie", .v_error_definitions = error_defs, .v_error_definitions_length = sizeof error_defs, }; -const struct b_error_vendor *mie_error_vendor(void) +const struct fx_error_vendor *mie_error_vendor(void) { return &error_vendor; } diff --git a/mie/trait/trait-definition.c b/mie/trait/trait-definition.c index 3d6041a..31ca2a3 100644 --- a/mie/trait/trait-definition.c +++ b/mie/trait/trait-definition.c @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -12,7 +12,7 @@ struct mie_trait_definition *mie_trait_definition_create( memset(out, 0x0, sizeof *out); - out->tr_name = b_strdup(name); + out->tr_name = fx_strdup(name); if (!out->tr_name) { free(out); return NULL; @@ -20,7 +20,7 @@ struct mie_trait_definition *mie_trait_definition_create( out->tr_parent = parent; - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&parent->d_traits, &out->tr_id, &name_rope); return out; diff --git a/mie/trait/trait-table.c b/mie/trait/trait-table.c index 5e7a67e..e1c30c1 100644 --- a/mie/trait/trait-table.c +++ b/mie/trait/trait-table.c @@ -20,7 +20,7 @@ struct generic_trait { /* generic trait ID. */ mie_id g_id; /* list of struct unique_trait */ - b_queue g_traits; + fx_queue g_traits; }; static struct unique_trait *unique_trait_create(const struct mie_trait *trait) @@ -56,19 +56,19 @@ static struct generic_trait *generic_trait_create(const struct mie_trait *trait) return NULL; } - b_queue_push_back(&out->g_traits, &entry->u_id.e_entry); + fx_queue_push_back(&out->g_traits, &entry->u_id.e_entry); return out; } static void generic_trait_destroy(struct generic_trait *trait) { - b_queue_entry *cur = b_queue_first(&trait->g_traits); + fx_queue_entry *cur = fx_queue_first(&trait->g_traits); while (cur) { - b_queue_entry *next = b_queue_next(cur); - b_queue_delete(&trait->g_traits, cur); + fx_queue_entry *next = fx_queue_next(cur); + fx_queue_delete(&trait->g_traits, cur); struct unique_trait *u - = b_unbox(struct unique_trait, cur, u_id.e_entry); + = fx_unbox(struct unique_trait, cur, u_id.e_entry); unique_trait_destroy(u); cur = next; } @@ -106,7 +106,7 @@ const struct mie_trait *mie_trait_table_get_unique( const mie_id *result = mie_id_map_get(&table->tr_unique, &id); const struct unique_trait *entry - = b_unbox(struct unique_trait, result, u_id); + = fx_unbox(struct unique_trait, result, u_id); return entry ? entry->u_trait : NULL; } @@ -143,7 +143,7 @@ static enum mie_status put_generic_trait( mie_id *target = mie_id_map_get(&table->tr_generic, &id); struct generic_trait *generic - = b_unbox(struct generic_trait, target, g_id); + = fx_unbox(struct generic_trait, target, g_id); if (!generic) { generic = generic_trait_create(trait); @@ -160,7 +160,7 @@ static enum mie_status put_generic_trait( return MIE_ERR_NO_MEMORY; } - b_queue_push_back(&generic->g_traits, &unique->u_id.e_entry); + fx_queue_push_back(&generic->g_traits, &unique->u_id.e_entry); return MIE_SUCCESS; } @@ -189,17 +189,17 @@ enum mie_status mie_trait_table_get_generic( const mie_id *result = mie_id_map_get(&table->tr_unique, &id); const struct generic_trait *entry - = b_unbox(struct generic_trait, entry, g_id); + = fx_unbox(struct generic_trait, entry, g_id); - if (!entry || b_queue_empty(&entry->g_traits)) { + if (!entry || fx_queue_empty(&entry->g_traits)) { return MIE_ERR_NO_ENTRY; } memset(it, 0x0, sizeof *it); - it->_e = b_queue_first(&entry->g_traits); + it->_e = fx_queue_first(&entry->g_traits); struct unique_trait *trait - = b_unbox(struct unique_trait, it->_e, u_id.e_entry); + = fx_unbox(struct unique_trait, it->_e, u_id.e_entry); it->it_trait = trait->u_trait; @@ -216,7 +216,7 @@ enum mie_status mie_trait_table_iterate( while (it.it_id) { const struct unique_trait *trait - = b_unbox(struct unique_trait, it.it_id, u_id); + = fx_unbox(struct unique_trait, it.it_id, u_id); ret = func(trait->u_trait, arg); if (ret != 0) { @@ -230,19 +230,19 @@ enum mie_status mie_trait_table_iterate( while (it.it_id) { const struct generic_trait *trait_group - = b_unbox(struct generic_trait, it.it_id, g_id); + = fx_unbox(struct generic_trait, it.it_id, g_id); - const b_queue_entry *cur = b_queue_first(&trait_group->g_traits); + const fx_queue_entry *cur = fx_queue_first(&trait_group->g_traits); while (cur) { const struct unique_trait *trait - = b_unbox(struct unique_trait, cur, u_id.e_entry); + = fx_unbox(struct unique_trait, cur, u_id.e_entry); ret = func(trait->u_trait, arg); if (ret != 0) { return MIE_SUCCESS; } - cur = b_queue_next(cur); + cur = fx_queue_next(cur); } mie_id_map_iterator_move_next(&it); @@ -258,13 +258,13 @@ enum mie_status mie_trait_table_iterator_move_next( return MIE_ERR_NO_ENTRY; } - it->_e = b_queue_next(it->_e); + it->_e = fx_queue_next(it->_e); if (!it->_e) { return MIE_ERR_NO_ENTRY; } struct unique_trait *trait - = b_unbox(struct unique_trait, it->_e, u_id.e_entry); + = fx_unbox(struct unique_trait, it->_e, u_id.e_entry); it->it_trait = trait->u_trait; return MIE_SUCCESS; diff --git a/mie/trait/trait.c b/mie/trait/trait.c index 576e21a..56c7294 100644 --- a/mie/trait/trait.c +++ b/mie/trait/trait.c @@ -1,15 +1,15 @@ #include #include -void mie_trait_print(const struct mie_trait *trait, b_stream *out) +void mie_trait_print(const struct mie_trait *trait, fx_stream *out) { if (trait->tr_name) { - b_stream_write_string(out, trait->tr_name, NULL); + fx_stream_write_string(out, trait->tr_name, NULL); } else if (trait->tr_def && trait->tr_def->tr_print) { trait->tr_def->tr_print(trait->tr_def, trait, out); } else if (trait->tr_def->tr_name) { - b_stream_write_string(out, trait->tr_def->tr_name, NULL); + fx_stream_write_string(out, trait->tr_def->tr_name, NULL); } else { - b_stream_write_string(out, "", NULL); + fx_stream_write_string(out, "", NULL); } } diff --git a/mie/type/function.c b/mie/type/function.c index 6c169a9..b45d1b4 100644 --- a/mie/type/function.c +++ b/mie/type/function.c @@ -21,34 +21,34 @@ static enum mie_status type_print( const struct mie_function_type *func = (const struct mie_function_type *)type; - b_stream_write_char(out->p_stream, '('); + fx_stream_write_char(out->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_in); i++) { if (i > 0) { - b_stream_write_string(out->p_stream, ", ", NULL); + fx_stream_write_string(out->p_stream, ", ", NULL); } mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_in, i)); } - b_stream_write_string(out->p_stream, ") -> ", NULL); + fx_stream_write_string(out->p_stream, ") -> ", NULL); if (MIE_VECTOR_COUNT(func->func_out) == 1) { mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, 0)); return MIE_SUCCESS; } - b_stream_write_char(out->p_stream, '('); + fx_stream_write_char(out->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_out); i++) { if (i > 0) { - b_stream_write_string(out->p_stream, ", ", NULL); + fx_stream_write_string(out->p_stream, ", ", NULL); } mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, i)); } - b_stream_write_char(out->p_stream, ')'); + fx_stream_write_char(out->p_stream, ')'); return MIE_SUCCESS; } diff --git a/mie/type/storage.c b/mie/type/storage.c index 82352eb..2ca1ca8 100644 --- a/mie/type/storage.c +++ b/mie/type/storage.c @@ -20,17 +20,17 @@ static enum mie_status type_print( { const struct mie_storage_type *storage = (const struct mie_storage_type *)type; - b_stream_write_char(out->p_stream, '('); + fx_stream_write_char(out->p_stream, '('); for (size_t i = 0; i < MIE_VECTOR_COUNT(storage->st_parts); i++) { if (i > 0) { - b_stream_write_string(out->p_stream, ", ", NULL); + fx_stream_write_string(out->p_stream, ", ", NULL); } mie_printer_print_type(out, storage->st_parts.items[i]); } - b_stream_write_char(out->p_stream, ')'); + fx_stream_write_char(out->p_stream, ')'); return MIE_SUCCESS; } diff --git a/mie/type/type-definition.c b/mie/type/type-definition.c index eb157a9..6cdf21b 100644 --- a/mie/type/type-definition.c +++ b/mie/type/type-definition.c @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -12,7 +12,7 @@ struct mie_type_definition *mie_type_definition_create( memset(out, 0x0, sizeof *out); - out->ty_name = b_strdup(name); + out->ty_name = fx_strdup(name); if (!out->ty_name) { free(out); return NULL; @@ -21,7 +21,7 @@ struct mie_type_definition *mie_type_definition_create( out->ty_parent = parent; mie_trait_table_init(&out->ty_traits); - b_rope name_rope = B_ROPE_CSTR(name); + fx_rope name_rope = FX_ROPE_CSTR(name); mie_id_map_put(&parent->d_types, &out->ty_id, &name_rope); return out; diff --git a/tool/CMakeLists.txt b/tool/CMakeLists.txt index f88f9ea..74e73f0 100644 --- a/tool/CMakeLists.txt +++ b/tool/CMakeLists.txt @@ -12,9 +12,9 @@ add_executable(mie-tool ${tool_sources} ${rc_file}) target_link_libraries( mie-tool mie - Bluelib::Core - Bluelib::Ds - Bluelib::Cmd) + FX::Core + FX::Ds + FX::Cmd) set_target_properties(mie-tool PROPERTIES OUTPUT_NAME "mie") target_compile_definitions(mie-tool PRIVATE MIE_STATIC=${MIE_STATIC}) diff --git a/tool/cmd/internal/builder-test.c b/tool/cmd/internal/builder-test.c index da4c1b7..e06f7c9 100644 --- a/tool/cmd/internal/builder-test.c +++ b/tool/cmd/internal/builder-test.c @@ -1,7 +1,7 @@ #include "../cmd.h" -#include -#include +#include +#include #include #include #include @@ -27,7 +27,7 @@ enum { }; static int builder_test( - const b_command *cmd, const b_arglist *args, const b_array *_) + const fx_command *cmd, const fx_arglist *args, const fx_array *_) { struct mie_ctx *ctx = mie_ctx_create(); mie_builtin_dialect_create(ctx); @@ -94,19 +94,20 @@ static int builder_test( struct mie_pass_manager *func_pm = mie_pass_manager_nest(pm); mie_pass_manager_filter_op(module_pm, "func", "func"); - b_arglist_iterator it; - b_arglist_foreach(&it, args) + fx_arglist_iterator it; + fx_arglist_foreach(&it, args) { if (it.opt_id < OPT_PASS_OFFSET) { continue; } - const b_command_option *opt = b_command_get_option(cmd, it.opt_id); + const fx_command_option *opt + = fx_command_get_option(cmd, it.opt_id); if (!opt) { continue; } - const char *pass_name = b_command_option_get_long_name(opt); + const char *pass_name = fx_command_option_get_long_name(opt); struct mie_pass *pass = NULL; enum mie_status status = mie_ctx_get_pass(ctx, pass_name, NULL, &pass); @@ -121,62 +122,62 @@ static int builder_test( mie_pass_manager_run(pm, module); enum mie_print_flags flags = 0; - if (b_arglist_get_count(args, OPT_GENERIC, B_COMMAND_INVALID_ID) > 0) { + if (fx_arglist_get_count(args, OPT_GENERIC, FX_COMMAND_INVALID_ID) > 0) { flags |= MIE_PRINT_F_GENERIC; } - if (b_arglist_get_count(args, OPT_NO_ABBREV, B_COMMAND_INVALID_ID) == 0) { + if (fx_arglist_get_count(args, OPT_NO_ABBREV, FX_COMMAND_INVALID_ID) == 0) { flags |= MIE_PRINT_F_ABBREVIATED; } struct mie_printer printer; - mie_printer_init(&printer, ctx, b_stdout, flags); + mie_printer_init(&printer, ctx, fx_stdout, flags); mie_printer_print_op(&printer, module); printf("\n"); return 0; } -B_COMMAND(CMD_INTERNAL_BUILDER_TEST, CMD_INTERNAL) +FX_COMMAND(CMD_INTERNAL_BUILDER_TEST, CMD_INTERNAL) { - B_COMMAND_NAME("builder-test"); - B_COMMAND_DESC("mie_builder test"); - B_COMMAND_FUNCTION(builder_test); + FX_COMMAND_NAME("builder-test"); + FX_COMMAND_DESC("mie_builder test"); + FX_COMMAND_FUNCTION(builder_test); - B_COMMAND_OPTION(OPT_GENERIC) + FX_COMMAND_OPTION(OPT_GENERIC) { - B_OPTION_LONG_NAME("generic"); - B_OPTION_SHORT_NAME('g'); - B_OPTION_DESC("print operations in generic format."); + FX_OPTION_LONG_NAME("generic"); + FX_OPTION_SHORT_NAME('g'); + FX_OPTION_DESC("print operations in generic format."); } - B_COMMAND_OPTION(OPT_NO_ABBREV) + FX_COMMAND_OPTION(OPT_NO_ABBREV) { - B_OPTION_LONG_NAME("no-abbrev"); - B_OPTION_SHORT_NAME('n'); - B_OPTION_DESC( + FX_OPTION_LONG_NAME("no-abbrev"); + FX_OPTION_SHORT_NAME('n'); + FX_OPTION_DESC( "don't use abbreviations for builtin types and ops."); } - B_COMMAND_HELP_OPTION(); + FX_COMMAND_HELP_OPTION(); struct mie_ctx *ctx = mie_ctx_create(); mie_builtin_passes_register(ctx); size_t i = 0; - b_btree_node *node = b_btree_first(&ctx->ctx_passes.map_entries); + fx_bst_node *node = fx_bst_first(&ctx->ctx_passes.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_pass_definition *pass - = b_unbox(struct mie_pass_definition, id, p_id); + = fx_unbox(struct mie_pass_definition, id, p_id); - B_COMMAND_OPTION_GEN(OPT_PASS_OFFSET + i) + FX_COMMAND_OPTION_GEN(OPT_PASS_OFFSET + i) { - B_OPTION_LONG_NAME(pass->p_name); - B_OPTION_DESC(pass->p_description); + FX_OPTION_LONG_NAME(pass->p_name); + FX_OPTION_DESC(pass->p_description); } - node = b_btree_next(node); + node = fx_bst_next(node); i++; } } diff --git a/tool/cmd/internal/ctx-dump.c b/tool/cmd/internal/ctx-dump.c index 14aa49a..3235cdb 100644 --- a/tool/cmd/internal/ctx-dump.c +++ b/tool/cmd/internal/ctx-dump.c @@ -1,8 +1,8 @@ #include "../cmd.h" #include -#include -#include +#include +#include #include #include #include @@ -35,7 +35,7 @@ static void mie_op_definition_print(const struct mie_op_definition *op) { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&op->op_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,red]Op:[reset]%-20s [dark_grey]{%s}[reset]\n", op->op_name, id_str); } @@ -44,7 +44,7 @@ static void mie_type_definition_print(const struct mie_type_definition *type) { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&type->ty_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,blue]Ty:[reset]%-20s [dark_grey]{%s}[reset]\n", type->ty_name, id_str); } @@ -53,7 +53,7 @@ static void mie_trait_definition_print(const struct mie_trait_definition *trait) { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&trait->tr_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,yellow]Tr:[reset]%-20s [dark_grey]{%s}[reset]\n", trait->tr_name, id_str); } @@ -63,7 +63,7 @@ static void mie_attribute_definition_print( { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&attribute->a_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,magenta]At:[reset]%-20s [dark_grey]{%s}[reset]\n", attribute->a_name, id_str); } @@ -73,7 +73,7 @@ static void mie_interface_definition_print( { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&interface->if_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,cyan]If:[reset]%-20s [dark_grey]{%s}[reset]\n", interface->if_name, id_str); } @@ -82,7 +82,7 @@ static void mie_pass_definition_print(const struct mie_pass_definition *interfac { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&interface->p_id, id_str, sizeof id_str); - b_printf( + fx_printf( " [bold,cyan]Ps:[reset]%-20s [dark_grey]{%s}[reset]\n", interface->p_name, id_str); } @@ -92,19 +92,19 @@ static void mie_diag_class_print( { switch (c->c_type) { case MIE_DIAG_CLASS_HINT: - b_printf(" [bold,cyan]Hint:[reset]"); + fx_printf(" [bold,cyan]Hint:[reset]"); break; case MIE_DIAG_CLASS_WARNING: - b_printf(" [bold,yellow]Warn:[reset]"); + fx_printf(" [bold,yellow]Warn:[reset]"); break; case MIE_DIAG_CLASS_ERROR: - b_printf(" [bold,red]Err: [reset]"); + fx_printf(" [bold,red]Err: [reset]"); break; default: return; } - b_printf( + fx_printf( "%s.%-25s [green]%s[reset]\n", dialect->d_name, c->c_id_str_short, c->c_title); } @@ -112,7 +112,11 @@ static void mie_diag_class_print( static void mie_diag_msg_print( const struct mie_dialect *dialect, const struct mie_diag_msg *msg) { - b_printf( + if (!msg->msg_id_str_short || !msg->msg_content) { + return; + } + + fx_printf( " [bold,blue]Msg: [reset]%s.%-25s [green]%s[reset]\n", dialect->d_name, msg->msg_id_str_short, msg->msg_content); } @@ -121,105 +125,110 @@ static void mie_dialect_print(const struct mie_dialect *dialect) { char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&dialect->d_id, id_str, sizeof id_str); - b_printf( + fx_printf( "[bold,green]D:[reset]%-20s [dark_grey]{%s}[reset]\n", dialect->d_name, id_str); - b_btree_node *node = b_btree_first(&dialect->d_ops.map_entries); + fx_bst_node *node = fx_bst_first(&dialect->d_ops.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_op_definition *op - = b_unbox(struct mie_op_definition, id, op_id); + = fx_unbox(struct mie_op_definition, id, op_id); mie_op_definition_print(op); - node = b_btree_next(node); + node = fx_bst_next(node); } - node = b_btree_first(&dialect->d_types.map_entries); + node = fx_bst_first(&dialect->d_types.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_type_definition *type - = b_unbox(struct mie_type_definition, id, ty_id); + = fx_unbox(struct mie_type_definition, id, ty_id); mie_type_definition_print(type); - node = b_btree_next(node); + node = fx_bst_next(node); } - node = b_btree_first(&dialect->d_traits.map_entries); + node = fx_bst_first(&dialect->d_traits.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_trait_definition *trait - = b_unbox(struct mie_trait_definition, id, tr_id); + = fx_unbox(struct mie_trait_definition, id, tr_id); mie_trait_definition_print(trait); - node = b_btree_next(node); + node = fx_bst_next(node); } - node = b_btree_first(&dialect->d_attributes.map_entries); + node = fx_bst_first(&dialect->d_attributes.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_attribute_definition *attribute - = b_unbox(struct mie_attribute_definition, id, a_id); + = fx_unbox(struct mie_attribute_definition, id, a_id); mie_attribute_definition_print(attribute); - node = b_btree_next(node); + node = fx_bst_next(node); } - node = b_btree_first(&dialect->d_interfaces.map_entries); + node = fx_bst_first(&dialect->d_interfaces.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); - struct mie_interface_definition *interface = b_unbox( + mie_id *id = fx_unbox(mie_id, node, e_node); + struct mie_interface_definition *interface = fx_unbox( struct mie_interface_definition, id, if_id); mie_interface_definition_print(interface); - node = b_btree_next(node); + node = fx_bst_next(node); } } static void mie_ctx_print(const struct mie_ctx *ctx) { printf("Dialects:\n"); - b_btree_node *node = b_btree_first(&ctx->ctx_dialects.map_entries); + fx_bst_node *node = fx_bst_first(&ctx->ctx_dialects.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_dialect *dialect - = b_unbox(struct mie_dialect, id, d_id); + = fx_unbox(struct mie_dialect, id, d_id); mie_dialect_print(dialect); - node = b_btree_next(node); + node = fx_bst_next(node); } printf("\nPasses:\n"); - node = b_btree_first(&ctx->ctx_passes.map_entries); + node = fx_bst_first(&ctx->ctx_passes.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_pass_definition *pass - = b_unbox(struct mie_pass_definition, id, p_id); + = fx_unbox(struct mie_pass_definition, id, p_id); mie_pass_definition_print(pass); - node = b_btree_next(node); + node = fx_bst_next(node); } printf("\nDiagnostics:\n"); - node = b_btree_first(&ctx->ctx_dialects.map_entries); + node = fx_bst_first(&ctx->ctx_dialects.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_dialect *dialect - = b_unbox(struct mie_dialect, id, d_id); + = fx_unbox(struct mie_dialect, id, d_id); for (size_t i = 0; i < dialect->d_nr_diag_classes; i++) { mie_diag_class_print(dialect, &dialect->d_diag_classes[i]); } for (size_t i = 0; i < dialect->d_nr_diag_msgs; i++) { + if (!dialect->d_diag_msgs[i].msg_content) { + printf(" [%zu] NULL\n", i); + } + mie_diag_msg_print(dialect, &dialect->d_diag_msgs[i]); } - node = b_btree_next(node); + node = fx_bst_next(node); } } -static int ctx_dump(const b_command *cmd, const b_arglist *args, const b_array *_) +static int ctx_dump( + const fx_command *cmd, const fx_arglist *args, const fx_array *_) { struct mie_ctx *ctx = mie_ctx_create(); mie_builtin_dialect_create(ctx); @@ -267,7 +276,7 @@ static int ctx_dump(const b_command *cmd, const b_arglist *args, const b_array * sizeof func_out_parts / sizeof *func_out_parts)); struct mie_printer printer; - mie_printer_init(&printer, ctx, b_stdout, MIE_PRINT_F_ABBREVIATED); + mie_printer_init(&printer, ctx, fx_stdout, MIE_PRINT_F_ABBREVIATED); char id_str[MIE_ID_STRING_MAX]; mie_id_to_string(&i32->ty_id, id_str, sizeof id_str); @@ -304,11 +313,11 @@ static int ctx_dump(const b_command *cmd, const b_arglist *args, const b_array * return 0; } -B_COMMAND(CMD_INTERNAL_CTX_DUMP, CMD_INTERNAL) +FX_COMMAND(CMD_INTERNAL_CTX_DUMP, CMD_INTERNAL) { - B_COMMAND_NAME("ctx-dump"); - B_COMMAND_DESC("mie_ctx dump"); - B_COMMAND_FUNCTION(ctx_dump); + FX_COMMAND_NAME("ctx-dump"); + FX_COMMAND_DESC("mie_ctx dump"); + FX_COMMAND_FUNCTION(ctx_dump); - B_COMMAND_HELP_OPTION(); + FX_COMMAND_HELP_OPTION(); } diff --git a/tool/cmd/internal/internal.c b/tool/cmd/internal/internal.c index 59757be..7f605a5 100644 --- a/tool/cmd/internal/internal.c +++ b/tool/cmd/internal/internal.c @@ -1,20 +1,21 @@ #include "../cmd.h" -#include -#include +#include +#include -static int internal(const b_command *cmd, const b_arglist *args, const b_array *_) +static int internal( + const fx_command *cmd, const fx_arglist *args, const fx_array *_) { return 0; } -B_COMMAND(CMD_INTERNAL, CMD_ROOT) +FX_COMMAND(CMD_INTERNAL, CMD_ROOT) { - B_COMMAND_SHORT_NAME('X'); - B_COMMAND_DESC("internal frontend debugging tools."); - B_COMMAND_FUNCTION(internal); - B_COMMAND_FLAGS(B_COMMAND_SHOW_HELP_BY_DEFAULT); + FX_COMMAND_SHORT_NAME('X'); + FX_COMMAND_DESC("internal frontend debugging tools."); + FX_COMMAND_FUNCTION(internal); + FX_COMMAND_FLAGS(FX_COMMAND_SHOW_HELP_BY_DEFAULT); - B_COMMAND_HELP_OPTION(); + FX_COMMAND_HELP_OPTION(); } diff --git a/tool/cmd/optimise.c b/tool/cmd/optimise.c index 090aa32..1eda4bb 100644 --- a/tool/cmd/optimise.c +++ b/tool/cmd/optimise.c @@ -3,10 +3,10 @@ #include "cmd.h" #include -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -57,20 +57,20 @@ static void report_diag(struct mie_ctx *ctx) { struct mie_diag *diag = mie_ctx_pop_diag(ctx); while (diag) { - mie_diag_write_pretty(diag, b_stdtty_err); + mie_diag_write_pretty(diag, fx_stdtty_err); /* TODO cleanup */ diag = mie_ctx_pop_diag(ctx); } } static int optimise_file( - const b_command *cmd, const char *path, const b_arglist *args) + const fx_command *cmd, const char *path, const fx_arglist *args) { - b_file *file = NULL; - b_result result - = b_file_open(NULL, B_RV_PATH(path), B_FILE_READ_ONLY, &file); - if (b_result_is_error(result)) { - b_throw(result); + fx_file *file = NULL; + fx_result result + = fx_file_open(NULL, FX_RV_PATH(path), FX_FILE_READ_ONLY, &file); + if (fx_result_is_error(result)) { + fx_throw(result); return -1; } @@ -129,19 +129,20 @@ static int optimise_file( mie_pass_manager_add_pass(func_pm, prefix_func_with_underscore); - b_arglist_iterator it; - b_arglist_foreach(&it, args) + fx_arglist_iterator it; + fx_arglist_foreach(&it, args) { if (it.opt_id < OPT_PASS_OFFSET) { continue; } - const b_command_option *opt = b_command_get_option(cmd, it.opt_id); + const fx_command_option *opt + = fx_command_get_option(cmd, it.opt_id); if (!opt) { continue; } - const char *pass_name = b_command_option_get_long_name(opt); + const char *pass_name = fx_command_option_get_long_name(opt); struct mie_pass *pass = NULL; enum mie_status status = mie_ctx_get_pass(ctx, pass_name, NULL, &pass); @@ -160,16 +161,16 @@ static int optimise_file( mie_pass_manager_run(pm, root); enum mie_print_flags flags = 0; - if (b_arglist_get_count(args, OPT_GENERIC, B_COMMAND_INVALID_ID) > 0) { + if (fx_arglist_get_count(args, OPT_GENERIC, FX_COMMAND_INVALID_ID) > 0) { flags |= MIE_PRINT_F_GENERIC; } - if (b_arglist_get_count(args, OPT_NO_ABBREV, B_COMMAND_INVALID_ID) == 0) { + if (fx_arglist_get_count(args, OPT_NO_ABBREV, FX_COMMAND_INVALID_ID) == 0) { flags |= MIE_PRINT_F_ABBREVIATED; } struct mie_printer printer; - mie_printer_init(&printer, ctx, b_stdout, flags); + mie_printer_init(&printer, ctx, fx_stdout, flags); mie_printer_print_op(&printer, root); printf("\n"); @@ -211,18 +212,18 @@ static int optimise_file( mie_lex_destroy(lex); mie_line_source_cleanup(&src); - b_file_unref(file); + fx_file_unref(file); return 0; } -int optimise(const b_command *cmd, const b_arglist *args, const b_array *_) +int optimise(const fx_command *cmd, const fx_arglist *args, const fx_array *_) { - b_arglist_iterator it; - b_arglist_foreach_filtered(&it, args, B_COMMAND_INVALID_ID, ARG_FILEPATH) + fx_arglist_iterator it; + fx_arglist_foreach_filtered(&it, args, FX_COMMAND_INVALID_ID, ARG_FILEPATH) { - b_arglist_value *path = it.value; - if (path->val_type != B_COMMAND_ARG_STRING) { + fx_arglist_value *path = it.value; + if (path->val_type != FX_COMMAND_ARG_STRING) { continue; } @@ -235,35 +236,35 @@ int optimise(const b_command *cmd, const b_arglist *args, const b_array *_) return 0; } -B_COMMAND(CMD_OPTIMISE, CMD_ROOT) +FX_COMMAND(CMD_OPTIMISE, CMD_ROOT) { - B_COMMAND_NAME("optimise"); - B_COMMAND_SHORT_NAME('O'); - B_COMMAND_DESC("optimise a mie ir file."); - B_COMMAND_FLAGS(B_COMMAND_SHOW_HELP_BY_DEFAULT); - B_COMMAND_FUNCTION(optimise); + FX_COMMAND_NAME("optimise"); + FX_COMMAND_SHORT_NAME('O'); + FX_COMMAND_DESC("optimise a mie ir file."); + FX_COMMAND_FLAGS(FX_COMMAND_SHOW_HELP_BY_DEFAULT); + FX_COMMAND_FUNCTION(optimise); - B_COMMAND_HELP_OPTION(); + FX_COMMAND_HELP_OPTION(); - B_COMMAND_ARG(ARG_FILEPATH) + FX_COMMAND_ARG(ARG_FILEPATH) { - B_ARG_NAME("filepath"); - B_ARG_DESC("the mie file to optimise"); - B_ARG_NR_VALUES(1); + FX_ARG_NAME("filepath"); + FX_ARG_DESC("the mie file to optimise"); + FX_ARG_NR_VALUES(1); } - B_COMMAND_OPTION(OPT_GENERIC) + FX_COMMAND_OPTION(OPT_GENERIC) { - B_OPTION_LONG_NAME("generic"); - B_OPTION_SHORT_NAME('g'); - B_OPTION_DESC("print operations in generic format."); + FX_OPTION_LONG_NAME("generic"); + FX_OPTION_SHORT_NAME('g'); + FX_OPTION_DESC("print operations in generic format."); } - B_COMMAND_OPTION(OPT_NO_ABBREV) + FX_COMMAND_OPTION(OPT_NO_ABBREV) { - B_OPTION_LONG_NAME("no-abbrev"); - B_OPTION_SHORT_NAME('n'); - B_OPTION_DESC( + FX_OPTION_LONG_NAME("no-abbrev"); + FX_OPTION_SHORT_NAME('n'); + FX_OPTION_DESC( "don't use abbreviations for builtin types and ops."); } @@ -271,19 +272,19 @@ B_COMMAND(CMD_OPTIMISE, CMD_ROOT) mie_builtin_passes_register(ctx); size_t i = 0; - b_btree_node *node = b_btree_first(&ctx->ctx_passes.map_entries); + fx_bst_node *node = fx_bst_first(&ctx->ctx_passes.map_entries); while (node) { - mie_id *id = b_unbox(mie_id, node, e_node); + mie_id *id = fx_unbox(mie_id, node, e_node); struct mie_pass_definition *pass - = b_unbox(struct mie_pass_definition, id, p_id); + = fx_unbox(struct mie_pass_definition, id, p_id); - B_COMMAND_OPTION_GEN(OPT_PASS_OFFSET + i) + FX_COMMAND_OPTION_GEN(OPT_PASS_OFFSET + i) { - B_OPTION_LONG_NAME(pass->p_name); - B_OPTION_DESC(pass->p_description); + FX_OPTION_LONG_NAME(pass->p_name); + FX_OPTION_DESC(pass->p_description); } - node = b_btree_next(node); + node = fx_bst_next(node); i++; } } diff --git a/tool/cmd/root.c b/tool/cmd/root.c index f703d5e..35458d7 100644 --- a/tool/cmd/root.c +++ b/tool/cmd/root.c @@ -1,18 +1,18 @@ #include "cmd.h" -#include +#include -B_COMMAND(CMD_ROOT, B_COMMAND_INVALID_ID) +FX_COMMAND(CMD_ROOT, FX_COMMAND_INVALID_ID) { - B_COMMAND_NAME("mie"); - B_COMMAND_DESC("Mie IR manipulation tool."); - B_COMMAND_HELP_OPTION(); - B_COMMAND_FLAGS(B_COMMAND_SHOW_HELP_BY_DEFAULT); + FX_COMMAND_NAME("mie"); + FX_COMMAND_DESC("Mie IR manipulation tool."); + FX_COMMAND_HELP_OPTION(); + FX_COMMAND_FLAGS(FX_COMMAND_SHOW_HELP_BY_DEFAULT); - B_COMMAND_USAGE() - { - B_COMMAND_USAGE_COMMAND_PLACEHOLDER(); - B_COMMAND_USAGE_OPT_PLACEHOLDER(); - B_COMMAND_USAGE_ARG_PLACEHOLDER(); - } + FX_COMMAND_USAGE() + { + FX_COMMAND_USAGE_COMMAND_PLACEHOLDER(); + FX_COMMAND_USAGE_OPT_PLACEHOLDER(); + FX_COMMAND_USAGE_ARG_PLACEHOLDER(); + } } diff --git a/tool/cmd/validate.c b/tool/cmd/validate.c index 7ee3231..738b55c 100644 --- a/tool/cmd/validate.c +++ b/tool/cmd/validate.c @@ -3,10 +3,10 @@ #include "cmd.h" #include -#include -#include -#include -#include +#include +#include +#include +#include #include #include #include @@ -51,19 +51,19 @@ static void report_diag(struct mie_ctx *ctx) { struct mie_diag *diag = mie_ctx_pop_diag(ctx); while (diag) { - mie_diag_write_pretty(diag, b_stdtty_err); + mie_diag_write_pretty(diag, fx_stdtty_err); /* TODO cleanup */ diag = mie_ctx_pop_diag(ctx); } } -static int validate_file(const char *path, const b_arglist *args) +static int validate_file(const char *path, const fx_arglist *args) { - b_file *file = NULL; - b_result result - = b_file_open(NULL, B_RV_PATH(path), B_FILE_READ_ONLY, &file); - if (b_result_is_error(result)) { - b_throw(result); + fx_file *file = NULL; + fx_result result + = fx_file_open(NULL, FX_RV_PATH(path), FX_FILE_READ_ONLY, &file); + if (fx_result_is_error(result)) { + fx_throw(result); return -1; } @@ -130,7 +130,7 @@ static int validate_file(const char *path, const b_arglist *args) struct mie_printer printer; mie_printer_init( - &printer, ctx, b_stdout, + &printer, ctx, fx_stdout, MIE_PRINT_F_ABBREVIATED | MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS); mie_printer_print_op(&printer, root); printf("\n"); @@ -216,18 +216,18 @@ static int validate_file(const char *path, const b_arglist *args) mie_line_source_cleanup(&src); - b_file_unref(file); + fx_file_unref(file); return 0; } -int validate(const b_command *cmd, const b_arglist *args, const b_array *_) +int validate(const fx_command *cmd, const fx_arglist *args, const fx_array *_) { - b_arglist_iterator it; - b_arglist_foreach_filtered(&it, args, B_COMMAND_INVALID_ID, ARG_FILEPATH) + fx_arglist_iterator it; + fx_arglist_foreach_filtered(&it, args, FX_COMMAND_INVALID_ID, ARG_FILEPATH) { - b_arglist_value *path = it.value; - if (path->val_type != B_COMMAND_ARG_STRING) { + fx_arglist_value *path = it.value; + if (path->val_type != FX_COMMAND_ARG_STRING) { continue; } @@ -240,21 +240,21 @@ int validate(const b_command *cmd, const b_arglist *args, const b_array *_) return 0; } -B_COMMAND(CMD_VALIDATE, CMD_ROOT) +FX_COMMAND(CMD_VALIDATE, CMD_ROOT) { - B_COMMAND_NAME("validate"); - B_COMMAND_SHORT_NAME('V'); - B_COMMAND_DESC("validate a mie ir file."); - B_COMMAND_HELP_OPTION(); - B_COMMAND_FLAGS(B_COMMAND_SHOW_HELP_BY_DEFAULT); - B_COMMAND_FUNCTION(validate); + FX_COMMAND_NAME("validate"); + FX_COMMAND_SHORT_NAME('V'); + FX_COMMAND_DESC("validate a mie ir file."); + FX_COMMAND_HELP_OPTION(); + FX_COMMAND_FLAGS(FX_COMMAND_SHOW_HELP_BY_DEFAULT); + FX_COMMAND_FUNCTION(validate); - B_COMMAND_ARG(ARG_FILEPATH) + FX_COMMAND_ARG(ARG_FILEPATH) { - B_ARG_NAME("filepath"); - B_ARG_DESC("the mie file to validate"); - B_ARG_NR_VALUES(1); + FX_ARG_NAME("filepath"); + FX_ARG_DESC("the mie file to validate"); + FX_ARG_NR_VALUES(1); } - B_COMMAND_HELP_OPTION(); + FX_COMMAND_HELP_OPTION(); } diff --git a/tool/diag/diag.h b/tool/diag/diag.h index 595c554..d2e6872 100644 --- a/tool/diag/diag.h +++ b/tool/diag/diag.h @@ -1,11 +1,11 @@ #ifndef _TOOL_DIAG_DIAG_H_ #define _TOOL_DIAG_DIAG_H_ -#include +#include #include struct mie_diag; -extern enum mie_status mie_diag_write_pretty(struct mie_diag *diag, b_tty *stream); +extern enum mie_status mie_diag_write_pretty(struct mie_diag *diag, fx_tty *stream); #endif diff --git a/tool/diag/pretty.c b/tool/diag/pretty.c index 247b1aa..0eaaba3 100644 --- a/tool/diag/pretty.c +++ b/tool/diag/pretty.c @@ -1,7 +1,7 @@ #include -#include -#include -#include +#include +#include +#include #include #include #include @@ -15,16 +15,16 @@ #define GET_CHAR_CONTINUE -1 struct snippet_print_ctx { - b_tty *ctx_stream; + fx_tty *ctx_stream; struct mie_line_source *ctx_line_source; size_t ctx_row, ctx_col; size_t ctx_indent_offset; bool ctx_has_underline, ctx_in_content; - b_stringstream *ctx_underline; - const b_string *ctx_linebuf; - const b_iterator *ctx_linebuf_ptr; + fx_stringstream *ctx_underline; + const fx_string *ctx_linebuf; + const fx_iterator *ctx_linebuf_ptr; struct mie_diag_c_snippet *ctx_snippet; @@ -40,31 +40,31 @@ struct snippet_print_ctx { #define __STREAM_COLOUR_RESET "[reset]" #define STREAM_COLOUR_ERROR(stream) \ - b_tty_puts(stream, 0, __STREAM_COLOUR_ERROR); -#define STREAM_COLOUR_WARN(stream) b_tty_puts(stream, 0, __STREAM_COLOUR_WARN); -#define STREAM_COLOUR_HINT(stream) b_tty_puts(stream, 0, __STREAM_COLOUR_HINT); + fx_tty_puts(stream, 0, __STREAM_COLOUR_ERROR); +#define STREAM_COLOUR_WARN(stream) fx_tty_puts(stream, 0, __STREAM_COLOUR_WARN); +#define STREAM_COLOUR_HINT(stream) fx_tty_puts(stream, 0, __STREAM_COLOUR_HINT); #define STREAM_COLOUR_ACCENT(stream) \ - b_tty_puts(stream, 0, __STREAM_COLOUR_ACCENT); + fx_tty_puts(stream, 0, __STREAM_COLOUR_ACCENT); #define STREAM_COLOUR_LINE_NO(stream) \ - b_tty_puts(stream, 0, __STREAM_COLOUR_LINE_NO); + fx_tty_puts(stream, 0, __STREAM_COLOUR_LINE_NO); #define STREAM_COLOUR_RESET(stream) \ - b_tty_puts(stream, 0, __STREAM_COLOUR_RESET); + fx_tty_puts(stream, 0, __STREAM_COLOUR_RESET); #define STREAM_COLOUR_ERROR_B(stream, str) \ - b_stream_write_string(str, __STREAM_COLOUR_ERROR, NULL); + fx_stream_write_string(str, __STREAM_COLOUR_ERROR, NULL); #define STREAM_COLOUR_WARN_B(stream, str) \ - b_stream_write_string(str, __STREAM_COLOUR_WARN, NULL); + fx_stream_write_string(str, __STREAM_COLOUR_WARN, NULL); #define STREAM_COLOUR_HINT_B(stream, str) \ - b_stream_write_string(str, __STREAM_COLOUR_HINT, NULL); + fx_stream_write_string(str, __STREAM_COLOUR_HINT, NULL); #define STREAM_COLOUR_ACCENT_B(stream, str) \ - b_stream_write_string(str, __STREAM_COLOUR_ACCENT, NULL); + fx_stream_write_string(str, __STREAM_COLOUR_ACCENT, NULL); #define STREAM_COLOUR_RESET_B(stream, str) \ - b_stream_write_string(str, __STREAM_COLOUR_RESET, NULL); + fx_stream_write_string(str, __STREAM_COLOUR_RESET, NULL); -static void print_header(struct mie_diag *diag, b_tty *dest) +static void print_header(struct mie_diag *diag, fx_tty *dest) { unsigned int w; - b_tty_get_dimensions(dest, &w, NULL); + fx_tty_get_dimensions(dest, &w, NULL); const struct mie_diag_class *diag_class = diag->diag_class; assert(diag_class); @@ -72,51 +72,51 @@ static void print_header(struct mie_diag *diag, b_tty *dest) STREAM_COLOUR_ACCENT(dest); size_t nr_written = 0; - nr_written += b_tty_puts(dest, 0, "--- "); + nr_written += fx_tty_puts(dest, 0, "--- "); const char *s = diag_class->c_title; while (*s) { - b_tty_putc(dest, 0, toupper(*s)); + fx_tty_putc(dest, 0, toupper(*s)); s++; nr_written++; } - b_tty_putc(dest, 0, ' '); + fx_tty_putc(dest, 0, ' '); nr_written++; while (nr_written < w) { - b_tty_putc(dest, 0, '-'); + fx_tty_putc(dest, 0, '-'); nr_written++; } STREAM_COLOUR_RESET(dest); - b_tty_putc(dest, 0, '\n'); + fx_tty_putc(dest, 0, '\n'); } -static void print_location(struct mie_diag *diag, b_tty *out) +static void print_location(struct mie_diag *diag, fx_tty *out) { size_t x; const char *name = mie_line_source_get_path(diag->diag_src); - b_tty_puts(out, 0, " "); + fx_tty_puts(out, 0, " "); STREAM_COLOUR_ACCENT(out); - b_tty_puts(out, 0, "> "); + fx_tty_puts(out, 0, "> "); STREAM_COLOUR_RESET(out); - b_tty_printf( + fx_tty_printf( out, 0, "%s:%lu:%lu\n", name, diag->diag_loc.c_row, diag->diag_loc.c_col); } static void print_msg( - struct mie_diag *diag, struct mie_diag_c_msg *msg, b_tty *stream) + struct mie_diag *diag, struct mie_diag_c_msg *msg, fx_tty *stream) { - b_paragraph_format format = { + fx_paragraph_format format = { .p_left_margin = 2, .p_right_margin = 2, }; - b_print_paragraph(msg->msg_content, stream, &format); + fx_print_paragraph(msg->msg_content, stream, &format); } static bool highlight_contains_cell( @@ -181,7 +181,7 @@ static bool amendment_contains_cell( } limit = a->a_replace.a_loc.c_row - + b_max(ulong, a->a_replace.a_length, a->__x) - 1; + + fx_max(ulong, a->a_replace.a_length, a->__x) - 1; if (col > limit) { return false; @@ -280,7 +280,7 @@ static void update_highlighting(struct snippet_print_ctx *ctx) static enum mie_status read_row(struct snippet_print_ctx *ctx, size_t row) { if (ctx->ctx_linebuf_ptr) { - b_iterator_unref(ctx->ctx_linebuf_ptr); + fx_iterator_unref(ctx->ctx_linebuf_ptr); ctx->ctx_linebuf_ptr = NULL; } @@ -293,7 +293,7 @@ static enum mie_status read_row(struct snippet_print_ctx *ctx, size_t row) return status; } - ctx->ctx_linebuf_ptr = b_iterator_cbegin(ctx->ctx_linebuf); + ctx->ctx_linebuf_ptr = fx_iterator_cbegin(ctx->ctx_linebuf); return MIE_SUCCESS; } @@ -309,7 +309,7 @@ static int get_char_amendment(struct snippet_print_ctx *ctx) - 1; return a->a_add.a_str[i]; case MIE_DIAG_AMENDMENT_REMOVE: - b_iterator_move_next(ctx->ctx_linebuf_ptr); + fx_iterator_move_next(ctx->ctx_linebuf_ptr); return GET_CHAR_CONTINUE; case MIE_DIAG_AMENDMENT_REPLACE: i = ctx->ctx_col - a->a_add.a_loc.c_col; @@ -320,7 +320,7 @@ static int get_char_amendment(struct snippet_print_ctx *ctx) c = a->a_replace.a_str[i]; if (i < a->a_replace.a_length) { - b_iterator_move_next(ctx->ctx_linebuf_ptr); + fx_iterator_move_next(ctx->ctx_linebuf_ptr); } if (c != 0) { @@ -341,15 +341,15 @@ static int get_char(struct snippet_print_ctx *ctx) return get_char_amendment(ctx); } - b_wchar c = B_WCHAR_INVALID; + fx_wchar c = FX_WCHAR_INVALID; while (1) { - c = b_iterator_get_cvalue(ctx->ctx_linebuf_ptr).v_int; - if (c == B_WCHAR_INVALID) { + c = fx_iterator_get_cvalue(ctx->ctx_linebuf_ptr).v_int; + if (c == FX_WCHAR_INVALID) { return GET_CHAR_STOP; } - b_iterator_move_next(ctx->ctx_linebuf_ptr); + fx_iterator_move_next(ctx->ctx_linebuf_ptr); if (isspace(c) && !ctx->ctx_in_content) { ctx->ctx_indent_offset++; @@ -364,7 +364,7 @@ static int get_char(struct snippet_print_ctx *ctx) static void update_underline(struct snippet_print_ctx *ctx) { if (!ctx->ctx_hl) { - b_stream_write_char(ctx->ctx_underline, ' '); + fx_stream_write_char(ctx->ctx_underline, ' '); return; } @@ -372,10 +372,10 @@ static void update_underline(struct snippet_print_ctx *ctx) case MIE_DIAG_HIGHLIGHT_ERROR: case MIE_DIAG_HIGHLIGHT_WARNING: case MIE_DIAG_HIGHLIGHT_HINT: - b_stream_write_char(ctx->ctx_underline, '^'); + fx_stream_write_char(ctx->ctx_underline, '^'); break; default: - b_stream_write_char(ctx->ctx_underline, ' '); + fx_stream_write_char(ctx->ctx_underline, ' '); break; } } @@ -388,28 +388,28 @@ static void write_underline(struct snippet_print_ctx *ctx) STREAM_COLOUR_RESET(ctx->ctx_stream); STREAM_COLOUR_LINE_NO(ctx->ctx_stream); - b_tty_puts(ctx->ctx_stream, 0, " : "); - b_tty_puts(ctx->ctx_stream, 0, b_stringstream_ptr(ctx->ctx_underline)); + fx_tty_puts(ctx->ctx_stream, 0, " : "); + fx_tty_puts(ctx->ctx_stream, 0, fx_stringstream_ptr(ctx->ctx_underline)); STREAM_COLOUR_RESET(ctx->ctx_stream); - b_tty_putc(ctx->ctx_stream, 0, '\n'); + fx_tty_putc(ctx->ctx_stream, 0, '\n'); } static void print_snippet( - struct mie_diag *diag, struct mie_diag_c_snippet *snippet, b_tty *stream) + struct mie_diag *diag, struct mie_diag_c_snippet *snippet, fx_tty *stream) { enum mie_status status = MIE_SUCCESS; struct snippet_print_ctx printer = { .ctx_stream = stream, .ctx_snippet = snippet, - .ctx_underline = b_stringstream_create(), + .ctx_underline = fx_stringstream_create(), .ctx_line_source = diag->diag_src, }; for (unsigned long row = snippet->s_first_line; row <= snippet->s_last_line; row++) { STREAM_COLOUR_LINE_NO(stream); - b_tty_printf(stream, 0, " %4lu | ", row); + fx_tty_printf(stream, 0, " %4lu | ", row); printer.ctx_row = row; status = read_row(&printer, row); @@ -433,23 +433,23 @@ static void print_snippet( update_highlighting(&printer); if (c == '[') { - b_tty_putc(stream, 0, c); + fx_tty_putc(stream, 0, c); } - b_tty_putc(stream, 0, c); + fx_tty_putc(stream, 0, c); update_underline(&printer); } - b_tty_putc(stream, 0, '\n'); + fx_tty_putc(stream, 0, '\n'); write_underline(&printer); } - b_stringstream_unref(printer.ctx_underline); + fx_stringstream_unref(printer.ctx_underline); } static void print_component( - struct mie_diag *diag, struct mie_diag_component *component, b_tty *stream) + struct mie_diag *diag, struct mie_diag_component *component, fx_tty *stream) { switch (component->c_type) { case MIE_DIAG_COMPONENT_MSG: @@ -463,20 +463,20 @@ static void print_component( } } -enum mie_status mie_diag_write_pretty(struct mie_diag *diag, b_tty *stream) +enum mie_status mie_diag_write_pretty(struct mie_diag *diag, fx_tty *stream) { print_header(diag, stream); print_location(diag, stream); - b_queue_entry *entry = b_queue_first(&diag->diag_components); + fx_queue_entry *entry = fx_queue_first(&diag->diag_components); while (entry) { struct mie_diag_component *c - = b_unbox(struct mie_diag_component, entry, c_entry); + = fx_unbox(struct mie_diag_component, entry, c_entry); - b_tty_putc(stream, 0, '\n'); + fx_tty_putc(stream, 0, '\n'); print_component(diag, c, stream); - entry = b_queue_next(entry); + entry = fx_queue_next(entry); } return MIE_SUCCESS; diff --git a/tool/main.c b/tool/main.c index a70a3fc..38cb6ff 100644 --- a/tool/main.c +++ b/tool/main.c @@ -1,10 +1,10 @@ #include "cmd/cmd.h" -#include +#include #include #include int main(int argc, const char **argv) { - return b_command_dispatch(CMD_ROOT, argc, argv); + return fx_command_dispatch(CMD_ROOT, argc, argv); }