wash/mie
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: replace bluelib references with fx

Browse Source
This commit is contained in:
max 🍓
2026-03-16 13:59:14 +00:00
parent 73b4b77816
commit ef858dd061
106 changed files with 1402 additions and 1389 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@@ -24,10 +24,10 @@ if (NOT MIE_STATIC)
endif () endif ()
if (MIE_STATIC) if (MIE_STATIC)
set(Bluelib_STATIC TRUE) set(FX_STATIC TRUE)
endif () endif ()
find_package(Bluelib REQUIRED) find_package(FX REQUIRED)
add_subdirectory(mie) add_subdirectory(mie)
add_subdirectory(tool) add_subdirectory(tool)

189
cmake/FindBluelib.cmake
View File

@@ -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()

189
cmake/FindFX.cmake Normal file
View File

@@ -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()

2
mie/CMakeLists.txt
View File

@@ -11,5 +11,5 @@ else ()
endif () endif ()
target_include_directories(mie PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include/) 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}) target_compile_definitions(mie PRIVATE MIE_EXPORT=1 MIE_STATIC=${MIE_STATIC})

6
mie/attribute/attribute-definition.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
@@ -12,7 +12,7 @@ struct mie_attribute_definition *mie_attribute_definition_create(
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->a_name = b_strdup(name); out->a_name = fx_strdup(name);
if (!out->a_name) { if (!out->a_name) {
free(out); free(out);
return NULL; return NULL;
@@ -20,7 +20,7 @@ struct mie_attribute_definition *mie_attribute_definition_create(
out->a_parent = parent; 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); mie_id_map_put(&parent->d_attributes, &out->a_id, &name_rope);
return out; return out;

54
mie/attribute/attribute-map.c
View File

@@ -1,6 +1,6 @@
#include <blue/core/hash.h> #include <fx/core/hash.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/attribute/attribute-map.h> #include <mie/attribute/attribute-map.h>
enum attribute_map_entry_type { enum attribute_map_entry_type {
@@ -13,14 +13,14 @@ struct attribute_map_entry {
enum attribute_map_entry_type e_type; enum attribute_map_entry_type e_type;
uint64_t e_hash; uint64_t e_hash;
union { union {
b_btree_node e_node; fx_bst_node e_node;
b_queue_entry e_entry; fx_queue_entry e_entry;
}; };
}; };
struct attribute_map_bucket { struct attribute_map_bucket {
struct attribute_map_entry b_base; struct attribute_map_entry b_base;
b_queue b_items; fx_queue b_items;
}; };
struct attribute_map_item { struct attribute_map_item {
@@ -29,9 +29,9 @@ struct attribute_map_item {
const struct mie_attribute *i_value; 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); 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); struct attribute_map_entry, uint64_t, e_node, e_hash, get_entry);
void mie_attribute_map_init(struct mie_attribute_map *map) 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( static const struct mie_attribute *get_attribute_from_bucket(
const struct attribute_map_bucket *bucket, const char *name) 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) { 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); const struct attribute_map_item, cur, i_base.e_entry);
if (!strcmp(item->i_name, name)) { if (!strcmp(item->i_name, name)) {
return item->i_value; return item->i_value;
} }
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
return NULL; 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 *mie_attribute_map_get(
const struct mie_attribute_map *map, const char *name) 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); struct attribute_map_entry *entry = get_entry(&map->m_entries, name_hash);
if (!entry) { if (!entry) {
return NULL; return NULL;
@@ -107,13 +107,13 @@ static struct attribute_map_bucket *convert_item_to_bucket(
return NULL; 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); memset(bucket, 0x0, sizeof *bucket);
bucket->b_base.e_type = ATTRMAP_ENTRY_BUCKET; bucket->b_base.e_type = ATTRMAP_ENTRY_BUCKET;
bucket->b_base.e_hash = item->i_base.e_hash; 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); put_entry(&map->m_entries, &bucket->b_base);
return bucket; return bucket;
@@ -132,7 +132,7 @@ static struct attribute_map_item *create_item(
out->i_value = attrib; out->i_value = attrib;
out->i_base.e_type = ATTRMAP_ENTRY_ITEM; out->i_base.e_type = ATTRMAP_ENTRY_ITEM;
out->i_base.e_hash = name_hash; out->i_base.e_hash = name_hash;
out->i_name = b_strdup(name); out->i_name = fx_strdup(name);
if (!out->i_name) { if (!out->i_name) {
free(out); free(out);
return NULL; return NULL;
@@ -145,7 +145,7 @@ enum mie_status mie_attribute_map_put(
struct mie_attribute_map *map, const char *name, struct mie_attribute_map *map, const char *name,
const struct mie_attribute *value, enum mie_attribute_map_flags flags) 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_entry *entry = get_entry(&map->m_entries, name_hash);
struct attribute_map_item *item = NULL; struct attribute_map_item *item = NULL;
struct attribute_map_bucket *bucket = NULL; struct attribute_map_bucket *bucket = NULL;
@@ -184,7 +184,7 @@ enum mie_status mie_attribute_map_put(
return MIE_ERR_NO_MEMORY; 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; 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) struct mie_attribute_map_iterator *it, const struct mie_attribute_map *map)
{ {
memset(it, 0x0, sizeof *it); memset(it, 0x0, sizeof *it);
it->_n = b_btree_first(&map->m_entries); it->_n = fx_bst_first(&map->m_entries);
if (!it->_n) { if (!it->_n) {
return MIE_ERR_NO_DATA; return MIE_ERR_NO_DATA;
} }
struct attribute_map_entry *entry 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_item *item = NULL;
struct attribute_map_bucket *bucket = NULL; struct attribute_map_bucket *bucket = NULL;
@@ -210,8 +210,8 @@ enum mie_status mie_attribute_map_iterator_begin(
return MIE_SUCCESS; return MIE_SUCCESS;
case ATTRMAP_ENTRY_BUCKET: case ATTRMAP_ENTRY_BUCKET:
bucket = (struct attribute_map_bucket *)entry; bucket = (struct attribute_map_bucket *)entry;
it->_e = b_queue_first(&bucket->b_items); it->_e = fx_queue_first(&bucket->b_items);
item = b_unbox(struct attribute_map_item, it->_e, i_base.e_entry); item = fx_unbox(struct attribute_map_item, it->_e, i_base.e_entry);
it->it_name = item->i_name; it->it_name = item->i_name;
it->it_value = item->i_value; it->it_value = item->i_value;
return MIE_SUCCESS; return MIE_SUCCESS;
@@ -228,11 +228,11 @@ enum mie_status mie_attribute_map_iterator_move_next(
struct attribute_map_bucket *next_bucket = NULL; struct attribute_map_bucket *next_bucket = NULL;
if (it->_e) { if (it->_e) {
it->_e = b_queue_next(it->_e); it->_e = fx_queue_next(it->_e);
next_entry = b_unbox(struct attribute_map_entry, it->_e, e_entry); next_entry = fx_unbox(struct attribute_map_entry, it->_e, e_entry);
} else if (it->_n) { } else if (it->_n) {
it->_n = b_btree_next(it->_n); it->_n = fx_bst_next(it->_n);
next_entry = b_unbox(struct attribute_map_entry, it->_n, e_node); next_entry = fx_unbox(struct attribute_map_entry, it->_n, e_node);
} else { } else {
memset(it, 0x0, sizeof *it); memset(it, 0x0, sizeof *it);
return MIE_ERR_NO_DATA; return MIE_ERR_NO_DATA;
@@ -249,8 +249,8 @@ enum mie_status mie_attribute_map_iterator_move_next(
break; break;
case ATTRMAP_ENTRY_BUCKET: case ATTRMAP_ENTRY_BUCKET:
next_bucket = (struct attribute_map_bucket *)next_item; next_bucket = (struct attribute_map_bucket *)next_item;
it->_e = b_queue_first(&next_bucket->b_items); it->_e = fx_queue_first(&next_bucket->b_items);
next_item = b_unbox( next_item = fx_unbox(
struct attribute_map_item, it->_e, i_base.e_entry); struct attribute_map_item, it->_e, i_base.e_entry);
break; break;
default: default:

76
mie/ctx.c
View File

@@ -1,7 +1,7 @@
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <blue/ds/hashmap.h> #include <fx/ds/hashmap.h>
#include <blue/ds/list.h> #include <fx/ds/list.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/diag/class.h> #include <mie/diag/class.h>
@@ -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) 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 id;
mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_dialects), &name_rope); 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); 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_op_definition *mie_ctx_get_op_definition(
const struct mie_ctx *ctx, const char *dialect_name, const char *op_name) 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 id;
mie_id_init_ns( mie_id_init_ns(
&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); 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) { if (!dialect) {
return NULL; 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); 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); 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( struct mie_type_definition *mie_ctx_get_type_definition(
const struct mie_ctx *ctx, const char *dialect_name, const char *type_name) 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 id;
mie_id_init_ns( mie_id_init_ns(
&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); 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) { if (!dialect) {
return NULL; 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); 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); 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_trait_definition *mie_ctx_get_trait_definition(
const struct mie_ctx *ctx, const char *dialect_name, const char *trait_name) 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 id;
mie_id_init_ns( mie_id_init_ns(
&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); 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) { if (!dialect) {
return NULL; 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); 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); 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_attribute_definition *mie_ctx_get_attribute_definition(
const struct mie_ctx *ctx, const char *dialect_name, const struct mie_ctx *ctx, const char *dialect_name,
const char *attribute_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 id;
mie_id_init_ns( mie_id_init_ns(
&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); 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) { if (!dialect) {
return NULL; 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( mie_id_init_ns(
&id, mie_id_map_get_ns(&dialect->d_attributes), &id, mie_id_map_get_ns(&dialect->d_attributes),
&attribute_name_rope); &attribute_name_rope);
target = mie_id_map_get(&dialect->d_attributes, &id); 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_interface_definition *mie_ctx_get_interface_definition(
const struct mie_ctx *ctx, const char *dialect_name, const struct mie_ctx *ctx, const char *dialect_name,
const char *interface_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 id;
mie_id_init_ns( mie_id_init_ns(
&id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope); &id, mie_id_map_get_ns(&ctx->ctx_dialects), &dialect_name_rope);
mie_id *target = mie_id_map_get(&ctx->ctx_dialects, &id); 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) { if (!dialect) {
return NULL; 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( mie_id_init_ns(
&id, mie_id_map_get_ns(&dialect->d_interfaces), &id, mie_id_map_get_ns(&dialect->d_interfaces),
&interface_name_rope); &interface_name_rope);
target = mie_id_map_get(&dialect->d_interfaces, &id); 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( struct mie_type *mie_ctx_get_type(
@@ -264,13 +264,13 @@ struct mie_type *mie_ctx_get_type(
{ {
char full_name[256]; char full_name[256];
snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, type_name); 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 id;
mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &full_name_rope); 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); 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) { if (type) {
return type; return type;
} }
@@ -295,7 +295,7 @@ struct mie_type *mie_ctx_get_type(
memset(type, 0x0, sizeof *type); memset(type, 0x0, sizeof *type);
type->ty_def = type_info; 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) { if (type_info->ty_init) {
type_info->ty_init(type_info, type); type_info->ty_init(type_info, type);
@@ -311,13 +311,13 @@ const struct mie_trait *mie_ctx_get_trait(
{ {
char full_name[256]; char full_name[256];
snprintf(full_name, sizeof full_name, "%s.%s", dialect_name, trait_name); 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 id;
mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_traits), &full_name_rope); 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); 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) { if (trait) {
return trait; return trait;
} }
@@ -342,7 +342,7 @@ const struct mie_trait *mie_ctx_get_trait(
memset(trait, 0x0, sizeof trait_info->tr_data_size); memset(trait, 0x0, sizeof trait_info->tr_data_size);
trait->tr_def = trait_info; 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) { if (trait_info->tr_init) {
trait_info->tr_init(trait_info, trait); 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_builder_end(&id_builder, &id);
mie_id *target = mie_id_map_get(&ctx->ctx_types, &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) { if (type) {
return type; return type;
} }
@@ -389,7 +389,7 @@ struct mie_type *mie_ctx_get_function_type(
mie_id_builder_end(&id_builder, &id); mie_id_builder_end(&id_builder, &id);
mie_id *target = mie_id_map_get(&ctx->ctx_types, &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) { if (type) {
return type; return type;
} }
@@ -456,7 +456,7 @@ enum mie_status mie_ctx_get_pass(
} }
struct mie_pass_definition *pass_def 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)) { if (pass_def->p_data_size < sizeof(struct mie_pass)) {
return MIE_ERR_BAD_STATE; return MIE_ERR_BAD_STATE;
@@ -511,17 +511,17 @@ struct mie_diag *mie_ctx_push_diag(
diag->diag_parent = dialect; diag->diag_parent = dialect;
diag->diag_class = &dialect->d_diag_classes[diag_class]; 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; return diag;
} }
struct mie_diag *mie_ctx_pop_diag(struct mie_ctx *ctx) 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) { if (!entry) {
return NULL; return NULL;
} }
return b_unbox(struct mie_diag, entry, diag_entry); return fx_unbox(struct mie_diag, entry, diag_entry);
} }

12
mie/diag/diag.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/diag/amendment.h> #include <mie/diag/amendment.h>
#include <mie/diag/component.h> #include <mie/diag/component.h>
@@ -19,7 +19,7 @@ struct mie_diag_c_msg *diag_msg_create(const struct mie_diag_msg *content)
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->msg_base.c_type = MIE_DIAG_COMPONENT_MSG; 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; return out;
} }
@@ -91,7 +91,7 @@ void mie_diag_push_msg(
return; 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) 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); memset(c_msg, 0x0, sizeof *c_msg);
c_msg->msg_base.c_type = MIE_DIAG_COMPONENT_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( void mie_diag_push_snippet(
@@ -120,5 +120,5 @@ void mie_diag_push_snippet(
return; 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);
} }

2
mie/diag/diag.h
View File

@@ -1,6 +1,6 @@
#ifndef _DIAG_DIAG_H_ #ifndef _DIAG_DIAG_H_
#define _DIAG_DIAG_H_ #define _DIAG_DIAG_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#endif #endif

64
mie/dialect/arith/float-cache.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <stdlib.h> #include <stdlib.h>
@@ -10,19 +10,19 @@ typedef union float_key {
} float_key; } float_key;
struct float_width_cache_entry { struct float_width_cache_entry {
b_btree_node e_node; fx_bst_node e_node;
float_key e_key; float_key e_key;
struct mie_float e_value; struct mie_float e_value;
}; };
struct float_width_cache { struct float_width_cache {
b_btree_node c_node; fx_bst_node c_node;
size_t c_width; size_t c_width;
b_btree c_floats; fx_bst c_floats;
}; };
struct mie_float_cache { 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) 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); 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); 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); 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) { if (!tree->bst_root) {
tree->b_root = &node->e_node; tree->bst_root = &node->e_node;
b_btree_insert_fixup(tree, &node->e_node); fx_bst_insert_fixup(tree, &node->e_node);
return; return;
} }
b_btree_node *cur = tree->b_root; fx_bst_node *cur = tree->bst_root;
while (1) { while (1) {
struct float_width_cache_entry *cur_node 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);
b_btree_node *next = NULL; fx_bst_node *next = NULL;
int cmp = float_key_compare(&node->e_key, &cur_node->e_key); int cmp = float_key_compare(&node->e_key, &cur_node->e_key);
if (cmp >= 0) { if (cmp >= 0) {
next = b_btree_right(cur); next = fx_bst_right(cur);
if (!next) { if (!next) {
b_btree_put_right(cur, &node->e_node); fx_bst_put_right(cur, &node->e_node);
break; break;
} }
} else if (cmp < 0) { } else if (cmp < 0) {
next = b_btree_left(cur); next = fx_bst_left(cur);
if (!next) { if (!next) {
b_btree_put_left(cur, &node->e_node); fx_bst_put_left(cur, &node->e_node);
break; break;
} }
} else { } else {
@@ -71,20 +71,20 @@ void put_float(b_btree *tree, struct float_width_cache_entry *node)
cur = next; 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) { while (cur) {
struct float_width_cache_entry *cur_node 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); int cmp = float_key_compare(&key, &cur_node->e_key);
if (cmp > 0) { if (cmp > 0) {
cur = b_btree_right(cur); cur = fx_bst_right(cur);
} else if (cmp < 0) { } else if (cmp < 0) {
cur = b_btree_left(cur); cur = fx_bst_left(cur);
} else { } else {
return cur_node; 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) 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) { while (cur) {
b_btree_node *next = b_btree_next(cur); fx_bst_node *next = fx_bst_next(cur);
b_btree_delete(&cache->c_floats, cur); fx_bst_delete(&cache->c_floats, cur);
struct float_width_cache_entry *entry 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); free(entry);
cur = next; 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) 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) { while (cur) {
b_btree_node *next = b_btree_next(cur); fx_bst_node *next = fx_bst_next(cur);
b_btree_delete(&cache->c_widths, cur); fx_bst_delete(&cache->c_widths, cur);
struct float_width_cache *width_cache 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); float_width_cache_destroy(width_cache);
cur = next; cur = next;

34
mie/dialect/arith/int-cache.c
View File

@@ -1,32 +1,32 @@
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
struct int_width_cache_entry { struct int_width_cache_entry {
b_btree_node e_node; fx_bst_node e_node;
struct mie_int e_value; struct mie_int e_value;
}; };
struct int_width_cache { struct int_width_cache {
b_btree_node c_node; fx_bst_node c_node;
size_t c_width; size_t c_width;
b_btree c_ints; fx_bst c_ints;
}; };
struct mie_int_cache { 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); 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); 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); 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, struct int_width_cache_entry, uint64_t, e_node, e_value.i_val.v_small,
get_int); 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) 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) { while (cur) {
b_btree_node *next = b_btree_next(cur); fx_bst_node *next = fx_bst_next(cur);
b_btree_delete(&cache->c_ints, cur); fx_bst_delete(&cache->c_ints, cur);
struct int_width_cache_entry *entry 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); free(entry);
cur = next; 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) 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) { while (cur) {
b_btree_node *next = b_btree_next(cur); fx_bst_node *next = fx_bst_next(cur);
b_btree_delete(&cache->c_widths, cur); fx_bst_delete(&cache->c_widths, cur);
struct int_width_cache *width_cache 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); int_width_cache_destroy(width_cache);
cur = next; cur = next;

6
mie/dialect/arith/op/addf.c
View File

@@ -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 *left = &op->op_args.items[0];
const struct mie_op_arg *right = &op->op_args.items[1]; 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); 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); 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)); mie_printer_print_type(printer, mie_op_arg_get_type(left));
return MIE_SUCCESS; return MIE_SUCCESS;

6
mie/dialect/arith/op/addi.c
View File

@@ -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 *left = &op->op_args.items[0];
const struct mie_op_arg *right = &op->op_args.items[1]; 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); 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); 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)); mie_printer_print_type(printer, mie_op_arg_get_type(left));
return MIE_SUCCESS; return MIE_SUCCESS;

14
mie/dialect/arith/op/cmpi.c
View File

@@ -47,19 +47,19 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
return MIE_SUCCESS; return MIE_SUCCESS;
} }
b_stream_write_char(printer->p_stream, ' '); fx_stream_write_char(printer->p_stream, ' ');
if (pred < 0 || pred >= nr_predicates) { if (pred < 0 || pred >= nr_predicates) {
return MIE_ERR_BAD_STATE; 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); 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); 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)); mie_printer_print_type(printer, mie_op_arg_get_type(left));
return MIE_SUCCESS; return MIE_SUCCESS;
@@ -79,14 +79,14 @@ static enum mie_status parse(
return MIE_ERR_BAD_SYNTAX; 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)) { if (!mie_parser_parse_word(parser, tmp, &span)) {
mie_parser_report_unexpected_token_s( mie_parser_report_unexpected_token_s(
parser, "predicate word", "comparison operation"); parser, "predicate word", "comparison operation");
return MIE_ERR_BAD_SYNTAX; return MIE_ERR_BAD_SYNTAX;
} }
int pred = find_predicate(b_string_ptr(tmp)); int pred = find_predicate(fx_string_ptr(tmp));
if (pred == -1) { if (pred == -1) {
struct mie_diag *diag = mie_parser_report_error_simple( struct mie_diag *diag = mie_parser_report_error_simple(
parser, "arith", MIE_ARITH_E_INVALID_COMPARISON_PREDICATE, parser, "arith", MIE_ARITH_E_INVALID_COMPARISON_PREDICATE,

4
mie/dialect/arith/op/constant.c
View File

@@ -21,14 +21,14 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
const struct mie_type *type = NULL; const struct mie_type *type = NULL;
if (mie_attribute_check_name(value, "builtin", "int")) { if (mie_attribute_check_name(value, "builtin", "int")) {
const struct mie_int *i = (const struct mie_int *)value; 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); printer->p_stream, NULL, " %lld : ", i->i_val.v_small);
type = i->i_type; type = i->i_type;
} else if (mie_attribute_check_name(value, "builtin", "float")) { } else if (mie_attribute_check_name(value, "builtin", "float")) {
const struct mie_float *f = (const struct mie_float *)value; const struct mie_float *f = (const struct mie_float *)value;
double d; double d;
mie_float_get_value(value, &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; type = f->f_type;
} else { } else {
return MIE_SUCCESS; return MIE_SUCCESS;

14
mie/dialect/builtin/attribute/array.c
View File

@@ -13,27 +13,27 @@ static enum mie_status print(
const struct mie_array *array = (const struct mie_array *)value; const struct mie_array *array = (const struct mie_array *)value;
if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(array->a_items); i++) {
if (i > 0) { 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]); mie_printer_print_attribute(out, array->a_items.items[i]);
} }
if (MIE_VECTOR_COUNT(array->a_items) != 0) { 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)) { 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; return MIE_SUCCESS;

12
mie/dialect/builtin/attribute/float.c
View File

@@ -1,6 +1,6 @@
#include "../float.h" #include "../float.h"
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/attribute/attribute.h> #include <mie/attribute/attribute.h>
#include <mie/ctx.h> #include <mie/ctx.h>
@@ -17,28 +17,28 @@ static enum mie_status print(
const struct float_type *float_ty const struct float_type *float_ty
= (const struct float_type *)float_val->f_type; = (const struct float_type *)float_val->f_type;
if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { 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) { switch (float_ty->f_width) {
case MIE_FLOAT_32: 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, out->p_stream, NULL, "%f : f%zu", float_val->f_val.v_32,
float_ty->f_width); float_ty->f_width);
break; break;
case MIE_FLOAT_64: case MIE_FLOAT_64:
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "%lf : f%zu", out->p_stream, NULL, "%lf : f%zu",
float_val->f_val.v_64, float_ty->f_width); float_val->f_val.v_64, float_ty->f_width);
break; break;
default: default:
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "NaN : f%zu", float_ty->f_width); out->p_stream, NULL, "NaN : f%zu", float_ty->f_width);
break; break;
} }
if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { 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; return MIE_SUCCESS;

16
mie/dialect/builtin/attribute/int.c
View File

@@ -1,6 +1,6 @@
#include "../int.h" #include "../int.h"
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/attribute/attribute.h> #include <mie/attribute/attribute.h>
#include <mie/ctx.h> #include <mie/ctx.h>
@@ -18,32 +18,32 @@ static enum mie_status print(
bool abbrev = ((out->p_flags & MIE_PRINT_F_ABBREVIATED) != 0); bool abbrev = ((out->p_flags & MIE_PRINT_F_ABBREVIATED) != 0);
if (!abbrev) { 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) { 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, out->p_stream, NULL, "%zu", int_val->i_val.v_small,
int_ty->i_width); int_ty->i_width);
} else { } 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) { 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) { if (abbrev) {
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "i%zu", int_ty->i_width); out->p_stream, NULL, "i%zu", int_ty->i_width);
} else { } else {
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "!builtin.int<%zu>", out->p_stream, NULL, "!builtin.int<%zu>",
int_ty->i_width); int_ty->i_width);
} }
} }
if (!abbrev) { if (!abbrev) {
b_stream_write_string(out->p_stream, ">", NULL); fx_stream_write_string(out->p_stream, ">", NULL);
} }
return MIE_SUCCESS; return MIE_SUCCESS;

8
mie/dialect/builtin/attribute/string.c
View File

@@ -11,9 +11,9 @@ static enum mie_status print(
{ {
const struct mie_string *str = (const struct mie_string *)value; const struct mie_string *str = (const struct mie_string *)value;
if (out->p_flags & MIE_PRINT_F_ABBREVIATED) { 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 { } else {
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "#builtin.string<\"%s\">", out->p_stream, NULL, "#builtin.string<\"%s\">",
str->str_val); str->str_val);
} }
@@ -23,14 +23,14 @@ static enum mie_status print(
static enum mie_status parse( static enum mie_status parse(
struct mie_parser *ctx, const struct mie_attribute **out) 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; struct mie_file_span span;
if (!mie_parser_parse_string(ctx, str, &span)) { if (!mie_parser_parse_string(ctx, str, &span)) {
return MIE_ERR_BAD_SYNTAX; return MIE_ERR_BAD_SYNTAX;
} }
struct mie_attribute *v = mie_ctx_get_string( 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) { if (!v) {
return MIE_ERR_NO_MEMORY; return MIE_ERR_NO_MEMORY;

4
mie/dialect/builtin/attribute/type.c
View File

@@ -30,13 +30,13 @@ static enum mie_status print(
const struct mie_type_attr *ty = (const struct mie_type_attr *)value; const struct mie_type_attr *ty = (const struct mie_type_attr *)value;
if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { 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); mie_printer_print_type(out, ty->ty_value);
if (!(out->p_flags & MIE_PRINT_F_ABBREVIATED)) { 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; return MIE_SUCCESS;

1
mie/dialect/builtin/diag.c
View File

@@ -31,6 +31,7 @@ MIE_DIAG_CLASS_LIST_END(mie_builtin_diag)
MIE_DIAG_MSG_LIST_BEGIN(mie_builtin_msg) MIE_DIAG_MSG_LIST_BEGIN(mie_builtin_msg)
MIE_DIAG_MSG(UNRECOGNISED_TOKEN, "encountered an unrecognised token.") 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_VALUE, "cannot resolve this value reference.")
MIE_DIAG_MSG( MIE_DIAG_MSG(
UNRESOLVED_BUILTIN_TYPE, UNRESOLVED_BUILTIN_TYPE,

18
mie/dialect/builtin/index-cache.c
View File

@@ -1,21 +1,21 @@
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
struct index_cache_entry { struct index_cache_entry {
b_btree_node e_node; fx_bst_node e_node;
struct mie_index e_value; struct mie_index e_value;
}; };
struct mie_index_cache { 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); 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); struct index_cache_entry, size_t, e_node, e_value.i_value, get_index);
static struct index_cache_entry *index_cache_entry_create( 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) 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) { while (cur) {
b_btree_node *next = b_btree_next(cur); fx_bst_node *next = fx_bst_next(cur);
b_btree_delete(&cache->c_entries, cur); fx_bst_delete(&cache->c_entries, cur);
struct index_cache_entry *entry 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); free(entry);
cur = next; cur = next;

2
mie/dialect/builtin/op/module.c
View File

@@ -9,7 +9,7 @@
static enum mie_status print(struct mie_printer *out, const struct mie_op *op) 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); struct mie_region *region = mie_op_get_first_region(op);
if (region) { if (region) {

22
mie/dialect/builtin/string-cache.c
View File

@@ -1,12 +1,12 @@
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/ds/hashmap.h> #include <fx/ds/hashmap.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
struct mie_string_cache { struct mie_string_cache {
b_hashmap *c_entries; fx_hashmap *c_entries;
}; };
static struct mie_string *mie_string_create( static struct mie_string *mie_string_create(
@@ -19,7 +19,7 @@ static struct mie_string *mie_string_create(
out->str_base.a_def out->str_base.a_def
= mie_ctx_get_attribute_definition(ctx, "builtin", "string"); = mie_ctx_get_attribute_definition(ctx, "builtin", "string");
out->str_val = b_strdup(s); out->str_val = fx_strdup(s);
if (!out->str_val) { if (!out->str_val) {
return NULL; return NULL;
} }
@@ -42,8 +42,8 @@ struct mie_string_cache *mie_string_cache_create(void)
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->c_entries = b_hashmap_create( out->c_entries = fx_hashmap_create(
NULL, (b_hashmap_value_destructor)mie_string_destroy); NULL, (fx_hashmap_value_destructor)mie_string_destroy);
if (!out->c_entries) { if (!out->c_entries) {
free(out); free(out);
return NULL; 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) void mie_string_cache_destroy(struct mie_string_cache *cache)
{ {
b_hashmap_unref(cache->c_entries); fx_hashmap_unref(cache->c_entries);
free(cache); 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) struct mie_string_cache *cache, struct mie_ctx *ctx, const char *s)
{ {
size_t s_len = strlen(s); size_t s_len = strlen(s);
b_hashmap_key key = {.key_data = s, .key_size = s_len}; fx_hashmap_key key = {.key_data = s, .key_size = s_len};
const b_hashmap_value *value = b_hashmap_get(cache->c_entries, &key); const fx_hashmap_value *value = fx_hashmap_get(cache->c_entries, &key);
if (value) { if (value) {
return value->value_data; return value->value_data;
} }
@@ -73,8 +73,8 @@ struct mie_string *mie_string_cache_get(
return NULL; return NULL;
} }
b_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str}; fx_hashmap_value new_val = {.value_data = str, .value_size = sizeof *str};
b_hashmap_put(cache->c_entries, &key, &new_val); fx_hashmap_put(cache->c_entries, &key, &new_val);
return str; return str;
} }

14
mie/dialect/builtin/type/float.c
View File

@@ -1,6 +1,6 @@
#include "../float.h" #include "../float.h"
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
@@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_float_type(struct mie_ctx *ctx, size_t bit_width)
return NULL; return NULL;
} }
b_rope rope_i = B_ROPE_CHAR('f'), rope_width = B_ROPE_UINT(bit_width); fx_rope rope_i = FX_ROPE_CHAR('f'), rope_width = FX_ROPE_UINT(bit_width);
b_rope type_name; fx_rope type_name;
b_rope_concat(&type_name, &rope_i, &rope_width); fx_rope_concat(&type_name, &rope_i, &rope_width);
mie_id id; mie_id id;
mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name); 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); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
if (target) { 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); 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; 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_base.ty_instance_size = sizeof(struct mie_float);
type->f_width = bit_width; 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) 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; 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_stream, NULL,
(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" : "!builtin.float<%zu>", (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "f%zu" : "!builtin.float<%zu>",
float_type->f_width); float_type->f_width);

14
mie/dialect/builtin/type/int.c
View File

@@ -1,6 +1,6 @@
#include "../int.h" #include "../int.h"
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
@@ -17,16 +17,16 @@ struct mie_type *mie_ctx_get_int_type(struct mie_ctx *ctx, size_t bit_width)
return NULL; return NULL;
} }
b_rope rope_i = B_ROPE_CHAR('i'), rope_width = B_ROPE_UINT(bit_width); fx_rope rope_i = FX_ROPE_CHAR('i'), rope_width = FX_ROPE_UINT(bit_width);
b_rope type_name; fx_rope type_name;
b_rope_concat(&type_name, &rope_i, &rope_width); fx_rope_concat(&type_name, &rope_i, &rope_width);
mie_id id; mie_id id;
mie_id_init_ns(&id, mie_id_map_get_ns(&ctx->ctx_types), &type_name); 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); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
if (target) { 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); 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; 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_base.ty_instance_size = sizeof(struct mie_int);
type->i_width = bit_width; 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) 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; 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_stream, NULL,
(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu" (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "i%zu"
: "!builtin.int<%zu>", : "!builtin.int<%zu>",

36
mie/dialect/builtin/type/memref.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
@@ -48,7 +48,7 @@ struct mie_type *mie_ctx_get_memref_type(
mie_id *target = mie_id_map_get(&ctx->ctx_types, &id); mie_id *target = mie_id_map_get(&ctx->ctx_types, &id);
if (target) { if (target) {
return b_unbox(struct mie_type, target, ty_id); return fx_unbox(struct mie_type, target, ty_id);
} }
struct memref_type *type struct memref_type *type
@@ -57,40 +57,40 @@ struct mie_type *mie_ctx_get_memref_type(
return NULL; return NULL;
} }
b_bstr type_name; fx_bstr type_name;
b_bstr_begin_dynamic(&type_name); fx_bstr_begin_dynamic(&type_name);
b_bstr_write_cstr(&type_name, "builtin.memref<", NULL); fx_bstr_write_cstr(&type_name, "builtin.memref<", NULL);
struct mie_printer printer; struct mie_printer printer;
mie_printer_init( 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++) { for (size_t i = 0; i < nr_ranks; i++) {
mie_vector_push_back(type->m_rank, &ranks[i], NULL); mie_vector_push_back(type->m_rank, &ranks[i], NULL);
if (i > 0) { if (i > 0) {
b_bstr_write_char(&type_name, '*'); fx_bstr_write_char(&type_name, '*');
} }
switch (ranks[i].r_ranktype) { switch (ranks[i].r_ranktype) {
case MIE_MEMREF_RANK_UNKNOWN: case MIE_MEMREF_RANK_UNKNOWN:
b_bstr_write_char(&type_name, '?'); fx_bstr_write_char(&type_name, '?');
break; break;
case MIE_MEMREF_RANK_TYPE: case MIE_MEMREF_RANK_TYPE:
mie_printer_print_type(&printer, ranks[i].r_type); mie_printer_print_type(&printer, ranks[i].r_type);
break; break;
case MIE_MEMREF_RANK_STATIC: 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; break;
default: default:
break; break;
} }
} }
b_bstr_write_char(&type_name, '>'); fx_bstr_write_char(&type_name, '>');
type->m_base.ty_name = b_bstr_end(&type_name); type->m_base.ty_name = fx_bstr_end(&type_name);
type->m_base.ty_instance_size = 0; 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); mie_id_map_put(&ctx->ctx_types, &type->m_base.ty_id, &name_rope);
return (struct mie_type *)type; 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) 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; const struct memref_type *memref_ty = (const struct memref_type *)ty;
b_stream_write_string( fx_stream_write_string(
out->p_stream, out->p_stream,
(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "memref" (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "memref"
: "builtin.memref", : "builtin.memref",
NULL); 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++) { 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]; const struct mie_memref_rank *rank = &memref_ty->m_rank.items[i];
if (i > 0) { if (i > 0) {
b_stream_write_char(out->p_stream, '*'); fx_stream_write_char(out->p_stream, '*');
} }
switch (rank->r_ranktype) { switch (rank->r_ranktype) {
case MIE_MEMREF_RANK_UNKNOWN: case MIE_MEMREF_RANK_UNKNOWN:
b_stream_write_char(out->p_stream, '?'); fx_stream_write_char(out->p_stream, '?');
break; break;
case MIE_MEMREF_RANK_TYPE: case MIE_MEMREF_RANK_TYPE:
mie_printer_print_type(out, rank->r_type); mie_printer_print_type(out, rank->r_type);
break; break;
case MIE_MEMREF_RANK_STATIC: case MIE_MEMREF_RANK_STATIC:
b_stream_write_fmt( fx_stream_write_fmt(
out->p_stream, NULL, "%zu", rank->r_static); out->p_stream, NULL, "%zu", rank->r_static);
break; break;
default: default:
break; break;
} }
} }
b_stream_write_char(out->p_stream, '>'); fx_stream_write_char(out->p_stream, '>');
return MIE_SUCCESS; return MIE_SUCCESS;
} }

4
mie/dialect/builtin/type/string.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/builtin.h> #include <mie/dialect/builtin.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
@@ -15,7 +15,7 @@ static void type_init(
static enum mie_status print(const struct mie_type *ty, struct mie_printer *out) 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_stream,
(out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "str" : "!builtin.string", (out->p_flags & MIE_PRINT_F_ABBREVIATED) ? "str" : "!builtin.string",
NULL); NULL);

10
mie/dialect/cf/op/br-cond.c
View File

@@ -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_true = &op->op_successors.items[0];
const struct mie_op_successor *if_false = &op->op_successors.items[1]; 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); 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); 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); mie_printer_print_op_successor(printer, if_false, true);
return MIE_SUCCESS; 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) static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out)
{ {
memset(out, 0x0, sizeof *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; bool result = false;
if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { 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; 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 if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED
|| mie_parser_peek_symbol(ctx) == MIE_SYM_COMMA) { || mie_parser_peek_symbol(ctx) == MIE_SYM_COMMA) {

6
mie/dialect/cf/op/br.c
View File

@@ -9,7 +9,7 @@
static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) 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]; const struct mie_op_successor *successor = &op->op_successors.items[0];
mie_printer_print_op_successor(printer, successor, true); 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) static bool parse_successor(struct mie_parser *ctx, struct mie_op_successor *out)
{ {
memset(out, 0x0, sizeof *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; bool result = false;
if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { 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; 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) { if (mie_parser_peek_type(ctx) == MIE_TOK_LINEFEED) {
goto ok; goto ok;

14
mie/dialect/dialect.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/ir/op-definition.h> #include <mie/ir/op-definition.h>
@@ -37,7 +37,7 @@ struct mie_dialect *mie_dialect_create(
memset(out, 0x0, size); memset(out, 0x0, size);
out->d_name = b_strdup(name); out->d_name = fx_strdup(name);
if (!out->d_name) { if (!out->d_name) {
free(out); free(out);
return NULL; return NULL;
@@ -58,7 +58,7 @@ struct mie_dialect *mie_dialect_create(
mie_id interface_ns = INTERFACE_NS_ID; mie_id interface_ns = INTERFACE_NS_ID;
mie_id_map_init(&out->d_interfaces, &interface_ns); 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); mie_id_map_put(&ctx->ctx_dialects, &out->d_id, &name_rope);
return out; return out;
@@ -67,21 +67,21 @@ struct mie_dialect *mie_dialect_create(
const struct mie_op_definition *mie_dialect_get_op( const struct mie_op_definition *mie_dialect_get_op(
const struct mie_dialect *dialect, const char *name) 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 id;
mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_ops), &name_rope); 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); 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_type_definition *mie_dialect_get_type(
const struct mie_dialect *dialect, const char *name) 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 id;
mie_id_init_ns(&id, mie_id_map_get_ns(&dialect->d_types), &name_rope); 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); 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);
} }

18
mie/dialect/func/op/func.c
View File

@@ -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_ty
= (const struct mie_function_type *)function_type_g; = (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_region *code = mie_op_get_first_region(op);
const struct mie_block *entry = mie_region_get_first_block(code); const struct mie_block *entry = mie_region_get_first_block(code);
for (size_t i = 0; i < MIE_VECTOR_COUNT(entry->b_params); i++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(entry->b_params); i++) {
if (i > 0) { 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]; 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); 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) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(function_ty->func_out); i++) {
if (i > 0) { 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]; 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) { 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( mie_printer_print_region(
printer, code, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER); printer, code, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER);
@@ -107,7 +107,7 @@ static enum mie_status parse(
return MIE_ERR_BAD_SYNTAX; 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)) { if (!mie_parser_parse_symname(parser, temp, NULL)) {
mie_parser_report_unexpected_token( mie_parser_report_unexpected_token(
parser, MIE_TOK_SYMNAME, "function signature"); parser, MIE_TOK_SYMNAME, "function signature");
@@ -115,7 +115,7 @@ static enum mie_status parse(
} }
struct mie_attribute *sym_name = mie_ctx_get_string( 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)) { if (!mie_parser_parse_symbol(parser, MIE_SYM_LEFT_PAREN)) {
mie_parser_report_unexpected_token( mie_parser_report_unexpected_token(

8
mie/dialect/func/op/return.c
View File

@@ -15,21 +15,21 @@
static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { 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); 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { if (i > 0) {
b_stream_write_string(printer->p_stream, ", ", NULL); fx_stream_write_string(printer->p_stream, ", ", NULL);
} }
mie_printer_print_type( mie_printer_print_type(

16
mie/dialect/memref/op/load.c
View File

@@ -13,26 +13,26 @@
static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) 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; const struct mie_type *memref_type = NULL;
if (MIE_VECTOR_COUNT(op->op_args) > 0) { if (MIE_VECTOR_COUNT(op->op_args) > 0) {
mie_printer_print_op_arg(printer, &op->op_args.items[0], false); mie_printer_print_op_arg(printer, &op->op_args.items[0], false);
memref_type = mie_op_arg_get_type(&op->op_args.items[0]); 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++) { for (size_t i = 1; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 1) { 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); 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) { 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); 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) struct mie_parser *ctx, struct mie_op_arg *out, const char *context)
{ {
memset(out, 0x0, sizeof *out); 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; struct mie_file_span loc;
if (mie_parser_parse_vregname(ctx, str, &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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL;
} else if (mie_parser_parse_mregname(ctx, str, &loc)) { } 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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE;
} else { } else {
struct mie_parser_item required[] = { struct mie_parser_item required[] = {

24
mie/dialect/scf/op/for.c
View File

@@ -40,35 +40,35 @@ static enum mie_status print(struct mie_printer *printer, const struct mie_op *o
ub = &op->op_args.items[1]; ub = &op->op_args.items[1];
step = &op->op_args.items[2]; 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); 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); 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); 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); mie_printer_print_op_arg(printer, step, 0);
if (MIE_VECTOR_COUNT(entry->b_params) > 1) { 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++) { for (size_t i = 1; i < MIE_VECTOR_COUNT(entry->b_params); i++) {
if (i > 1) { if (i > 1) {
b_stream_write_string(printer->p_stream, ", ", NULL); fx_stream_write_string(printer->p_stream, ", ", NULL);
} }
mie_printer_print_register( mie_printer_print_register(
printer, &entry->b_params.items[i], 0); 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( mie_printer_print_op_arg(
printer, &op->op_args.items[i + 2], false); 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) { 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) { 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++) { 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) { 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( mie_printer_print_region(
printer, body, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER); printer, body, MIE_PRINT_F_EXCLUDE_FIRST_BLOCK_HEADER);

14
mie/dialect/scf/op/if.c
View File

@@ -8,30 +8,30 @@
static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) 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); mie_printer_print_op_arg(printer, &op->op_args.items[0], false);
if (MIE_VECTOR_COUNT(op->op_result) > 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);
if (MIE_VECTOR_COUNT(op->op_result) > 1) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
if (i > 0) { 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); mie_printer_print_type(printer, op->op_result.items[i].reg_type);
} }
if (MIE_VECTOR_COUNT(op->op_result) > 1) { 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 *if_region = mie_op_get_first_region(op);
struct mie_region *else_region = mie_op_get_next_region(op, if_region); 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); mie_printer_print_region(printer, if_region, 0);
if (else_region) { 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); mie_printer_print_region(printer, else_region, 0);
} }

8
mie/dialect/scf/op/yield.c
View File

@@ -9,20 +9,20 @@
static enum mie_status print(struct mie_printer *printer, const struct mie_op *op) 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { 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); 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { if (i > 0) {
b_stream_write_string(printer->p_stream, ", ", NULL); fx_stream_write_string(printer->p_stream, ", ", NULL);
} }
mie_printer_print_type( mie_printer_print_type(

90
mie/id.c
View File

@@ -1,7 +1,7 @@
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <blue/core/endian.h> #include <fx/core/endian.h>
#include <blue/core/hash.h> #include <fx/core/hash.h>
#include <blue/core/random.h> #include <fx/core/random.h>
#include <mie/id.h> #include <mie/id.h>
#include <string.h> #include <string.h>
@@ -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); 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) { 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( int cmp = memcmp(
key->id_bytes, cur_node->id_bytes, sizeof key->id_bytes); key->id_bytes, cur_node->id_bytes, sizeof key->id_bytes);
if (cmp > 0) { if (cmp > 0) {
cur = b_btree_right(cur); cur = fx_bst_right(cur);
} else if (cmp < 0) { } else if (cmp < 0) {
cur = b_btree_left(cur); cur = fx_bst_left(cur);
} else { } else {
return cur_node; return cur_node;
} }
@@ -30,33 +30,33 @@ static mie_id *get_id(const b_btree *tree, mie_id *key)
return NULL; return NULL;
} }
void put_id(b_btree *tree, mie_id *node) void put_id(fx_bst *tree, mie_id *node)
{ {
if (!tree->b_root) { if (!tree->bst_root) {
tree->b_root = &node->e_node; tree->bst_root = &node->e_node;
b_btree_insert_fixup(tree, &node->e_node); fx_bst_insert_fixup(tree, &node->e_node);
return; return;
} }
b_btree_node *cur = tree->b_root; fx_bst_node *cur = tree->bst_root;
while (1) { while (1) {
mie_id *cur_node = b_unbox(mie_id, cur, e_node); mie_id *cur_node = fx_unbox(mie_id, cur, e_node);
b_btree_node *next = NULL; fx_bst_node *next = NULL;
int cmp = memcmp( int cmp = memcmp(
node->id_bytes, cur_node->id_bytes, sizeof node->id_bytes); node->id_bytes, cur_node->id_bytes, sizeof node->id_bytes);
if (cmp > 0) { if (cmp > 0) {
next = b_btree_right(cur); next = fx_bst_right(cur);
if (!next) { if (!next) {
b_btree_put_right(cur, &node->e_node); fx_bst_put_right(cur, &node->e_node);
break; break;
} }
} else if (cmp < 0) { } else if (cmp < 0) {
next = b_btree_left(cur); next = fx_bst_left(cur);
if (!next) { if (!next) {
b_btree_put_left(cur, &node->e_node); fx_bst_put_left(cur, &node->e_node);
break; break;
} }
} else { } else {
@@ -66,17 +66,17 @@ void put_id(b_btree *tree, mie_id *node)
cur = next; cur = next;
} }
b_btree_insert_fixup(tree, &node->e_node); fx_bst_insert_fixup(tree, &node->e_node);
} }
void mie_id_init( void mie_id_init(
mie_id *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d, uint64_t e) 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); fx_i32 x_a = fx_i32_htob(a);
b_i16 x_b = b_i16_htob(b); fx_i16 x_b = fx_i16_htob(b);
b_i16 x_c = b_i16_htob(c); fx_i16 x_c = fx_i16_htob(c);
b_i16 x_d = b_i16_htob(d); fx_i16 x_d = fx_i16_htob(d);
b_i64 x_e = b_i64_htob(e); 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[0], x_a.i_bytes, sizeof x_a.i_bytes);
memcpy(&out->id_bytes[4], x_b.i_bytes, sizeof x_b.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) void mie_id_init_random(mie_id *out)
{ {
b_random_ctx *random = b_random_global_ctx(); fx_random_ctx *random = fx_random_global_ctx();
b_random_next_bytes( fx_random_next_bytes(
random, (unsigned char *)out->id_bytes, sizeof out->id_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; struct mie_id_builder ctx;
mie_id_builder_begin(&ctx, ns); 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) void mie_id_to_string(const mie_id *id, char *out, size_t max)
{ {
b_bstr str; fx_bstr str;
b_bstr_begin(&str, out, max); fx_bstr_begin(&str, out, max);
for (size_t i = 0; i < sizeof id->id_bytes; i++) { for (size_t i = 0; i < sizeof id->id_bytes; i++) {
if (i == 4 || i == 6 || i == 8 || i == 10) { 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) void mie_id_builder_begin(struct mie_id_builder *builder, const mie_id *ns)
{ {
memset(builder, 0x0, sizeof *builder); memset(builder, 0x0, sizeof *builder);
b_hash_ctx_init(&builder->b_hash, B_HASH_SHA1); fx_hash_ctx_init(&builder->b_hash, FX_HASH_SHA1);
b_hash_ctx_update(&builder->b_hash, ns->id_bytes, sizeof ns->id_bytes); 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) 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( void mie_id_builder_add_marker(
struct mie_id_builder *builder, enum mie_id_builder_marker marker) struct mie_id_builder *builder, enum mie_id_builder_marker marker)
{ {
unsigned char c = 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) void mie_id_builder_end(struct mie_id_builder *builder, mie_id *out)
{ {
memset(out, 0x0, sizeof *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] &= 0x0F;
out->id_bytes[6] |= 0x50; 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; 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); mie_id_init_ns(id, &map->map_ns_id, name);
put_id(&map->map_entries, id); put_id(&map->map_entries, id);
@@ -187,13 +187,13 @@ enum mie_status mie_id_map_iterator_begin(
{ {
memset(it, 0x0, sizeof *it); memset(it, 0x0, sizeof *it);
it->_n = b_btree_first(&map->map_entries); it->_n = fx_bst_first(&map->map_entries);
if (!it->_n) { if (!it->_n) {
return MIE_ERR_NO_DATA; 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; 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; return MIE_ERR_NO_DATA;
} }
it->_n = b_btree_next(it->_n); it->_n = fx_bst_next(it->_n);
if (!it->_n) { if (!it->_n) {
it->it_id = NULL; it->it_id = NULL;
return MIE_ERR_NO_DATA; 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; return MIE_SUCCESS;
} }

12
mie/include/mie/attribute/attribute-map.h
View File

@@ -1,14 +1,14 @@
#ifndef MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_ #ifndef MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
#define MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_ #define MIE_ATTRIBUTE_ATTRIBUTE_MAP_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>
struct b_queue_entry; struct fx_queue_entry;
struct mie_attribute_map { struct mie_attribute_map {
b_btree m_entries; fx_bst m_entries;
}; };
enum mie_attribute_map_flags { enum mie_attribute_map_flags {
@@ -18,8 +18,8 @@ enum mie_attribute_map_flags {
struct mie_attribute_map_iterator { struct mie_attribute_map_iterator {
const char *it_name; const char *it_name;
const struct mie_attribute *it_value; const struct mie_attribute *it_value;
b_btree_node *_n; fx_bst_node *_n;
struct b_queue_entry *_e; struct fx_queue_entry *_e;
}; };
MIE_API void mie_attribute_map_init(struct mie_attribute_map *map); 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) 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( MIE_API const struct mie_attribute *mie_attribute_map_get(

10
mie/include/mie/ctx.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_CTX_H_ #ifndef MIE_CTX_H_
#define MIE_CTX_H_ #define MIE_CTX_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/ds/hashmap.h> #include <fx/ds/hashmap.h>
#include <mie/id.h> #include <mie/id.h>
struct mie_op; struct mie_op;
@@ -21,8 +21,8 @@ struct mie_ctx {
struct mie_const *ctx_true, *ctx_false; struct mie_const *ctx_true, *ctx_false;
struct mie_value *ctx_null; struct mie_value *ctx_null;
struct mie_type *ctx_types[__MIE_TYPE_COUNT]; struct mie_type *ctx_types[__MIE_TYPE_COUNT];
b_hashmap *ctx_sel_cache; fx_hashmap *ctx_sel_cache;
b_hashmap *ctx_string_cache; fx_hashmap *ctx_string_cache;
#endif #endif
/* map of struct mie_dialect */ /* map of struct mie_dialect */
struct mie_id_map ctx_dialects; struct mie_id_map ctx_dialects;
@@ -35,7 +35,7 @@ struct mie_ctx {
/* map of struct mie_pass_definition */ /* map of struct mie_pass_definition */
struct mie_id_map ctx_passes; struct mie_id_map ctx_passes;
/* queue of struct mie_diag */ /* queue of struct mie_diag */
b_queue ctx_diag; fx_queue ctx_diag;
}; };
MIE_API struct mie_ctx *mie_ctx_create(void); MIE_API struct mie_ctx *mie_ctx_create(void);

4
mie/include/mie/diag/component.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_DIAG_COMPONENT_H_ #ifndef MIE_DIAG_COMPONENT_H_
#define MIE_DIAG_COMPONENT_H_ #define MIE_DIAG_COMPONENT_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <stddef.h> #include <stddef.h>
enum mie_diag_component_type { enum mie_diag_component_type {
@@ -12,7 +12,7 @@ enum mie_diag_component_type {
struct mie_diag_component { struct mie_diag_component {
enum mie_diag_component_type c_type; enum mie_diag_component_type c_type;
b_queue_entry c_entry; fx_queue_entry c_entry;
}; };
struct mie_diag_c_snippet { struct mie_diag_c_snippet {

6
mie/include/mie/diag/diag.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_DIAG_DIAG_H_ #ifndef MIE_DIAG_DIAG_H_
#define MIE_DIAG_DIAG_H_ #define MIE_DIAG_DIAG_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/parse/file-span.h> #include <mie/parse/file-span.h>
#define MIE_DIAG_HL(type, span) \ #define MIE_DIAG_HL(type, span) \
@@ -55,8 +55,8 @@ struct mie_diag {
struct mie_line_source *diag_src; struct mie_line_source *diag_src;
struct mie_file_cell diag_loc; struct mie_file_cell diag_loc;
b_queue_entry diag_entry; fx_queue_entry diag_entry;
b_queue diag_components; fx_queue diag_components;
}; };
MIE_API void mie_diag_set_location( MIE_API void mie_diag_set_location(

2
mie/include/mie/dialect/builtin.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_DIALECT_BUILTIN_H_ #ifndef MIE_DIALECT_BUILTIN_H_
#define MIE_DIALECT_BUILTIN_H_ #define MIE_DIALECT_BUILTIN_H_
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/attribute/attribute.h> #include <mie/attribute/attribute.h>
#include <mie/interface/interface.h> #include <mie/interface/interface.h>
#include <mie/misc.h> #include <mie/misc.h>

4
mie/include/mie/dialect/dialect.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_DIALECT_DIALECT_H_ #ifndef MIE_DIALECT_DIALECT_H_
#define MIE_DIALECT_DIALECT_H_ #define MIE_DIALECT_DIALECT_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/id.h> #include <mie/id.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/vector.h> #include <mie/vector.h>

24
mie/include/mie/id.h
View File

@@ -1,9 +1,9 @@
#ifndef MIE_ID_H_ #ifndef MIE_ID_H_
#define MIE_ID_H_ #define MIE_ID_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <blue/core/rope.h> #include <fx/core/rope.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>
#include <stddef.h> #include <stddef.h>
@@ -42,30 +42,30 @@ typedef struct mie_id {
}; };
union { union {
b_btree_node e_node; fx_bst_node e_node;
b_queue_entry e_entry; fx_queue_entry e_entry;
}; };
} mie_id; } mie_id;
struct mie_id_builder { struct mie_id_builder {
b_hash_ctx b_hash; fx_hash_ctx b_hash;
}; };
struct mie_id_map { struct mie_id_map {
mie_id map_ns_id; mie_id map_ns_id;
b_btree map_entries; fx_bst map_entries;
}; };
struct mie_id_map_iterator { struct mie_id_map_iterator {
mie_id *it_id; mie_id *it_id;
b_btree_node *_n; fx_bst_node *_n;
}; };
MIE_API void mie_id_init( 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_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_zero(mie_id *out);
MIE_API void mie_id_init_random(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) 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_id_builder_add(builder, s, len);
} }
MIE_API void mie_id_builder_add_rope( 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( MIE_API void mie_id_builder_add_marker(
struct mie_id_builder *builder, enum mie_id_builder_marker 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); 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); 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) 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 const mie_id *mie_id_map_get_ns(const struct mie_id_map *map);
MIE_API void mie_id_map_put( 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 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); MIE_API mie_id *mie_id_map_get(const struct mie_id_map *map, mie_id *id);

6
mie/include/mie/ir/block.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_IR_BLOCK_H_ #ifndef MIE_IR_BLOCK_H_
#define MIE_IR_BLOCK_H_ #define MIE_IR_BLOCK_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/name.h> #include <mie/name.h>
#include <mie/vector.h> #include <mie/vector.h>
@@ -26,11 +26,11 @@ struct mie_block {
unsigned int b_id; unsigned int b_id;
struct mie_block *b_idom; struct mie_block *b_idom;
// struct mie_block *b_sdom, *b_dfs_parent; // 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); MIE_VECTOR_DECLARE(struct mie_register, b_params);
/* queue of struct mie_op */ /* queue of struct mie_op */
b_queue b_ops; fx_queue b_ops;
}; };
extern struct mie_vector_ops mie_block_vector_ops; extern struct mie_vector_ops mie_block_vector_ops;

4
mie/include/mie/ir/op-definition.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_IR_OP_DEFINITION_H_ #ifndef MIE_IR_OP_DEFINITION_H_
#define MIE_IR_OP_DEFINITION_H_ #define MIE_IR_OP_DEFINITION_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/id.h> #include <mie/id.h>
#include <mie/interface/interface-map.h> #include <mie/interface/interface-map.h>
#include <mie/status.h> #include <mie/status.h>

4
mie/include/mie/ir/op.h
View File

@@ -52,7 +52,7 @@ struct mie_op_successor {
struct mie_op { struct mie_op {
enum mie_op_flags op_flags; enum mie_op_flags op_flags;
/* used by struct mie_block */ /* used by struct mie_block */
b_queue_entry op_entry; fx_queue_entry op_entry;
struct mie_line_source *op_src; struct mie_line_source *op_src;
/* this pointer is only valid if the F_OP_RESOLVED flag is set */ /* 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 */ /* only valid if the F_RESOLVED flag is NOT set */
char *op_name; char *op_name;
b_queue op_regions; fx_queue op_regions;
MIE_VECTOR_DECLARE(struct mie_op_successor, op_successors); MIE_VECTOR_DECLARE(struct mie_op_successor, op_successors);
struct mie_attribute_map op_attrib; struct mie_attribute_map op_attrib;

14
mie/include/mie/ir/region.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_IR_REGION_H_ #ifndef MIE_IR_REGION_H_
#define MIE_IR_REGION_H_ #define MIE_IR_REGION_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/vector.h> #include <mie/vector.h>
#include <stddef.h> #include <stddef.h>
@@ -15,12 +15,12 @@ struct mie_region {
struct mie_name_map *r_names; struct mie_name_map *r_names;
struct mie_op *r_parent; struct mie_op *r_parent;
/* used by struct mie_op */ /* used by struct mie_op */
b_queue_entry r_entry; fx_queue_entry r_entry;
/* queue of struct mie_block */ /* 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. /* bst of struct mie_block, as numbered by a depth-first search.
* this ordering is recalculated by mie_region_refresh_dominance */ * 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( 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 * this function populates the following attributes of every block in the
* region: * region:
* b_id * b_id
* b_node * fx_node
* b_parent * fx_parent
* as well as the following attributes of the region itself: * as well as the following attributes of the region itself:
* r_blocks_s * r_blocks_s
* only top-level blocks and ops are considered by this function. if an op * only top-level blocks and ops are considered by this function. if an op

4
mie/include/mie/ir/register.h
View File

@@ -30,7 +30,7 @@ struct mie_register_ref {
/* represents a use of/resolved reference to a mie_register */ /* represents a use of/resolved reference to a mie_register */
struct mie_register_use { struct mie_register_use {
b_queue_entry u_entry; fx_queue_entry u_entry;
struct mie_op *u_user; struct mie_op *u_user;
struct mie_register *u_reg; struct mie_register *u_reg;
}; };
@@ -59,7 +59,7 @@ struct mie_register {
struct mie_op *reg_op; struct mie_op *reg_op;
/* list of struct mie_register_use, representing all the places /* list of struct mie_register_use, representing all the places
* where this register is used. */ * where this register is used. */
b_queue reg_use; fx_queue reg_use;
}; };
extern struct mie_vector_ops mie_register_vector_ops; extern struct mie_vector_ops mie_register_vector_ops;

6
mie/include/mie/ir/walk.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_IR_WALK_H_ #ifndef MIE_IR_WALK_H_
#define MIE_IR_WALK_H_ #define MIE_IR_WALK_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>
#include <stddef.h> #include <stddef.h>
@@ -35,7 +35,7 @@ enum mie_walk_item_type {
struct mie_walk_item { struct mie_walk_item {
int _f; int _f;
b_queue_entry _e; fx_queue_entry _e;
enum mie_walk_item_type i_type; enum mie_walk_item_type i_type;
// size_t i_index; // size_t i_index;
size_t i_depth; size_t i_depth;
@@ -50,7 +50,7 @@ struct mie_walker {
enum mie_walker_flags w_flags; enum mie_walker_flags w_flags;
union { union {
/* used for recursive walks */ /* used for recursive walks */
b_queue w_stack; fx_queue w_stack;
/* used for non-recursive walks */ /* used for non-recursive walks */
struct { struct {
struct mie_walk_item w_region, w_block, w_op; struct mie_walk_item w_region, w_block, w_op;

12
mie/include/mie/name.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_NAME_H_ #ifndef MIE_NAME_H_
#define MIE_NAME_H_ #define MIE_NAME_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/parse/file-span.h> #include <mie/parse/file-span.h>
@@ -30,14 +30,14 @@ struct mie_name_map_entry {
enum mie_name_map_entry_type e_type; enum mie_name_map_entry_type e_type;
uint64_t e_hash; uint64_t e_hash;
union { union {
b_queue_entry e_entry; fx_queue_entry e_entry;
b_btree_node e_node; fx_bst_node e_node;
}; };
}; };
struct mie_name_bucket { struct mie_name_bucket {
struct mie_name_map_entry b_base; 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. /* stores a unique name, and forms a binary tree of similar entries.
@@ -64,7 +64,7 @@ struct mie_name {
struct mie_name_map { struct mie_name_map {
const struct mie_name_map *m_parent; const struct mie_name_map *m_parent;
b_btree m_entries; fx_bst m_entries;
size_t m_next_id; size_t m_next_id;
}; };

4
mie/include/mie/parse/lex.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_PARSE_LEX_H_ #ifndef MIE_PARSE_LEX_H_
#define MIE_PARSE_LEX_H_ #define MIE_PARSE_LEX_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>

22
mie/include/mie/parse/line-source.h
View File

@@ -1,34 +1,34 @@
#ifndef MIE_PARSE_LINE_SOURCE_H_ #ifndef MIE_PARSE_LINE_SOURCE_H_
#define MIE_PARSE_LINE_SOURCE_H_ #define MIE_PARSE_LINE_SOURCE_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <blue/ds/array.h> #include <fx/ds/array.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/parse/file-span.h> #include <mie/parse/file-span.h>
#include <mie/status.h> #include <mie/status.h>
struct mie_line_source { struct mie_line_source {
b_stream *s_stream; fx_stream *s_stream;
const char *s_path; const char *s_path;
b_string *s_linebuf; fx_string *s_linebuf;
b_iterator *s_linebuf_ptr; fx_iterator *s_linebuf_ptr;
b_array *s_lines; fx_array *s_lines;
struct mie_file_cell s_cursor; struct mie_file_cell s_cursor;
}; };
MIE_API enum mie_status mie_line_source_init( 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 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 char *mie_line_source_get_path(const struct mie_line_source *src);
MIE_API const struct mie_file_cell *mie_line_source_get_cursor( MIE_API const struct mie_file_cell *mie_line_source_get_cursor(
const struct mie_line_source *src); const struct mie_line_source *src);
MIE_API b_wchar mie_line_source_peekc(struct mie_line_source *src); MIE_API fx_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_getc(struct mie_line_source *src);
MIE_API enum mie_status mie_line_source_get_row( 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); MIE_API bool mie_line_source_input_available(struct mie_line_source *src);

30
mie/include/mie/parse/parser.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_PARSE_PARSER_H_ #ifndef MIE_PARSE_PARSER_H_
#define MIE_PARSE_PARSER_H_ #define MIE_PARSE_PARSER_H_
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/ir/register.h> #include <mie/ir/register.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/parse/token.h> #include <mie/parse/token.h>
@@ -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 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 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 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 struct mie_token *mie_parser_peek(struct mie_parser *ctx);
MIE_API enum mie_token_type mie_parser_peek_type(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( MIE_API bool mie_parser_parse_float(
struct mie_parser *ctx, double *out, struct mie_file_span *loc); struct mie_parser *ctx, double *out, struct mie_file_span *loc);
MIE_API bool mie_parser_parse_word( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( 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( MIE_API bool mie_parser_parse_keyword(
struct mie_parser *ctx, const char *kw, struct mie_file_span *loc); struct mie_parser *ctx, const char *kw, struct mie_file_span *loc);
MIE_API bool mie_parser_parse_symbol( 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, struct mie_parser *ctx, bool include_type,
MIE_VECTOR_REF_PARAM(struct mie_op_arg, out), const char *context); 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( MIE_API bool mie_parser_parse_unknown_symbol(
struct mie_parser *ctx, enum mie_token_symbol sym); struct mie_parser *ctx, enum mie_token_symbol sym);

4
mie/include/mie/parse/token.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_PARSE_TOKEN_H_ #ifndef MIE_PARSE_TOKEN_H_
#define MIE_PARSE_TOKEN_H_ #define MIE_PARSE_TOKEN_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/parse/file-span.h> #include <mie/parse/file-span.h>
@@ -82,7 +82,7 @@ struct mie_token {
struct mie_file_span tok_location; struct mie_file_span tok_location;
enum mie_token_type tok_type; enum mie_token_type tok_type;
enum mie_token_value_type tok_value_type; enum mie_token_value_type tok_value_type;
b_queue_entry tok_entry; fx_queue_entry tok_entry;
union { union {
char *tok_str; char *tok_str;

6
mie/include/mie/print/printer.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_PRINT_PRINTER_H_ #ifndef MIE_PRINT_PRINTER_H_
#define MIE_PRINT_PRINTER_H_ #define MIE_PRINT_PRINTER_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>
@@ -30,11 +30,11 @@ enum mie_print_flags {
struct mie_printer { struct mie_printer {
enum mie_print_flags p_flags; enum mie_print_flags p_flags;
struct mie_ctx *p_mie; struct mie_ctx *p_mie;
b_stream *p_stream; fx_stream *p_stream;
}; };
MIE_API enum mie_status mie_printer_init( 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); enum mie_print_flags flags);
MIE_API void mie_printer_print_module( MIE_API void mie_printer_print_module(

4
mie/include/mie/status.h
View File

@@ -5,7 +5,7 @@
#define MIE_ERROR_VENDOR (ivy_error_vendor()) #define MIE_ERROR_VENDOR (ivy_error_vendor())
struct b_error_vendor; struct fx_error_vendor;
enum mie_status { enum mie_status {
MIE_SUCCESS = 0, MIE_SUCCESS = 0,
@@ -23,6 +23,6 @@ enum mie_status {
MIE_ERR_INTERNAL_FAILURE, 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 #endif

4
mie/include/mie/trait/trait-definition.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_TRAIT_TRAIT_DEFINITION_H_ #ifndef MIE_TRAIT_TRAIT_DEFINITION_H_
#define MIE_TRAIT_TRAIT_DEFINITION_H_ #define MIE_TRAIT_TRAIT_DEFINITION_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/id.h> #include <mie/id.h>
#include <mie/status.h> #include <mie/status.h>
@@ -50,7 +50,7 @@ struct mie_trait_definition {
struct mie_id_builder *); struct mie_id_builder *);
enum mie_status (*tr_print)( enum mie_status (*tr_print)(
const struct mie_trait_definition *, const struct mie_trait *, const struct mie_trait_definition *, const struct mie_trait *,
b_stream *); fx_stream *);
enum mie_status (*tr_cleanup)( enum mie_status (*tr_cleanup)(
const struct mie_trait_definition *, struct mie_trait *); const struct mie_trait_definition *, struct mie_trait *);
enum mie_status (*tr_validate)( enum mie_status (*tr_validate)(

4
mie/include/mie/trait/trait-table.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_TRAIT_TRAIT_TABLE_H_ #ifndef MIE_TRAIT_TRAIT_TABLE_H_
#define MIE_TRAIT_TRAIT_TABLE_H_ #define MIE_TRAIT_TRAIT_TABLE_H_
#include <blue/core/btree.h> #include <fx/core/bst.h>
#include <mie/id.h> #include <mie/id.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <mie/status.h> #include <mie/status.h>
@@ -18,7 +18,7 @@ struct mie_trait_table_iterator {
int _f; int _f;
struct mie_id_map_iterator _n; struct mie_id_map_iterator _n;
const struct mie_trait_table *_m; 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); MIE_API void mie_trait_table_init(struct mie_trait_table *out);

2
mie/include/mie/trait/trait.h
View File

@@ -15,6 +15,6 @@ struct mie_trait {
const struct mie_trait_definition *tr_def; 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 #endif

2
mie/include/mie/type/function.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_TYPE_FUNCTION_H_ #ifndef MIE_TYPE_FUNCTION_H_
#define MIE_TYPE_FUNCTION_H_ #define MIE_TYPE_FUNCTION_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/vector.h> #include <mie/vector.h>

2
mie/include/mie/type/storage.h
View File

@@ -1,7 +1,7 @@
#ifndef MIE_TYPE_STORAGE_H_ #ifndef MIE_TYPE_STORAGE_H_
#define MIE_TYPE_STORAGE_H_ #define MIE_TYPE_STORAGE_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <mie/type/type.h> #include <mie/type/type.h>
#include <mie/vector.h> #include <mie/vector.h>

4
mie/include/mie/type/type.h
View File

@@ -1,8 +1,8 @@
#ifndef MIE_TYPE_TYPE_H_ #ifndef MIE_TYPE_TYPE_H_
#define MIE_TYPE_TYPE_H_ #define MIE_TYPE_TYPE_H_
#include <blue/core/stream.h> #include <fx/core/stream.h>
#include <blue/core/stringstream.h> #include <fx/core/stringstream.h>
#include <mie/id.h> #include <mie/id.h>
#include <mie/misc.h> #include <mie/misc.h>
#include <stddef.h> #include <stddef.h>

6
mie/interface/interface-definition.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/interface/interface-definition.h> #include <mie/interface/interface-definition.h>
@@ -12,7 +12,7 @@ struct mie_interface_definition *mie_interface_definition_create(
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->if_name = b_strdup(name); out->if_name = fx_strdup(name);
if (!out->if_name) { if (!out->if_name) {
free(out); free(out);
return NULL; return NULL;
@@ -21,7 +21,7 @@ struct mie_interface_definition *mie_interface_definition_create(
out->if_parent = parent; out->if_parent = parent;
out->if_size = 0; 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); mie_id_map_put(&parent->d_interfaces, &out->if_id, &name_rope);
return out; return out;

2
mie/interface/interface-map.c
View File

@@ -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 mie_id *result = mie_id_map_get(&map->m_entries, &id);
const struct mie_interface *iface 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; return iface;
} }

32
mie/ir/block.c
View File

@@ -4,12 +4,12 @@
struct mie_op *mie_block_get_first_op(const struct mie_block *block) 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) { if (!entry) {
return NULL; 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( struct mie_op *mie_block_get_prev_op(
@@ -19,12 +19,12 @@ struct mie_op *mie_block_get_prev_op(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_prev(&before->op_entry); fx_queue_entry *entry = fx_queue_prev(&before->op_entry);
if (!entry) { if (!entry) {
return NULL; 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( struct mie_op *mie_block_get_next_op(
@@ -34,28 +34,28 @@ struct mie_op *mie_block_get_next_op(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_next(&after->op_entry); fx_queue_entry *entry = fx_queue_next(&after->op_entry);
if (!entry) { if (!entry) {
return NULL; 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) 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) { if (!entry) {
return NULL; 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) struct mie_op *mie_block_get_terminator(const struct mie_block *block)
{ {
b_queue_entry *op_entry = b_queue_last(&block->b_ops); fx_queue_entry *op_entry = fx_queue_last(&block->b_ops);
return b_unbox(struct mie_op, op_entry, op_entry); return fx_unbox(struct mie_op, op_entry, op_entry);
} }
struct mie_op_successor *mie_block_get_first_successor(const struct mie_block *block) 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); mie_op_init(op);
op->op_container = block; 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; 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; op->op_container = block;
if (after) { 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 { } else {
b_queue_push_back(&block->b_ops, &op->op_entry); fx_queue_push_back(&block->b_ops, &op->op_entry);
} }
return op; return op;
@@ -243,7 +243,7 @@ struct mie_register *mie_block_find_register(
const struct mie_block *block, const char *name, const struct mie_block *block, const char *name,
const struct mie_op *start_point) 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) { if (start_point) {
entry = &start_point->op_entry; entry = &start_point->op_entry;
} }
@@ -255,13 +255,13 @@ struct mie_register *mie_block_find_register(
} }
while (entry) { 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); struct mie_register *reg = mie_op_get_result_with_name(op, name);
if (reg) { if (reg) {
return reg; return reg;
} }
entry = b_queue_prev(entry); entry = fx_queue_prev(entry);
} }
return NULL; return NULL;

24
mie/ir/builder.c
View File

@@ -7,7 +7,7 @@
#include <mie/ir/region.h> #include <mie/ir/region.h>
struct builder_scope { struct builder_scope {
b_queue_entry s_entry; fx_queue_entry s_entry;
struct mie_op *s_op; struct mie_op *s_op;
struct mie_region *s_region; struct mie_region *s_region;
struct mie_block *s_block; struct mie_block *s_block;
@@ -16,7 +16,7 @@ struct builder_scope {
struct mie_builder { struct mie_builder {
struct mie_emitter b_base; struct mie_emitter b_base;
struct mie_ctx *b_ctx; struct mie_ctx *b_ctx;
b_queue b_scope_stack; fx_queue b_scope_stack;
struct mie_op *b_root; struct mie_op *b_root;
struct mie_op *b_prev_op; 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) 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) { while (cur) {
struct builder_scope *scope 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) { if (scope->s_region && scope->s_region->r_names) {
return scope->s_region->r_names; return scope->s_region->r_names;
} }
cur = b_queue_prev(cur); cur = fx_queue_prev(cur);
} }
return NULL; 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) 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) { if (!entry) {
return NULL; return NULL;
} }
struct builder_scope *scope struct builder_scope *scope
= b_unbox(struct builder_scope, entry, s_entry); = fx_unbox(struct builder_scope, entry, s_entry);
return scope->s_block; 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_region = block->b_parent;
scope->s_op = scope->s_region->r_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) 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) { if (!entry) {
return; return;
} }
struct builder_scope *scope struct builder_scope *scope
= b_unbox(struct builder_scope, entry, s_entry); = fx_unbox(struct builder_scope, entry, s_entry);
b_queue_delete(&builder->b_scope_stack, entry); fx_queue_delete(&builder->b_scope_stack, entry);
free(scope); free(scope);
} }
@@ -151,7 +151,7 @@ struct mie_op *mie_builder_put_op(
arg->arg_flags = MIE_OP_F_ARG_RESOLVED; arg->arg_flags = MIE_OP_F_ARG_RESOLVED;
arg->arg_value.u_reg = args[i]; arg->arg_value.u_reg = args[i];
arg->arg_value.u_user = op; 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; return op;

6
mie/ir/op-definition.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/ir/op-definition.h> #include <mie/ir/op-definition.h>
@@ -10,7 +10,7 @@ struct mie_op_definition *mie_op_definition_create(
return NULL; return NULL;
} }
out->op_name = b_strdup(name); out->op_name = fx_strdup(name);
if (!out->op_name) { if (!out->op_name) {
free(out); free(out);
return NULL; return NULL;
@@ -20,7 +20,7 @@ struct mie_op_definition *mie_op_definition_create(
mie_trait_table_init(&out->op_traits); mie_trait_table_init(&out->op_traits);
mie_interface_map_init(&out->op_iface); 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); mie_id_map_put(&parent->d_ops, &out->op_id, &name_rope);
return out; return out;

22
mie/ir/op.c
View File

@@ -15,7 +15,7 @@ static enum mie_status op_arg_cleanup(void *p)
struct mie_op_arg *arg = p; struct mie_op_arg *arg = p;
if (arg->arg_flags & MIE_OP_F_ARG_RESOLVED) { 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); &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_flags = MIE_OP_F_ARG_RESOLVED;
arg->arg_value.u_reg = args[i]; arg->arg_value.u_reg = args[i];
arg->arg_value.u_user = op; 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; 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); region->r_names = mie_name_map_create(NULL);
} }
b_queue_push_back(&op->op_regions, &region->r_entry); fx_queue_push_back(&op->op_regions, &region->r_entry);
return region; return region;
} }
@@ -202,12 +202,12 @@ bool mie_op_has_interface(
struct mie_region *mie_op_get_first_region(const struct mie_op *op) 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) { if (!entry) {
return NULL; 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( struct mie_region *mie_op_get_prev_region(
@@ -217,12 +217,12 @@ struct mie_region *mie_op_get_prev_region(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_prev(&before->r_entry); fx_queue_entry *entry = fx_queue_prev(&before->r_entry);
if (!entry) { if (!entry) {
return NULL; 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( struct mie_region *mie_op_get_next_region(
@@ -232,22 +232,22 @@ struct mie_region *mie_op_get_next_region(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_next(&after->r_entry); fx_queue_entry *entry = fx_queue_next(&after->r_entry);
if (!entry) { if (!entry) {
return NULL; 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) 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) { if (!entry) {
return NULL; 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) struct mie_register *mie_op_get_arg(const struct mie_op *op, size_t index)

34
mie/ir/region.c
View File

@@ -10,12 +10,12 @@
struct mie_block *mie_region_get_first_block(const struct mie_region *region) struct mie_block *mie_region_get_first_block(const struct mie_region *region)
{ {
b_queue_entry *entry = b_queue_first(&region->r_blocks); fx_queue_entry *entry = fx_queue_first(&region->r_blocks);
if (!entry) { if (!entry) {
return NULL; 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( struct mie_block *mie_region_get_prev_block(
@@ -25,12 +25,12 @@ struct mie_block *mie_region_get_prev_block(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_prev(&before->b_entry); fx_queue_entry *entry = fx_queue_prev(&before->b_entry);
if (!entry) { if (!entry) {
return NULL; 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( struct mie_block *mie_region_get_next_block(
@@ -40,22 +40,22 @@ struct mie_block *mie_region_get_next_block(
return NULL; return NULL;
} }
b_queue_entry *entry = b_queue_next(&after->b_entry); fx_queue_entry *entry = fx_queue_next(&after->b_entry);
if (!entry) { if (!entry) {
return NULL; 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) struct mie_block *mie_region_get_last_block(const struct mie_region *region)
{ {
b_queue_entry *entry = b_queue_last(&region->r_blocks); fx_queue_entry *entry = fx_queue_last(&region->r_blocks);
if (!entry) { if (!entry) {
return NULL; 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) 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_parent = region;
block->b_id = MIE_BLOCK_ID_INVALID; block->b_id = MIE_BLOCK_ID_INVALID;
b_queue_push_back(&region->r_blocks, &block->b_entry); fx_queue_push_back(&region->r_blocks, &block->b_entry);
return block; return block;
} }
@@ -91,7 +91,7 @@ struct mie_block *mie_region_add_block_before(
memset(block, 0x0, sizeof *block); memset(block, 0x0, sizeof *block);
block->b_parent = region; block->b_parent = region;
b_queue_insert_before(&region->r_blocks, &block->b_entry, &before->b_entry); fx_queue_insert_before(&region->r_blocks, &block->b_entry, &before->b_entry);
return block; return block;
} }
@@ -112,7 +112,7 @@ struct mie_block *mie_region_add_block_after(
memset(block, 0x0, sizeof *block); memset(block, 0x0, sizeof *block);
block->b_parent = region; block->b_parent = region;
b_queue_insert_after(&region->r_blocks, &block->b_entry, &after->b_entry); fx_queue_insert_after(&region->r_blocks, &block->b_entry, &after->b_entry);
return block; return block;
} }
@@ -120,15 +120,15 @@ struct mie_block *mie_region_add_block_after(
struct mie_block *mie_region_find_block( struct mie_block *mie_region_find_block(
const struct mie_region *region, const char *name) const struct mie_region *region, const char *name)
{ {
b_queue_entry *cur = b_queue_first(&region->r_blocks); fx_queue_entry *cur = fx_queue_first(&region->r_blocks);
while (cur) { 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; const char *block_name = block->b_name.n_str;
if (block_name && !strcmp(block_name, name)) { if (block_name && !strcmp(block_name, name)) {
return block; return block;
} }
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
return NULL; return NULL;
@@ -137,17 +137,17 @@ struct mie_block *mie_region_find_block(
struct mie_register *mie_region_find_register( struct mie_register *mie_region_find_register(
const struct mie_region *region, const char *name) const struct mie_region *region, const char *name)
{ {
b_queue_entry *cur = b_queue_first(&region->r_blocks); fx_queue_entry *cur = fx_queue_first(&region->r_blocks);
while (cur) { 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 struct mie_register *reg
= mie_block_find_register(block, name, NULL); = mie_block_find_register(block, name, NULL);
if (reg) { if (reg) {
return reg; return reg;
} }
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
return NULL; return NULL;

6
mie/ir/register.c
View File

@@ -1,5 +1,5 @@
#include <assert.h> #include <assert.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/ir/register.h> #include <mie/ir/register.h>
static enum mie_status reg_cleanup(void *p) static enum mie_status reg_cleanup(void *p)
@@ -57,13 +57,13 @@ void mie_register_use_move(
memmove(dest, src, sizeof *dest); memmove(dest, src, sizeof *dest);
if (src->u_reg) { 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) void mie_register_use_cleanup(struct mie_register_use *use)
{ {
if (use->u_reg) { 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);
} }
} }

4
mie/ir/resolve.c
View File

@@ -120,7 +120,7 @@ static bool resolve_arg(
memset(&arg->arg_value, 0x0, sizeof arg->arg_value); memset(&arg->arg_value, 0x0, sizeof arg->arg_value);
arg->arg_value.u_reg = reg; arg->arg_value.u_reg = reg;
arg->arg_value.u_user = op; arg->arg_value.u_user = op;
b_queue_push_back(&reg->reg_use, &arg->arg_value.u_entry); fx_queue_push_back(&reg->reg_use, &arg->arg_value.u_entry);
return true; return true;
} }
@@ -135,7 +135,7 @@ static bool resolve_arg(
memset(&arg->arg_value, 0x0, sizeof arg->arg_value); memset(&arg->arg_value, 0x0, sizeof arg->arg_value);
arg->arg_value.u_reg = reg; arg->arg_value.u_reg = reg;
arg->arg_value.u_user = op; arg->arg_value.u_user = op;
b_queue_push_back(&reg->reg_use, &arg->arg_value.u_entry); fx_queue_push_back(&reg->reg_use, &arg->arg_value.u_entry);
return true; return true;
} }

22
mie/ir/walk.c
View File

@@ -35,15 +35,15 @@ static void push_walk_item(
} }
memcpy(i, item, sizeof *i); 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) 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) { if (entry) {
struct mie_walk_item *item struct mie_walk_item *item
= b_unbox(struct mie_walk_item, entry, _e); = fx_unbox(struct mie_walk_item, entry, _e);
free(item); free(item);
} }
} }
@@ -65,12 +65,12 @@ static struct mie_walk_item *current_item(struct mie_walker *walker)
return eof ? item : NULL; 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) { if (!entry) {
return NULL; 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; 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) struct mie_walk_item *child)
{ {
bool ok = false; bool ok = false;
b_queue_entry *entry = NULL; fx_queue_entry *entry = NULL;
switch (item->i_type) { switch (item->i_type) {
case MIE_WALK_ITEM_OP: case MIE_WALK_ITEM_OP:
@@ -184,7 +184,7 @@ static bool walk_item_get_last_child(
struct mie_walk_item *child) struct mie_walk_item *child)
{ {
bool ok = false; bool ok = false;
b_queue_entry *entry = NULL; fx_queue_entry *entry = NULL;
switch (item->i_type) { switch (item->i_type) {
case MIE_WALK_ITEM_OP: case MIE_WALK_ITEM_OP:
@@ -230,7 +230,7 @@ static bool walk_item_get_next_sibling(
sibling->i_type = item->i_type; sibling->i_type = item->i_type;
size_t index = 0; size_t index = 0;
b_queue_entry *entry = NULL; fx_queue_entry *entry = NULL;
struct mie_region *parent_r = NULL; struct mie_region *parent_r = NULL;
struct mie_block *parent_b = NULL; struct mie_block *parent_b = NULL;
struct mie_op *parent_o = 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) 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) { while (entry) {
struct mie_walk_item *item 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) { switch (item->i_type) {
case MIE_WALK_ITEM_OP: case MIE_WALK_ITEM_OP:
@@ -347,7 +347,7 @@ static void print_stack(struct mie_walker *walker)
printf("\n"); printf("\n");
entry = b_queue_prev(entry); entry = fx_queue_prev(entry);
} }
} }

14
mie/lt-idom.c
View File

@@ -26,9 +26,9 @@ struct lt_ctx {
}; };
#if 0 #if 0
static B_BTREE_DEFINE_SIMPLE_INSERT(struct mie_block, b_node, b_id, put_block_by_id); static FX_BST_DEFINE_SIMPLE_INSERT(struct mie_block, fx_node, b_id, put_block_by_id);
static B_BTREE_DEFINE_SIMPLE_GET( static FX_BST_DEFINE_SIMPLE_GET(
struct mie_block, size_t, b_node, b_id, get_block_by_id); struct mie_block, size_t, fx_node, b_id, get_block_by_id);
#endif #endif
static void set_add(struct set *set, unsigned int val) 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) static void reset_block_relationship_metadata(struct mie_region *region)
{ {
b_queue_entry *cur = b_queue_first(&region->r_blocks); fx_queue_entry *cur = fx_queue_first(&region->r_blocks);
while (cur) { 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_id = MIE_BLOCK_ID_INVALID;
block->b_idom = NULL; block->b_idom = NULL;
// block->b_sdom = block->b_dfs_parent = NULL; // block->b_sdom = block->b_dfs_parent = NULL;
mie_vector_destroy(block->b_ipred, NULL); mie_vector_destroy(block->b_ipred, NULL);
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
memset(&region->r_blocks_s, 0x0, sizeof region->r_blocks_s); memset(&region->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) void mie_region_refresh_dominance(struct mie_region *region)
{ {
struct lt_ctx ctx; struct lt_ctx ctx;
size_t nr_nodes = b_queue_length(&region->r_blocks); size_t nr_nodes = fx_queue_length(&region->r_blocks);
lt_ctx_init(&ctx, nr_nodes); lt_ctx_init(&ctx, nr_nodes);
struct mie_block *root = mie_region_get_first_block(region); struct mie_block *root = mie_region_get_first_block(region);

110
mie/name.c
View File

@@ -1,12 +1,12 @@
#include <blue/core/rope.h> #include <fx/core/rope.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/name.h> #include <mie/name.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static B_BTREE_DEFINE_SIMPLE_INSERT( static FX_BST_DEFINE_SIMPLE_INSERT(
struct mie_name_map_entry, e_node, e_hash, put_entry); 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); struct mie_name_map_entry, uint64_t, e_node, e_hash, get_entry);
static struct mie_name_bucket *create_bucket(void) 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) 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) { while (entry) {
b_queue_entry *next = b_queue_next(entry); fx_queue_entry *next = fx_queue_next(entry);
b_queue_delete(&bucket->b_names, entry); fx_queue_delete(&bucket->b_names, entry);
entry = next; 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) 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) { while (node) {
struct mie_name_map_entry *entry struct mie_name_map_entry *entry
= b_unbox(struct mie_name_map_entry, node, e_node); = fx_unbox(struct mie_name_map_entry, node, e_node);
b_btree_node *next = b_btree_next(node); fx_bst_node *next = fx_bst_next(node);
b_btree_delete(&map->m_entries, node); fx_bst_delete(&map->m_entries, node);
if (entry->e_type == MIE_NAME_MAP_E_BUCKET) { if (entry->e_type == MIE_NAME_MAP_E_BUCKET) {
struct mie_name_bucket *bucket struct mie_name_bucket *bucket
= (struct mie_name_bucket *)entry; = (struct mie_name_bucket *)entry;
@@ -71,36 +71,36 @@ void mie_name_map_destroy(struct mie_name_map *map)
free(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) 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) { 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); struct mie_name_map_entry, entry, e_entry);
if (!strcmp(cur->n_str, name->n_str)) { 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; 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 struct mie_name_map_entry *entry
= get_entry(&map->m_entries, name->n_base.e_hash); = get_entry(&map->m_entries, name->n_base.e_hash);
if (!entry) { if (!entry) {
put_entry(&map->m_entries, &name->n_base); put_entry(&map->m_entries, &name->n_base);
return B_SUCCESS; return FX_SUCCESS;
} }
if (entry->e_type == MIE_NAME_MAP_E_BUCKET) { 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; struct mie_name *existing_name = (struct mie_name *)entry;
if (!strcmp(existing_name->n_str, name->n_str)) { 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(); struct mie_name_bucket *bucket = create_bucket();
if (!bucket) { if (!bucket) {
return B_ERR_NO_MEMORY; return FX_ERR_NO_MEMORY;
} }
b_btree_delete(&map->m_entries, &entry->e_node); fx_bst_delete(&map->m_entries, &entry->e_node);
entry->e_entry = B_QUEUE_ENTRY_INIT; entry->e_entry = FX_QUEUE_ENTRY_INIT;
bucket->b_base.e_hash = name->n_base.e_hash; bucket->b_base.e_hash = name->n_base.e_hash;
b_queue_push_back(&bucket->b_names, &existing_name->n_base.e_entry); fx_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, &name->n_base.e_entry);
existing_name->n_bucket = name->n_bucket = bucket; existing_name->n_bucket = name->n_bucket = bucket;
put_entry(&map->m_entries, &bucket->b_base); 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) 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( static const struct mie_name *find_name_in_bucket(
const struct mie_name_bucket *bucket, const char *s, uint64_t hash) 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) { while (entry) {
struct mie_name_map_entry *map_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; struct mie_name *name = (struct mie_name *)map_entry;
if (check_name(name, s, hash)) { if (check_name(name, s, hash)) {
return name; return name;
} }
entry = b_queue_next(entry); entry = fx_queue_next(entry);
} }
return NULL; return NULL;
@@ -194,7 +194,7 @@ const struct mie_name *mie_name_map_get(
const struct mie_name_map *map, const char *name, const struct mie_name_map *map, const char *name,
enum mie_name_map_flags flags) enum mie_name_map_flags flags)
{ {
uint64_t name_hash = b_hash_cstr(name); uint64_t name_hash = fx_hash_cstr(name);
while (map) { while (map) {
const struct mie_name *result = name_map_get(map, name, name_hash); const struct mie_name *result = name_map_get(map, name, name_hash);
if (result) { if (result) {
@@ -214,24 +214,24 @@ struct mie_name *mie_name_map_put(
memset(entry, 0x0, sizeof *entry); memset(entry, 0x0, sizeof *entry);
entry->n_base.e_type = MIE_NAME_MAP_E_NAME; entry->n_base.e_type = MIE_NAME_MAP_E_NAME;
b_rope base = {}; fx_rope base = {};
if (hint) { if (hint) {
b_rope_init_cstr_borrowed(&base, hint); fx_rope_init_cstr_borrowed(&base, hint);
} }
char str[256]; char str[256];
if (hint) { if (hint) {
/* first try just the hint on its own */ /* 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_str = str;
entry->n_base.e_hash = base.r_v.v_cstr.hash; 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_parent = map;
entry->n_str = b_strdup(str); entry->n_str = fx_strdup(str);
return entry; 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. /* 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 */ * alternately, no hint was specified, so it's up to us to generate the name */
b_rope dot = B_ROPE_CHAR('.'); fx_rope dot = FX_ROPE_CHAR('.');
b_rope suffix = B_ROPE_UINT(0); fx_rope suffix = FX_ROPE_UINT(0);
b_rope unique_name; fx_rope unique_name;
if (hint) { if (hint) {
const b_rope *parts[] = {&base, &dot, &suffix}; const fx_rope *parts[] = {&base, &dot, &suffix};
b_rope_join(&unique_name, parts, sizeof parts / sizeof parts[0]); fx_rope_join(&unique_name, parts, sizeof parts / sizeof parts[0]);
} else { } else {
b_rope_concat(&unique_name, &base, &suffix); fx_rope_concat(&unique_name, &base, &suffix);
} }
size_t i = 0; size_t i = 0;
@@ -263,21 +263,21 @@ struct mie_name *mie_name_map_put(
for (;; i++) { for (;; i++) {
suffix.r_v.v_uint = 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_str = str;
entry->n_base.e_hash = b_hash_cstr(str); entry->n_base.e_hash = fx_hash_cstr(str);
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_parent = map;
entry->n_str = b_strdup(str); entry->n_str = fx_strdup(str);
b_rope_destroy(&unique_name); fx_rope_destroy(&unique_name);
return entry; return entry;
} }
} }
b_rope_destroy(&unique_name); fx_rope_destroy(&unique_name);
return NULL; return NULL;
} }
@@ -292,11 +292,11 @@ void mie_name_move(struct mie_name *dst, struct mie_name *src)
memmove(dst, src, sizeof *src); memmove(dst, src, sizeof *src);
if (src->n_bucket) { if (src->n_bucket) {
b_queue_move( fx_queue_move(
&src->n_bucket->b_names, &dst->n_base.e_entry, &src->n_bucket->b_names, &dst->n_base.e_entry,
&src->n_base.e_entry); &src->n_base.e_entry);
} else { } else {
b_btree_move( fx_bst_move(
&src->n_parent->m_entries, &dst->n_base.e_node, &src->n_parent->m_entries, &dst->n_base.e_node,
&src->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) { switch (entry->e_type) {
case MIE_NAME_MAP_E_NAME: 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; break;
case MIE_NAME_MAP_E_BUCKET: case MIE_NAME_MAP_E_BUCKET:
bucket = b_unbox(struct mie_name_bucket, entry, b_base); bucket = fx_unbox(struct mie_name_bucket, entry, b_base);
b_queue_delete(&bucket->b_names, &name->n_base.e_entry); fx_queue_delete(&bucket->b_names, &name->n_base.e_entry);
break; break;
default: default:
abort(); abort();

122
mie/parse/lex.c
View File

@@ -1,11 +1,11 @@
#include "lex.h" #include "lex.h"
#include <blue/core/hash.h> #include <fx/core/hash.h>
#include <blue/core/misc.h> #include <fx/core/misc.h>
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <blue/ds/dict.h> #include <fx/ds/dict.h>
#include <blue/ds/number.h> #include <fx/ds/number.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <ctype.h> #include <ctype.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/diag/diag.h> #include <mie/diag/diag.h>
@@ -22,10 +22,10 @@
#define LEX_TOKEN_DEF(i, n) {.id = (i), .name = (n)} #define LEX_TOKEN_DEF(i, n) {.id = (i), .name = (n)}
#define IS_VALID_IDENT_CHAR(c) \ #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) \ #define IS_VALID_IDENT_START_CHAR(c) \
(b_wchar_is_alpha(c) || c == '.' || c == '_') (fx_wchar_is_alpha(c) || c == '.' || c == '_')
#define IS_VALID_REG_START_CHAR(c) (b_wchar_is_alnum(c) || c == '.' || c == '_') #define IS_VALID_REG_START_CHAR(c) (fx_wchar_is_alnum(c) || c == '.' || c == '_')
static struct lex_token_def symbols[] = { static struct lex_token_def symbols[] = {
LEX_TOKEN_DEF(MIE_SYM_COLON, ":"), 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( static struct mie_lex_symbol_node *get_symbol_node(
struct mie_lex_symbol_node *node, char c) 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) { while (entry) {
struct mie_lex_symbol_node *child 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) { if (child->s_char == c) {
return child; return child;
} }
entry = b_queue_next(entry); entry = fx_queue_next(entry);
} }
return NULL; return NULL;
@@ -79,13 +79,13 @@ static struct mie_diag *push_diag(struct mie_lex *lex, unsigned long diag_class)
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) { 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; return lex->lex_temp;
} }
@@ -110,7 +110,7 @@ static enum mie_status put_symbol(
child->s_def = NULL; child->s_def = NULL;
child->s_char = c; 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; tree = child;
} }
@@ -120,12 +120,12 @@ static enum mie_status put_symbol(
static void destroy_symbol_tree(struct mie_lex_symbol_node *tree) 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) { while (entry) {
struct mie_lex_symbol_node *node struct mie_lex_symbol_node *node
= b_unbox(struct mie_lex_symbol_node, entry, s_entry); = fx_unbox(struct mie_lex_symbol_node, entry, s_entry);
b_queue_entry *next = b_queue_next(entry); fx_queue_entry *next = fx_queue_next(entry);
b_queue_delete(&tree->s_children, entry); fx_queue_delete(&tree->s_children, entry);
destroy_symbol_tree(node); 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) 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) { while (entry) {
struct mie_token *tok struct mie_token *tok
= b_unbox(struct mie_token, entry, tok_entry); = fx_unbox(struct mie_token, entry, tok_entry);
b_queue_entry *next = b_queue_next(entry); fx_queue_entry *next = fx_queue_next(entry);
b_queue_delete(&lex->lex_queue, entry); fx_queue_delete(&lex->lex_queue, entry);
mie_token_destroy(tok); mie_token_destroy(tok);
@@ -201,7 +201,7 @@ void mie_lex_destroy(struct mie_lex *lex)
} }
if (lex->lex_temp) { if (lex->lex_temp) {
b_string_unref(lex->lex_temp); fx_string_unref(lex->lex_temp);
} }
free(lex); 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_start = lex->lex_token_start;
tok->tok_location.s_end = lex->lex_token_end; 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; 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) static enum mie_status read_line_comment(struct mie_lex *lex)
{ {
while (true) { 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') { if (c == -MIE_ERR_EOF || c == '\n') {
break; break;
@@ -373,14 +373,14 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate)
int token_len = 0; int token_len = 0;
int base = 10; int base = 10;
int dots = 0; int dots = 0;
b_string *str = get_temp_string(lex); fx_string *str = get_temp_string(lex);
if (!negate) { if (!negate) {
set_token_start(lex); set_token_start(lex);
} }
while (true) { 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) { if (c == -MIE_ERR_EOF) {
break; break;
} }
@@ -408,13 +408,13 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate)
token_len++; token_len++;
dots++; dots++;
char s[] = {c, 0}; char s[] = {c, 0};
b_string_append_cstr(str, s); fx_string_append_cstr(str, s);
set_token_end(lex); set_token_end(lex);
mie_line_source_getc(lex->lex_source); mie_line_source_getc(lex->lex_source);
continue; continue;
} }
if (b_wchar_is_space(c) || b_wchar_is_punct(c)) { if (fx_wchar_is_space(c) || fx_wchar_is_punct(c)) {
break; break;
} }
@@ -446,7 +446,7 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate)
return MIE_ERR_BAD_SYNTAX; return MIE_ERR_BAD_SYNTAX;
} }
b_string_append_wc(str, c); fx_string_append_wc(str, c);
set_token_end(lex); set_token_end(lex);
mie_line_source_getc(lex->lex_source); mie_line_source_getc(lex->lex_source);
token_len++; token_len++;
@@ -456,7 +456,7 @@ static enum mie_status read_number(struct mie_lex *lex, bool negate)
return push_int(lex, 0); return push_int(lex, 0);
} }
const char *s = b_string_ptr(str); const char *s = fx_string_ptr(str);
char *ep = NULL; char *ep = NULL;
/* negative numbers will be lexed as a hyphen followed by a positive /* 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) static enum mie_status read_ident(struct mie_lex *lex, enum mie_token_type type)
{ {
int dots = 0; int dots = 0;
b_string *str = get_temp_string(lex); fx_string *str = get_temp_string(lex);
b_wchar prev = 0; fx_wchar prev = 0;
if (type == MIE_TOK_NONE) { if (type == MIE_TOK_NONE) {
set_token_start(lex); set_token_start(lex);
} }
while (1) { 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) { if ((c == '.' || c == '-') && prev == c) {
return MIE_ERR_BAD_SYNTAX; 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; prev = c;
b_string_append_wc(str, c); fx_string_append_wc(str, c);
set_token_end(lex); set_token_end(lex);
mie_line_source_getc(lex->lex_source); 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; type = dots > 0 ? MIE_TOK_NAME : MIE_TOK_WORD;
} }
char *s = b_string_steal(str); char *s = fx_string_steal(str);
switch (type) { switch (type) {
case MIE_TOK_INSTNAME: 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) 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; bool esc = false;
if (c != '"') { if (c != '"') {
@@ -555,13 +555,13 @@ static enum mie_status read_string(struct mie_lex *lex)
mie_line_source_getc(lex->lex_source); mie_line_source_getc(lex->lex_source);
while (1) { while (1) {
b_wchar c = mie_line_source_peekc(lex->lex_source); fx_wchar c = mie_line_source_peekc(lex->lex_source);
if (esc) { if (esc) {
switch (c) { switch (c) {
case '\\': case '\\':
case '"': case '"':
b_string_append_wc(str, c); fx_string_append_wc(str, c);
break; break;
default: default:
return MIE_ERR_BAD_SYNTAX; return MIE_ERR_BAD_SYNTAX;
@@ -583,11 +583,11 @@ static enum mie_status read_string(struct mie_lex *lex)
break; break;
} }
b_string_append_wc(str, c); fx_string_append_wc(str, c);
mie_line_source_getc(lex->lex_source); 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); 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; struct mie_lex_symbol_node *node = lex->lex_sym_tree;
set_token_start(lex); set_token_start(lex);
b_wchar prev = 0; fx_wchar prev = 0;
while (true) { 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) { if (c < 0) {
break; break;
} }
@@ -667,17 +667,17 @@ static enum mie_status read_symbol(struct mie_lex *lex)
static void skip_whitespace(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); mie_line_source_getc(lex->lex_source);
c = mie_line_source_peekc(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) { if (!skip_linefeeds) {
skip = (skip && c != '\n'); 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) 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 (1) {
while (should_skip(c, include_linefeeds)) { 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) 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) { if (c < 0) {
return -c; return -c;
} }
while (1) { 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); skip_ignored_chars(lex, false);
} else { } else {
break; break;
@@ -758,7 +758,7 @@ static enum mie_status pump_tokens(struct mie_lex *lex)
return push_linefeed(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); mie_line_source_getc(lex->lex_source);
c = mie_line_source_peekc(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; enum mie_status status = MIE_SUCCESS;
while (b_queue_empty(&lex->lex_queue)) { while (fx_queue_empty(&lex->lex_queue)) {
status = pump_tokens(lex); status = pump_tokens(lex);
if (status != MIE_SUCCESS) { if (status != MIE_SUCCESS) {
@@ -811,8 +811,8 @@ struct mie_token *mie_lex_peek(struct mie_lex *lex)
lex->lex_status = status; lex->lex_status = status;
b_queue_entry *entry = b_queue_first(&lex->lex_queue); fx_queue_entry *entry = fx_queue_first(&lex->lex_queue);
struct mie_token *tok = b_unbox(struct mie_token, entry, tok_entry); struct mie_token *tok = fx_unbox(struct mie_token, entry, tok_entry);
return tok; return tok;
} }
@@ -820,7 +820,7 @@ void mie_lex_advance(struct mie_lex *lex)
{ {
enum mie_status status = MIE_SUCCESS; enum mie_status status = MIE_SUCCESS;
while (b_queue_empty(&lex->lex_queue)) { while (fx_queue_empty(&lex->lex_queue)) {
status = pump_tokens(lex); status = pump_tokens(lex);
if (status != MIE_SUCCESS) { 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); fx_queue_entry *entry = fx_queue_pop_front(&lex->lex_queue);
struct mie_token *tok = b_unbox(struct mie_token, entry, tok_entry); struct mie_token *tok = fx_unbox(struct mie_token, entry, tok_entry);
mie_token_destroy(tok); mie_token_destroy(tok);
} }
bool mie_lex_tokens_available(struct mie_lex *lex) 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; return true;
} }

16
mie/parse/lex.h
View File

@@ -1,9 +1,9 @@
#ifndef _PARSE_LEX_H_ #ifndef _PARSE_LEX_H_
#define _PARSE_LEX_H_ #define _PARSE_LEX_H_
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <blue/ds/dict.h> #include <fx/ds/dict.h>
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/parse/lex.h> #include <mie/parse/lex.h>
#include <mie/parse/line-source.h> #include <mie/parse/line-source.h>
#include <mie/parse/token.h> #include <mie/parse/token.h>
@@ -16,10 +16,10 @@ struct mie_lex {
enum mie_status lex_status; enum mie_status lex_status;
struct mie_ctx *lex_ctx; struct mie_ctx *lex_ctx;
b_queue lex_queue; fx_queue lex_queue;
b_string *lex_temp; fx_string *lex_temp;
b_queue lex_state; fx_queue lex_state;
unsigned int lex_brace_depth; unsigned int lex_brace_depth;
struct mie_file_cell lex_token_start, lex_token_end; struct mie_file_cell lex_token_start, lex_token_end;
@@ -29,8 +29,8 @@ struct mie_lex_symbol_node {
char s_char; char s_char;
struct lex_token_def *s_def; struct lex_token_def *s_def;
b_queue_entry s_entry; fx_queue_entry s_entry;
b_queue s_children; fx_queue s_children;
}; };
struct lex_token_def { struct lex_token_def {

56
mie/parse/line-source.c
View File

@@ -1,11 +1,11 @@
#include <mie/parse/line-source.h> #include <mie/parse/line-source.h>
enum mie_status mie_line_source_init( 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); memset(src, 0x0, sizeof *src);
src->s_lines = b_array_create(); src->s_lines = fx_array_create();
if (!src->s_lines) { if (!src->s_lines) {
return MIE_ERR_NO_MEMORY; 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) void mie_line_source_cleanup(struct mie_line_source *src)
{ {
if (src->s_linebuf_ptr) { if (src->s_linebuf_ptr) {
b_iterator_unref(src->s_linebuf_ptr); fx_iterator_unref(src->s_linebuf_ptr);
} }
if (src->s_lines) { if (src->s_lines) {
b_array_unref(src->s_lines); fx_array_unref(src->s_lines);
} }
memset(src, 0x0, sizeof *src); 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) { if (src->s_linebuf_ptr) {
b_iterator_unref(src->s_linebuf_ptr); fx_iterator_unref(src->s_linebuf_ptr);
src->s_linebuf_ptr = NULL; 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; return MIE_ERR_EOF;
} }
if (!B_OK(status)) { if (!FX_OK(status)) {
return MIE_ERR_INTERNAL_FAILURE; return MIE_ERR_INTERNAL_FAILURE;
} }
b_string *line = b_string_create(); fx_string *line = fx_string_create();
b_string_replace_all_with_stringstream(line, s); fx_string_replace_all_with_stringstream(line, s);
b_stringstream_unref(s); fx_stringstream_unref(s);
b_array_append(src->s_lines, line); fx_array_append(src->s_lines, line);
b_string_unref(line); fx_string_unref(line);
src->s_linebuf = 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; return MIE_SUCCESS;
} }
@@ -83,7 +83,7 @@ static int peek(struct mie_line_source *src)
{ {
enum mie_status status = MIE_SUCCESS; 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); status = refill_linebuf(src);
} }
@@ -91,11 +91,11 @@ static int peek(struct mie_line_source *src)
return -status; 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; 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; return c;
} }
@@ -103,7 +103,7 @@ static int advance(struct mie_line_source *src)
{ {
enum mie_status status = MIE_SUCCESS; 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); status = refill_linebuf(src);
} }
@@ -111,12 +111,12 @@ static int advance(struct mie_line_source *src)
return -status; 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; 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;
b_iterator_move_next(src->s_linebuf_ptr); fx_iterator_move_next(src->s_linebuf_ptr);
src->s_cursor.c_col++; src->s_cursor.c_col++;
if (c == '\n') { if (c == '\n') {
@@ -126,18 +126,18 @@ static int advance(struct mie_line_source *src)
return c; 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); 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); return advance(src);
} }
enum mie_status mie_line_source_get_row( 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) { if (row == 0) {
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
@@ -145,11 +145,11 @@ enum mie_status mie_line_source_get_row(
row--; row--;
if (row >= b_array_size(src->s_lines)) { if (row >= fx_array_size(src->s_lines)) {
return MIE_ERR_EOF; 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; *out = line;
return MIE_SUCCESS; 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) 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);
} }

158
mie/parse/parser.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/bstr.h> #include <fx/core/bstr.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/attribute/attribute-map.h> #include <mie/attribute/attribute-map.h>
#include <mie/ctx.h> #include <mie/ctx.h>
@@ -25,49 +25,49 @@ struct mie_parser {
struct mie_ctx *p_ctx; struct mie_ctx *p_ctx;
struct mie_lex *p_lex; struct mie_lex *p_lex;
enum mie_status p_status; 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; return parser->s_tmp;
} }
#define GET_SOMETHING_BY_FULL_NAME(thing) \ #define GET_SOMETHING_BY_FULL_NAME(thing) \
static const struct mie_##thing##_definition *get_##thing##_by_full_name( \ 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(); \ fx_string *dialect = fx_string_create(); \
b_string *item = b_string_create(); \ fx_string *item = fx_string_create(); \
const char *delim[] = {"."}; \ const char *delim[] = {"."}; \
size_t i = 0; \ size_t i = 0; \
b_iterator *it = b_string_tokenise( \ fx_iterator *it = fx_string_tokenise( \
name, delim, 1, B_STRING_TOK_F_NORMAL); \ name, delim, 1, FX_STRING_TOK_F_NORMAL); \
while (b_iterator_is_valid(it)) { \ while (fx_iterator_is_valid(it)) { \
const char *tok = b_iterator_get_cvalue(it).v_cptr; \ const char *tok = fx_iterator_get_cvalue(it).v_cptr; \
switch (i) { \ switch (i) { \
case 0: \ case 0: \
b_string_append_cstr(dialect, tok); \ fx_string_append_cstr(dialect, tok); \
break; \ break; \
case 1: \ case 1: \
b_string_append_cstr(item, tok); \ fx_string_append_cstr(item, tok); \
break; \ break; \
default: \ default: \
b_string_append_c(item, '.'); \ fx_string_append_c(item, '.'); \
b_string_append_cstr(item, tok); \ fx_string_append_cstr(item, tok); \
break; \ break; \
} \ } \
b_iterator_move_next(it); \ fx_iterator_move_next(it); \
i++; \ i++; \
} \ } \
b_iterator_unref(it); \ fx_iterator_unref(it); \
const struct mie_##thing##_definition *def \ const struct mie_##thing##_definition *def \
= mie_ctx_get_##thing##_definition( \ = mie_ctx_get_##thing##_definition( \
ctx->p_ctx, b_string_ptr(dialect), \ ctx->p_ctx, fx_string_ptr(dialect), \
b_string_ptr(item)); \ fx_string_ptr(item)); \
b_string_unref(dialect); \ fx_string_unref(dialect); \
b_string_unref(item); \ fx_string_unref(item); \
return def; \ 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); memset(out, 0x0, sizeof *out);
out->s_tmp = b_string_create(); out->s_tmp = fx_string_create();
if (!out->s_tmp) { if (!out->s_tmp) {
free(out); free(out);
return NULL; 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) void mie_parser_destroy(struct mie_parser *ctx)
{ {
if (ctx->s_tmp) { if (ctx->s_tmp) {
b_string_unref(ctx->s_tmp); fx_string_unref(ctx->s_tmp);
} }
free(ctx); free(ctx);
@@ -126,7 +126,7 @@ void mie_parser_set_status(struct mie_parser *ctx, enum mie_status status)
ctx->p_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); return get_temp_string(ctx);
} }
@@ -217,7 +217,7 @@ bool mie_parser_parse_float(
#define TOKEN_PARSER(name, id) \ #define TOKEN_PARSER(name, id) \
bool mie_parser_parse_##name( \ 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)) { \ if (!mie_parser_check_type(ctx, id)) { \
return false; \ return false; \
@@ -225,10 +225,10 @@ bool mie_parser_parse_float(
struct mie_token *tok = mie_lex_peek(ctx->p_lex); \ struct mie_token *tok = mie_lex_peek(ctx->p_lex); \
switch (tok->tok_value_type) { \ switch (tok->tok_value_type) { \
case MIE_TOK_V_STRING: \ case MIE_TOK_V_STRING: \
b_string_append_cstr(out, tok->tok_str); \ fx_string_append_cstr(out, tok->tok_str); \
break; \ break; \
case MIE_TOK_V_INT: \ case MIE_TOK_V_INT: \
b_string_append_cstrf(out, "%lld", tok->tok_int); \ fx_string_append_cstrf(out, "%lld", tok->tok_int); \
break; \ break; \
default: \ default: \
return false; \ return false; \
@@ -256,12 +256,12 @@ TOKEN_PARSER(string, MIE_TOK_STRING);
bool mie_parser_parse_keyword( bool mie_parser_parse_keyword(
struct mie_parser *ctx, const char *kw, struct mie_file_span *loc) 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)) { if (!mie_parser_parse_word(ctx, str, loc)) {
return false; 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) 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, struct mie_parser *ctx, const char *context,
const struct mie_type **out, struct mie_file_span *out_span) 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; struct mie_file_span loc;
if (!mie_parser_parse_word(ctx, name, &loc)) { if (!mie_parser_parse_word(ctx, name, &loc)) {
return false; return false;
@@ -315,7 +315,7 @@ static bool parse_builtin_type_name(
FLOAT FLOAT
} base_type = NONE; } base_type = NONE;
const char *name_cstr = b_string_ptr(name); const char *name_cstr = fx_string_ptr(name);
if (!strcmp(name_cstr, "memref")) { if (!strcmp(name_cstr, "memref")) {
type_info = mie_ctx_get_type_definition( type_info = mie_ctx_get_type_definition(
@@ -381,7 +381,7 @@ static bool parse_type_name(
struct mie_parser *ctx, const char *context, struct mie_parser *ctx, const char *context,
const struct mie_type **out, struct mie_file_span *out_span) 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; struct mie_file_span loc;
if (!mie_parser_parse_typename(ctx, name, &loc)) { if (!mie_parser_parse_typename(ctx, name, &loc)) {
return false; 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) bool mie_parser_parse_operand(struct mie_parser *ctx, struct mie_op_arg *out)
{ {
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
b_string *str = get_temp_string(ctx); fx_string *str = get_temp_string(ctx);
bool result = false; bool result = false;
struct mie_file_span loc; struct mie_file_span loc;
if (mie_parser_parse_vregname(ctx, str, &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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL;
result = true; result = true;
} else if (mie_parser_parse_mregname(ctx, str, &loc)) { } 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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE;
result = true; result = true;
} }
@@ -698,14 +698,14 @@ bool mie_parser_parse_parameter(
const char *context) const char *context)
{ {
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
b_string *str = get_temp_string(ctx); fx_string *str = get_temp_string(ctx);
struct mie_file_span loc; struct mie_file_span loc;
if (mie_parser_parse_vregname(ctx, str, &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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_VIRTUAL;
} else if (mie_parser_parse_mregname(ctx, str, &loc)) { } 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; out->arg_unresolved.reg_flags = MIE_REGISTER_F_MACHINE;
} else { } else {
struct mie_parser_item required[] = { struct mie_parser_item required[] = {
@@ -823,16 +823,16 @@ bool mie_parser_parse_register(
} }
struct mie_name *name = NULL; struct mie_name *name = NULL;
b_string *tmp = get_temp_string(ctx); fx_string *tmp = get_temp_string(ctx);
switch (tok->tok_value_type) { switch (tok->tok_value_type) {
case MIE_TOK_V_STRING: case MIE_TOK_V_STRING:
name = mie_parser_scope_put_name( name = mie_parser_scope_put_name(
scope, &out->reg_name, tok->tok_str, MIE_NAME_MAP_F_STRICT); scope, &out->reg_name, tok->tok_str, MIE_NAME_MAP_F_STRICT);
break; break;
case MIE_TOK_V_INT: 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( 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); MIE_NAME_MAP_F_STRICT);
break; break;
default: default:
@@ -1070,7 +1070,7 @@ bool mie_parser_parse_block(
return NULL; return NULL;
} }
b_string *str = get_temp_string(ctx); fx_string *str = get_temp_string(ctx);
struct mie_file_span span; struct mie_file_span span;
if (!mie_parser_parse_blockname(ctx, str, &span)) { if (!mie_parser_parse_blockname(ctx, str, &span)) {
@@ -1078,7 +1078,7 @@ bool mie_parser_parse_block(
} }
if (!mie_parser_scope_put_name( 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)) { MIE_NAME_MAP_F_STRICT)) {
return false; 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) bool mie_parser_parse_successor(struct mie_parser *ctx, struct mie_op_successor *out)
{ {
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
b_string *str = get_temp_string(ctx); fx_string *str = get_temp_string(ctx);
bool result = false; bool result = false;
if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) { if (!mie_parser_parse_blockname(ctx, str, &out->s_name_span)) {
return false; 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)) { if (!mie_parser_parse_symbol(ctx, MIE_SYM_COLON)) {
return true; return true;
@@ -1203,13 +1203,13 @@ bool mie_parser_parse_successor_list(
static bool parse_custom_op( static bool parse_custom_op(
struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) 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; struct mie_file_span loc;
if (!mie_parser_parse_name(ctx, str, &dest->op_name_span)) { if (!mie_parser_parse_name(ctx, str, &dest->op_name_span)) {
return false; 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)) { if (!mie_resolve_op_self(dest, ctx->p_ctx)) {
struct mie_diag *diag = mie_ctx_push_diag( struct mie_diag *diag = mie_ctx_push_diag(
@@ -1267,13 +1267,13 @@ static bool parse_custom_op(
static bool parse_builtin_op( static bool parse_builtin_op(
struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) 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; struct mie_file_span loc;
if (!mie_parser_parse_word(ctx, str, &loc)) { if (!mie_parser_parse_word(ctx, str, &loc)) {
return false; 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)) { if (!mie_resolve_op_self(dest, ctx->p_ctx)) {
struct mie_diag *diag = mie_ctx_push_diag( struct mie_diag *diag = mie_ctx_push_diag(
@@ -1331,13 +1331,13 @@ static bool parse_builtin_op(
static bool parse_generic_op( static bool parse_generic_op(
struct mie_parser *ctx, struct mie_parser_scope *scope, struct mie_op *dest) 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; struct mie_file_span loc;
if (!mie_parser_parse_opname(ctx, str, &loc)) { if (!mie_parser_parse_opname(ctx, str, &loc)) {
return false; 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 /* 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. */ * 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); enum mie_token_type type = mie_parser_peek_type(ctx);
const struct mie_attribute_definition *attribute = NULL; 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; struct mie_file_span span;
bool need_angle_delim = false; bool need_angle_delim = false;
@@ -1554,13 +1554,13 @@ static bool parse_attribute_map_entry(
struct mie_parser *ctx, char **out_name, struct mie_parser *ctx, char **out_name,
const struct mie_attribute **out_value) 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; struct mie_file_span span;
if (!mie_parser_parse_word(ctx, str, &span)) { if (!mie_parser_parse_word(ctx, str, &span)) {
return false; return false;
} }
char *name = b_string_steal(str); char *name = fx_string_steal(str);
if (!mie_parser_parse_symbol(ctx, MIE_SYM_EQUAL)) { if (!mie_parser_parse_symbol(ctx, MIE_SYM_EQUAL)) {
free(name); free(name);
@@ -1691,29 +1691,29 @@ void mie_parser_report_unexpected_token_v(
struct mie_parser *parser, struct mie_parser *parser,
const struct mie_parser_item expected_tokens[], const char *context) const struct mie_parser_item expected_tokens[], const char *context)
{ {
b_bstr str; fx_bstr str;
b_bstr_begin_dynamic(&str); fx_bstr_begin_dynamic(&str);
struct mie_token *tok = mie_lex_peek(parser->p_lex); 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++) { 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; bool end = expected_tokens[i + 1].i_type == MIE_PARSER_ITEM_NONE;
if (end && i > 0) { if (end && i > 0) {
b_bstr_write_cstr(&str, " or ", NULL); fx_bstr_write_cstr(&str, " or ", NULL);
} else if (i > 0) { } else if (i > 0) {
b_bstr_write_cstr(&str, ", ", NULL); fx_bstr_write_cstr(&str, ", ", NULL);
} }
switch (expected_tokens[i].i_type) { switch (expected_tokens[i].i_type) {
case MIE_PARSER_ITEM_TOK: case MIE_PARSER_ITEM_TOK:
b_bstr_write_fmt( fx_bstr_write_fmt(
&str, NULL, "[blue]%s[reset]", &str, NULL, "[blue]%s[reset]",
token_diag_string(expected_tokens[i].i_tok)); token_diag_string(expected_tokens[i].i_tok));
break; break;
case MIE_PARSER_ITEM_CSTR: case MIE_PARSER_ITEM_CSTR:
b_bstr_write_fmt( fx_bstr_write_fmt(
&str, NULL, "[blue]%s[reset]", &str, NULL, "[blue]%s[reset]",
expected_tokens[i].i_cstr); expected_tokens[i].i_cstr);
break; break;
@@ -1723,22 +1723,22 @@ void mie_parser_report_unexpected_token_v(
} }
if (context) { if (context) {
b_bstr_write_fmt( fx_bstr_write_fmt(
&str, NULL, " while parsing [cyan]%s[reset]", context); &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) { 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) { } 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 { } 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);
b_bstr_write_cstr(&str, ".", 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 const struct mie_file_cell *loc = tok ? &tok->tok_location.s_start
: mie_lex_get_cursor(parser->p_lex); : 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( void mie_parser_report_unexpected_token_s(
struct mie_parser *parser, const char *expected_token, const char *context) struct mie_parser *parser, const char *expected_token, const char *context)
{ {
b_bstr str; fx_bstr str;
b_bstr_begin_dynamic(&str); fx_bstr_begin_dynamic(&str);
struct mie_token *tok = mie_lex_peek(parser->p_lex); 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) { if (context) {
b_bstr_write_fmt( fx_bstr_write_fmt(
&str, NULL, " while parsing [cyan]%s[reset]", context); &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) { 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) { } 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 { } 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 const struct mie_file_cell *loc = tok ? &tok->tok_location.s_start
: mie_lex_get_cursor(parser->p_lex); : mie_lex_get_cursor(parser->p_lex);

4
mie/pass/builtin/convert-scf-to-cf.c
View File

@@ -52,7 +52,7 @@ static struct mie_rewrite_result if_rewrite(
struct mie_register *old_reg = &op->op_result.items[i]; struct mie_register *old_reg = &op->op_result.items[i];
struct mie_register *new_reg = mie_block_add_param(end_block); struct mie_register *new_reg = mie_block_add_param(end_block);
new_reg->reg_type = old_reg->reg_type; 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_name_destroy(&old_reg->reg_name);
mie_rewriter_rename_register(rewriter, new_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 *old_reg = &op->op_result.items[i];
struct mie_register *new_reg = mie_block_add_param(end_block); struct mie_register *new_reg = mie_block_add_param(end_block);
new_reg->reg_type = old_reg->reg_type; 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_name_destroy(&old_reg->reg_name);
mie_rewriter_rename_register(rewriter, new_reg, name); mie_rewriter_rename_register(rewriter, new_reg, name);

38
mie/pass/pass-manager.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/queue.h> #include <fx/core/queue.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/interface/interface-definition.h> #include <mie/interface/interface-definition.h>
@@ -16,13 +16,13 @@
struct pass_sched { struct pass_sched {
struct mie_op *s_op; struct mie_op *s_op;
b_queue_entry s_entry; fx_queue_entry s_entry;
/* queue of struct pass_sched_item */ /* queue of struct pass_sched_item */
b_queue s_items; fx_queue s_items;
}; };
struct pass_sched_item { struct pass_sched_item {
b_queue_entry i_entry; fx_queue_entry i_entry;
struct mie_pass *i_pass; 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( 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) 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) { if (!filter_check_op(&pm->pm_filter, op) || depth > pm->pm_depth) {
return; return;
} }
@@ -196,13 +196,13 @@ static void schedule_passes(
} }
struct pass_sched_item *item = pass_sched_item_create(pass); 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); struct pass_sched *sched = pass_sched_create(op);
sched->s_items = passes; sched->s_items = passes;
b_queue_push_back(schedule, &sched->s_entry); fx_queue_push_back(schedule, &sched->s_entry);
} }
struct mie_walker walker; struct mie_walker walker;
@@ -236,14 +236,14 @@ static void sched_execute(
struct pass_sched *sched, struct mie_pass_args *args, struct pass_sched *sched, struct mie_pass_args *args,
struct mie_pass_result *result) 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; 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) { while (cur_item) {
sched_item = b_unbox(struct pass_sched_item, cur_item, i_entry); sched_item = fx_unbox(struct pass_sched_item, cur_item, i_entry);
next_item = b_queue_next(cur_item); next_item = fx_queue_next(cur_item);
b_queue_delete(&sched->s_items, cur_item); fx_queue_delete(&sched->s_items, cur_item);
sched_item_execute(sched_item, sched->s_op, args, result); 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_result mie_pass_manager_run(
struct mie_pass_manager *pm, struct mie_op *target) 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); 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 pass_sched *sched = NULL;
struct mie_pass_result result = MIE_PASS_CONTINUE; struct mie_pass_result result = MIE_PASS_CONTINUE;
@@ -267,9 +267,9 @@ struct mie_pass_result mie_pass_manager_run(
}; };
while (cur_sched) { while (cur_sched) {
sched = b_unbox(struct pass_sched, cur_sched, s_entry); sched = fx_unbox(struct pass_sched, cur_sched, s_entry);
next_sched = b_queue_next(cur_sched); next_sched = fx_queue_next(cur_sched);
b_queue_delete(&schedule, cur_sched); fx_queue_delete(&schedule, cur_sched);
sched_execute(sched, &args, &result); sched_execute(sched, &args, &result);

24
mie/print/block.c
View File

@@ -31,42 +31,42 @@ static void print_block_header_params(
return; 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(block->b_params); i++) {
if (i > 0) { 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); 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); 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( static void print_block_header(
struct mie_printer *printer, const struct mie_block *block) 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) { if (first_block && !block->b_name.n_str) {
return; return;
} }
b_stream_write_char(printer->p_stream, '^'); fx_stream_write_char(printer->p_stream, '^');
if (block->b_name.n_str) { 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 { } else {
b_stream_write_string(printer->p_stream, "<UNNAMED>", NULL); fx_stream_write_string(printer->p_stream, "<UNNAMED>", NULL);
} }
print_block_header_params(printer, block); 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( void mie_printer_print_block(
@@ -77,16 +77,16 @@ void mie_printer_print_block(
print_block_header(printer, 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); struct mie_op *op = mie_block_get_first_op(block);
while (op) { while (op) {
mie_printer_print_op(printer, 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); 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( void mie_printer_print_block_ref(

84
mie/print/op.c
View File

@@ -33,28 +33,28 @@ void mie_printer_print_op_arg(
} }
if (arg_flags & MIE_REGISTER_F_MACHINE) { if (arg_flags & MIE_REGISTER_F_MACHINE) {
b_stream_write_char(printer->p_stream, '$'); fx_stream_write_char(printer->p_stream, '$');
} else { } else {
b_stream_write_char(printer->p_stream, '%'); fx_stream_write_char(printer->p_stream, '%');
} }
if (!arg_name) { if (!arg_name) {
arg_name = "<NO-NAME>"; arg_name = "<NO-NAME>";
} }
b_stream_write_string(printer->p_stream, arg_name, NULL); fx_stream_write_string(printer->p_stream, arg_name, NULL);
if (!resolved if (!resolved
&& MIE_TEST_FLAGS( && MIE_TEST_FLAGS(
printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { 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) { if (!include_type || !arg_type) {
return; return;
} }
b_stream_write_string(printer->p_stream, ": ", NULL); fx_stream_write_string(printer->p_stream, ": ", NULL);
mie_printer_print_type(printer, arg_type); 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, struct mie_printer *printer, const struct mie_op_successor *successor,
bool compact) bool compact)
{ {
b_stream_write_char(printer->p_stream, '^'); fx_stream_write_char(printer->p_stream, '^');
bool resolved = false; bool resolved = false;
const char *name = NULL; const char *name = NULL;
@@ -78,12 +78,12 @@ void mie_printer_print_op_successor(
name = "<NO-NAME>"; name = "<NO-NAME>";
} }
b_stream_write_string(printer->p_stream, name, NULL); fx_stream_write_string(printer->p_stream, name, NULL);
if (!resolved if (!resolved
&& MIE_TEST_FLAGS( && MIE_TEST_FLAGS(
printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { 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) { if (MIE_VECTOR_COUNT(successor->s_args) == 0) {
@@ -91,20 +91,20 @@ void mie_printer_print_op_successor(
} }
if (!compact) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(successor->s_args); i++) {
if (i > 0) { 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); 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( static void print_successor_list(
@@ -114,34 +114,34 @@ static void print_successor_list(
return; 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) {
if (i > 0) { if (i > 0) {
b_stream_write_string(printer->p_stream, ", ", NULL); fx_stream_write_string(printer->p_stream, ", ", NULL);
} }
mie_printer_print_op_successor( mie_printer_print_op_successor(
printer, &op->op_successors.items[i], false); 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) 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; 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); struct mie_region *region = mie_op_get_first_region(op);
size_t i = 0; size_t i = 0;
while (region) { while (region) {
if (i > 0) { 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); 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++; i++;
} }
b_stream_write_string(printer->p_stream, ")", NULL); fx_stream_write_string(printer->p_stream, ")", NULL);
} }
static void print_attribute( static void print_attribute(
struct mie_printer *printer, const struct mie_attribute_map_iterator *attrib) 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); mie_printer_print_attribute(printer, attrib->it_value);
} }
@@ -167,7 +167,7 @@ static void print_attribute_list(
return; return;
} }
b_stream_write_string(printer->p_stream, " { ", NULL); fx_stream_write_string(printer->p_stream, " { ", NULL);
struct mie_attribute_map_iterator it; struct mie_attribute_map_iterator it;
enum mie_status status enum mie_status status
@@ -176,7 +176,7 @@ static void print_attribute_list(
while (status == MIE_SUCCESS) { while (status == MIE_SUCCESS) {
if (i > 0) { if (i > 0) {
b_stream_write_string(printer->p_stream, ", ", NULL); fx_stream_write_string(printer->p_stream, ", ", NULL);
} }
print_attribute(printer, &it); print_attribute(printer, &it);
@@ -184,18 +184,18 @@ static void print_attribute_list(
i++; i++;
} }
b_stream_write_string(printer->p_stream, " }", NULL); fx_stream_write_string(printer->p_stream, " }", NULL);
} }
static void print_type_signature( static void print_type_signature(
struct mie_printer *printer, const struct mie_op *op) struct mie_printer *printer, const struct mie_op *op)
{ {
const struct mie_type *type = NULL; 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { 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]; 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); 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) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
if (i > 0) { 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; 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) { 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) 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) { if (op->op_flags & MIE_OP_F_OP_RESOLVED) {
b_stream_write_fmt( fx_stream_write_fmt(
printer->p_stream, NULL, "%s.%s", printer->p_stream, NULL, "%s.%s",
op->op_info->op_parent->d_name, op->op_info->op_name); op->op_info->op_parent->d_name, op->op_info->op_name);
} else { } 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( if (MIE_TEST_FLAGS(
printer->p_flags, MIE_PRINT_F_MARK_UNRESOLVED_ELEMENTS)) { 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_args); i++) {
if (i > 0) { 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); 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_successor_list(printer, op);
print_region_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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
if (i > 0) { 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); mie_printer_print_register(printer, &op->op_result.items[i], 0);
} }
if (MIE_VECTOR_COUNT(op->op_result) > 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 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) { if (printer->p_flags & MIE_PRINT_F_GENERIC) {
generic = true; 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")) { } else if (!strcmp(op->op_info->op_parent->d_name, "builtin")) {
builtin = true; builtin = true;
} }
if (!resolved) { 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; return;
} }
if (generic || !builtin || !abbreviate) { if (generic || !builtin || !abbreviate) {
b_stream_write_fmt( fx_stream_write_fmt(
printer->p_stream, NULL, "%s.", printer->p_stream, NULL, "%s.",
op->op_info->op_parent->d_name); 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; return;
} }

2
mie/print/printer.c
View File

@@ -1,7 +1,7 @@
#include <mie/print/printer.h> #include <mie/print/printer.h>
enum mie_status mie_printer_init( 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) enum mie_print_flags flags)
{ {
memset(printer, 0x0, sizeof *printer); memset(printer, 0x0, sizeof *printer);

4
mie/print/region.c
View File

@@ -6,7 +6,7 @@ void mie_printer_print_region(
struct mie_printer *printer, const struct mie_region *region, struct mie_printer *printer, const struct mie_region *region,
enum mie_print_flags flags) 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); struct mie_block *block = mie_region_get_first_block(region);
size_t i = 0; size_t i = 0;
@@ -24,5 +24,5 @@ void mie_printer_print_region(
i++; i++;
} }
b_stream_write_string(printer->p_stream, "}", NULL); fx_stream_write_string(printer->p_stream, "}", NULL);
} }

8
mie/print/register.c
View File

@@ -6,18 +6,18 @@ void mie_printer_print_register(
enum mie_print_flags flags) enum mie_print_flags flags)
{ {
if (reg->reg_flags & MIE_REGISTER_F_VIRTUAL) { 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); printer->p_stream, NULL, "%%%s", reg->reg_name.n_str);
} else if (reg->reg_flags & MIE_REGISTER_F_MACHINE) { } else if (reg->reg_flags & MIE_REGISTER_F_MACHINE) {
// TODO this shouldnt use reg_name // TODO this shouldnt use reg_name
b_stream_write_fmt( fx_stream_write_fmt(
printer->p_stream, NULL, "$%s", reg->reg_name.n_str); printer->p_stream, NULL, "$%s", reg->reg_name.n_str);
} else { } 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) { 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); mie_printer_print_type(printer, reg->reg_type);
} }
} }

14
mie/print/type.c
View File

@@ -13,23 +13,23 @@
void mie_printer_print_type(struct mie_printer *printer, const struct mie_type *type) void mie_printer_print_type(struct mie_printer *printer, const struct mie_type *type)
{ {
if (!type) { if (!type) {
b_stream_write_string(printer->p_stream, "<NULL-TYPE>", NULL); fx_stream_write_string(printer->p_stream, "<NULL-TYPE>", NULL);
return; return;
} }
if (TYPE_HAS_PRINT_CALLBACK(type)) { if (TYPE_HAS_PRINT_CALLBACK(type)) {
type->ty_def->ty_print(type, printer); type->ty_def->ty_print(type, printer);
} else if (TYPE_IS_BUILTIN(type)) { } else if (TYPE_IS_BUILTIN(type)) {
b_stream_write_string( fx_stream_write_string(
printer->p_stream, type->ty_def->ty_name, NULL); printer->p_stream, type->ty_def->ty_name, NULL);
} else if (TYPE_HAS_NAME(type)) { } else if (TYPE_HAS_NAME(type)) {
b_stream_write_char(printer->p_stream, '!'); fx_stream_write_char(printer->p_stream, '!');
b_stream_write_string(printer->p_stream, type->ty_name, NULL); fx_stream_write_string(printer->p_stream, type->ty_name, NULL);
} else if (TYPE_DEF_HAS_NAME(type)) { } else if (TYPE_DEF_HAS_NAME(type)) {
b_stream_write_char(printer->p_stream, '!'); fx_stream_write_char(printer->p_stream, '!');
b_stream_write_string( fx_stream_write_string(
printer->p_stream, type->ty_def->ty_name, NULL); printer->p_stream, type->ty_def->ty_name, NULL);
} else { } else {
b_stream_write_string(printer->p_stream, "<UNNAMED-TYPE>", NULL); fx_stream_write_string(printer->p_stream, "<UNNAMED-TYPE>", NULL);
} }
} }

126
mie/rewrite/rewriter.c
View File

@@ -93,12 +93,12 @@ struct mie_block *mie_rewriter_split_block(
struct mie_block *new_block = mie_region_add_block_after(region, block); struct mie_block *new_block = mie_region_add_block_after(region, block);
mie_name_map_put(names, &new_block->b_name, name, 0); 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) { while (cur) {
struct mie_op *cur_op = b_unbox(struct mie_op, cur, op_entry); struct mie_op *cur_op = fx_unbox(struct mie_op, cur, op_entry);
b_queue_entry *next = b_queue_next(cur); fx_queue_entry *next = fx_queue_next(cur);
b_queue_delete(&block->b_ops, cur); fx_queue_delete(&block->b_ops, cur);
b_queue_push_back(&new_block->b_ops, cur); fx_queue_push_back(&new_block->b_ops, cur);
cur_op->op_container = new_block; cur_op->op_container = new_block;
cur = next; cur = next;
@@ -142,8 +142,8 @@ enum mie_status mie_rewriter_move_block_to_start(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->r_blocks, &block->b_entry); fx_queue_delete(&from->r_blocks, &block->b_entry);
b_queue_push_front(&to->r_blocks, &block->b_entry); fx_queue_push_front(&to->r_blocks, &block->b_entry);
block->b_parent = to; block->b_parent = to;
@@ -158,8 +158,8 @@ enum mie_status mie_rewriter_move_block_to_end(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->r_blocks, &block->b_entry); fx_queue_delete(&from->r_blocks, &block->b_entry);
b_queue_push_back(&to->r_blocks, &block->b_entry); fx_queue_push_back(&to->r_blocks, &block->b_entry);
block->b_parent = to; block->b_parent = to;
@@ -178,8 +178,8 @@ enum mie_status mie_rewriter_move_block_before(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->r_blocks, &block->b_entry); fx_queue_delete(&from->r_blocks, &block->b_entry);
b_queue_insert_before(&to->r_blocks, &block->b_entry, &before->b_entry); fx_queue_insert_before(&to->r_blocks, &block->b_entry, &before->b_entry);
block->b_parent = to; block->b_parent = to;
@@ -198,8 +198,8 @@ enum mie_status mie_rewriter_move_block_after(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->r_blocks, &block->b_entry); fx_queue_delete(&from->r_blocks, &block->b_entry);
b_queue_insert_after(&to->r_blocks, &block->b_entry, &after->b_entry); fx_queue_insert_after(&to->r_blocks, &block->b_entry, &after->b_entry);
block->b_parent = to; block->b_parent = to;
@@ -221,18 +221,18 @@ enum mie_status mie_rewriter_rename_block(
enum mie_status mie_rewriter_move_blocks_to_start( enum mie_status mie_rewriter_move_blocks_to_start(
struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to) 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);
b_queue_entry *insert_point = NULL; fx_queue_entry *insert_point = NULL;
while (cur) { 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); struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry);
b_queue_delete(&from->r_blocks, cur); fx_queue_delete(&from->r_blocks, cur);
if (insert_point) { if (insert_point) {
b_queue_insert_after(&to->r_blocks, cur, insert_point); fx_queue_insert_after(&to->r_blocks, cur, insert_point);
} else { } else {
b_queue_push_front(&to->r_blocks, cur); fx_queue_push_front(&to->r_blocks, cur);
} }
block->b_parent = to; 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( enum mie_status mie_rewriter_move_blocks_to_end(
struct mie_rewriter *rw, struct mie_region *from, struct mie_region *to) 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) { 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); struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry);
b_queue_delete(&from->r_blocks, cur); fx_queue_delete(&from->r_blocks, cur);
b_queue_push_back(&to->r_blocks, cur); fx_queue_push_back(&to->r_blocks, cur);
block->b_parent = to; block->b_parent = to;
cur = next; cur = next;
@@ -269,13 +269,13 @@ enum mie_status mie_rewriter_move_blocks_before(
return MIE_ERR_INVALID_ARGUMENT; 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) { 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); struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry);
b_queue_delete(&from->r_blocks, cur); fx_queue_delete(&from->r_blocks, cur);
b_queue_insert_before(&to->r_blocks, cur, &before->b_entry); fx_queue_insert_before(&to->r_blocks, cur, &before->b_entry);
block->b_parent = to; block->b_parent = to;
cur = next; cur = next;
@@ -292,15 +292,15 @@ enum mie_status mie_rewriter_move_blocks_after(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_entry *cur = b_queue_first(&from->r_blocks); fx_queue_entry *cur = fx_queue_first(&from->r_blocks);
b_queue_entry *insert_point = &after->b_entry; fx_queue_entry *insert_point = &after->b_entry;
while (cur) { 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); struct mie_block *block = fx_unbox(struct mie_block, cur, b_entry);
b_queue_delete(&from->r_blocks, cur); fx_queue_delete(&from->r_blocks, cur);
b_queue_insert_after(&to->r_blocks, cur, insert_point); fx_queue_insert_after(&to->r_blocks, cur, insert_point);
block->b_parent = to; block->b_parent = to;
insert_point = cur; insert_point = cur;
@@ -318,8 +318,8 @@ enum mie_status mie_rewriter_move_region_to_start(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->op_regions, &region->r_entry); fx_queue_delete(&from->op_regions, &region->r_entry);
b_queue_push_front(&to->op_regions, &region->r_entry); fx_queue_push_front(&to->op_regions, &region->r_entry);
region->r_parent = to; region->r_parent = to;
@@ -334,8 +334,8 @@ enum mie_status mie_rewriter_move_region_to_end(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->op_regions, &region->r_entry); fx_queue_delete(&from->op_regions, &region->r_entry);
b_queue_push_back(&to->op_regions, &region->r_entry); fx_queue_push_back(&to->op_regions, &region->r_entry);
region->r_parent = to; region->r_parent = to;
@@ -354,8 +354,8 @@ enum mie_status mie_rewriter_move_region_before(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->op_regions, &region->r_entry); fx_queue_delete(&from->op_regions, &region->r_entry);
b_queue_insert_before(&to->op_regions, &region->r_entry, &before->r_entry); fx_queue_insert_before(&to->op_regions, &region->r_entry, &before->r_entry);
region->r_parent = to; region->r_parent = to;
@@ -374,8 +374,8 @@ enum mie_status mie_rewriter_move_region_after(
return MIE_ERR_INVALID_ARGUMENT; return MIE_ERR_INVALID_ARGUMENT;
} }
b_queue_delete(&from->op_regions, &region->r_entry); fx_queue_delete(&from->op_regions, &region->r_entry);
b_queue_insert_after(&to->op_regions, &region->r_entry, &after->r_entry); fx_queue_insert_after(&to->op_regions, &region->r_entry, &after->r_entry);
region->r_parent = to; 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_flags = MIE_OP_F_ARG_RESOLVED;
arg->arg_value.u_reg = args[i]; arg->arg_value.u_reg = args[i];
arg->arg_value.u_user = op; 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; 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_flags = MIE_OP_F_ARG_RESOLVED;
arg->arg_value.u_reg = value; arg->arg_value.u_reg = value;
arg->arg_value.u_user = op; 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; 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_flags = MIE_OP_F_ARG_RESOLVED;
arg->arg_value.u_reg = value; arg->arg_value.u_reg = value;
arg->arg_value.u_user = op; 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; 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; 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_successors); i++) {
struct mie_op_successor *s = &op->op_successors.items[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; continue;
} }
b_queue_delete( fx_queue_delete(
&arg->arg_value.u_reg->reg_use, &arg->arg_value.u_reg->reg_use,
&arg->arg_value.u_entry); &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; continue;
} }
b_queue_delete( fx_queue_delete(
&arg->arg_value.u_reg->reg_use, &arg->arg_value.u_entry); &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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(op->op_result); i++) {
struct mie_register *reg = &op->op_result.items[i]; struct mie_register *reg = &op->op_result.items[i];
b_queue_entry *cur = b_queue_first(&reg->reg_use); fx_queue_entry *cur = fx_queue_first(&reg->reg_use);
while (cur) { while (cur) {
b_queue_entry *next = b_queue_next(cur); fx_queue_entry *next = fx_queue_next(cur);
struct mie_register_use *use 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->reg_use, &use->u_entry); fx_queue_delete(&reg->reg_use, &use->u_entry);
use->u_reg = NULL; use->u_reg = NULL;
cur = next; cur = next;
} }
@@ -529,14 +529,14 @@ enum mie_status mie_rewriter_move_op_args_to_successor(
struct mie_register *reg = NULL; struct mie_register *reg = NULL;
if (src->arg_flags & MIE_OP_F_ARG_RESOLVED) { if (src->arg_flags & MIE_OP_F_ARG_RESOLVED) {
reg = src->arg_value.u_reg; reg = src->arg_value.u_reg;
b_queue_delete(&reg->reg_use, &src->arg_value.u_entry); fx_queue_delete(&reg->reg_use, &src->arg_value.u_entry);
} }
memcpy(dest, src, sizeof *src); memcpy(dest, src, sizeof *src);
if (reg) { if (reg) {
memset(&dest->arg_value.u_entry, 0x0, memset(&dest->arg_value.u_entry, 0x0,
sizeof dest->arg_value.u_entry); sizeof dest->arg_value.u_entry);
b_queue_push_back(&reg->reg_use, &dest->arg_value.u_entry); fx_queue_push_back(&reg->reg_use, &dest->arg_value.u_entry);
} }
} }
@@ -558,9 +558,9 @@ static enum mie_status replace_register_usage(
continue; 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; 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++) { 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; 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; 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( enum mie_status mie_rewriter_replace_register(
struct mie_rewriter *rw, struct mie_register *old, struct mie_register *new) 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) { while (cur) {
struct mie_register_use *use 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; struct mie_op *op = use->u_user;
if (use->u_reg == old) { if (use->u_reg == old) {
replace_register_usage(op, old, new); replace_register_usage(op, old, new);
} }
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
return MIE_SUCCESS; return MIE_SUCCESS;

26
mie/status.c
View File

@@ -1,31 +1,31 @@
#include <blue/core/error.h> #include <fx/core/error.h>
#include <errno.h> #include <errno.h>
#include <mie/status.h> #include <mie/status.h>
static const b_error_definition error_defs[] = { static const fx_error_definition error_defs[] = {
B_ERROR_DEFINITION(MIE_SUCCESS, "SUCCESS", "Success"), FX_ERROR_DEFINITION(MIE_SUCCESS, "SUCCESS", "Success"),
B_ERROR_DEFINITION(MIE_ERR_EOF, "EOF", "Unexpected end of file"), FX_ERROR_DEFINITION(MIE_ERR_EOF, "EOF", "Unexpected end of file"),
B_ERROR_DEFINITION(MIE_ERR_BAD_SYNTAX, "BAD_SYNTAX", "Invalid syntax"), FX_ERROR_DEFINITION(MIE_ERR_BAD_SYNTAX, "BAD_SYNTAX", "Invalid syntax"),
B_ERROR_DEFINITION(MIE_ERR_NO_MEMORY, "NO_MEMORY", "Out of memory"), FX_ERROR_DEFINITION(MIE_ERR_NO_MEMORY, "NO_MEMORY", "Out of memory"),
B_ERROR_DEFINITION( FX_ERROR_DEFINITION(
MIE_ERR_NOT_SUPPORTED, "NOT_SUPPORTED", MIE_ERR_NOT_SUPPORTED, "NOT_SUPPORTED",
"Operation not supported"), "Operation not supported"),
B_ERROR_DEFINITION( FX_ERROR_DEFINITION(
MIE_ERR_INTERNAL_FAILURE, "INTERNAL_FAILURE", MIE_ERR_INTERNAL_FAILURE, "INTERNAL_FAILURE",
"Internal failure"), "Internal failure"),
B_ERROR_DEFINITION( FX_ERROR_DEFINITION(
MIE_ERR_INVALID_VALUE, "INVALID_VALUE", "Invalid value"), MIE_ERR_INVALID_VALUE, "INVALID_VALUE", "Invalid value"),
B_ERROR_DEFINITION(MIE_ERR_NO_ENTRY, "NO_ENTRY", "Name does not exist"), FX_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_BAD_FORMAT, "BAD_FORMAT", "Bad format"),
}; };
static const b_error_vendor error_vendor = { static const fx_error_vendor error_vendor = {
.v_name = "Mie", .v_name = "Mie",
.v_error_definitions = error_defs, .v_error_definitions = error_defs,
.v_error_definitions_length = sizeof 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; return &error_vendor;
} }

6
mie/trait/trait-definition.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/trait/trait-definition.h> #include <mie/trait/trait-definition.h>
@@ -12,7 +12,7 @@ struct mie_trait_definition *mie_trait_definition_create(
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->tr_name = b_strdup(name); out->tr_name = fx_strdup(name);
if (!out->tr_name) { if (!out->tr_name) {
free(out); free(out);
return NULL; return NULL;
@@ -20,7 +20,7 @@ struct mie_trait_definition *mie_trait_definition_create(
out->tr_parent = parent; 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); mie_id_map_put(&parent->d_traits, &out->tr_id, &name_rope);
return out; return out;

40
mie/trait/trait-table.c
View File

@@ -20,7 +20,7 @@ struct generic_trait {
/* generic trait ID. */ /* generic trait ID. */
mie_id g_id; mie_id g_id;
/* list of struct unique_trait */ /* 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) 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; 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; return out;
} }
static void generic_trait_destroy(struct generic_trait *trait) 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) { while (cur) {
b_queue_entry *next = b_queue_next(cur); fx_queue_entry *next = fx_queue_next(cur);
b_queue_delete(&trait->g_traits, cur); fx_queue_delete(&trait->g_traits, cur);
struct unique_trait *u 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); unique_trait_destroy(u);
cur = next; 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 mie_id *result = mie_id_map_get(&table->tr_unique, &id);
const struct unique_trait *entry 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; 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); mie_id *target = mie_id_map_get(&table->tr_generic, &id);
struct generic_trait *generic struct generic_trait *generic
= b_unbox(struct generic_trait, target, g_id); = fx_unbox(struct generic_trait, target, g_id);
if (!generic) { if (!generic) {
generic = generic_trait_create(trait); generic = generic_trait_create(trait);
@@ -160,7 +160,7 @@ static enum mie_status put_generic_trait(
return MIE_ERR_NO_MEMORY; 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; 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 mie_id *result = mie_id_map_get(&table->tr_unique, &id);
const struct generic_trait *entry 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; return MIE_ERR_NO_ENTRY;
} }
memset(it, 0x0, sizeof *it); 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 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; it->it_trait = trait->u_trait;
@@ -216,7 +216,7 @@ enum mie_status mie_trait_table_iterate(
while (it.it_id) { while (it.it_id) {
const struct unique_trait *trait 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); ret = func(trait->u_trait, arg);
if (ret != 0) { if (ret != 0) {
@@ -230,19 +230,19 @@ enum mie_status mie_trait_table_iterate(
while (it.it_id) { while (it.it_id) {
const struct generic_trait *trait_group 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) { while (cur) {
const struct unique_trait *trait 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); ret = func(trait->u_trait, arg);
if (ret != 0) { if (ret != 0) {
return MIE_SUCCESS; return MIE_SUCCESS;
} }
cur = b_queue_next(cur); cur = fx_queue_next(cur);
} }
mie_id_map_iterator_move_next(&it); 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; return MIE_ERR_NO_ENTRY;
} }
it->_e = b_queue_next(it->_e); it->_e = fx_queue_next(it->_e);
if (!it->_e) { if (!it->_e) {
return MIE_ERR_NO_ENTRY; return MIE_ERR_NO_ENTRY;
} }
struct unique_trait *trait 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; it->it_trait = trait->u_trait;
return MIE_SUCCESS; return MIE_SUCCESS;

8
mie/trait/trait.c
View File

@@ -1,15 +1,15 @@
#include <mie/trait/trait-definition.h> #include <mie/trait/trait-definition.h>
#include <mie/trait/trait.h> #include <mie/trait/trait.h>
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) { 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) { } else if (trait->tr_def && trait->tr_def->tr_print) {
trait->tr_def->tr_print(trait->tr_def, trait, out); trait->tr_def->tr_print(trait->tr_def, trait, out);
} else if (trait->tr_def->tr_name) { } 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 { } else {
b_stream_write_string(out, "<UNNAMED-TRAIT>", NULL); fx_stream_write_string(out, "<UNNAMED-TRAIT>", NULL);
} }
} }

12
mie/type/function.c
View File

@@ -21,34 +21,34 @@ static enum mie_status type_print(
const struct mie_function_type *func const struct mie_function_type *func
= (const struct mie_function_type *)type; = (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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_in); i++) {
if (i > 0) { 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)); 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) { if (MIE_VECTOR_COUNT(func->func_out) == 1) {
mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, 0)); mie_printer_print_type(out, MIE_VECTOR_ITEM(func->func_out, 0));
return MIE_SUCCESS; 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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(func->func_out); i++) {
if (i > 0) { 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)); 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; return MIE_SUCCESS;
} }

6
mie/type/storage.c
View File

@@ -20,17 +20,17 @@ static enum mie_status type_print(
{ {
const struct mie_storage_type *storage const struct mie_storage_type *storage
= (const struct mie_storage_type *)type; = (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++) { for (size_t i = 0; i < MIE_VECTOR_COUNT(storage->st_parts); i++) {
if (i > 0) { 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]); 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; return MIE_SUCCESS;
} }

6
mie/type/type-definition.c
View File

@@ -1,4 +1,4 @@
#include <blue/ds/string.h> #include <fx/ds/string.h>
#include <mie/dialect/dialect.h> #include <mie/dialect/dialect.h>
#include <mie/type/type-definition.h> #include <mie/type/type-definition.h>
@@ -12,7 +12,7 @@ struct mie_type_definition *mie_type_definition_create(
memset(out, 0x0, sizeof *out); memset(out, 0x0, sizeof *out);
out->ty_name = b_strdup(name); out->ty_name = fx_strdup(name);
if (!out->ty_name) { if (!out->ty_name) {
free(out); free(out);
return NULL; return NULL;
@@ -21,7 +21,7 @@ struct mie_type_definition *mie_type_definition_create(
out->ty_parent = parent; out->ty_parent = parent;
mie_trait_table_init(&out->ty_traits); 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); mie_id_map_put(&parent->d_types, &out->ty_id, &name_rope);
return out; return out;

6
tool/CMakeLists.txt
View File

@@ -12,9 +12,9 @@ add_executable(mie-tool ${tool_sources} ${rc_file})
target_link_libraries( target_link_libraries(
mie-tool mie-tool
mie mie
Bluelib::Core FX::Core
Bluelib::Ds FX::Ds
Bluelib::Cmd) FX::Cmd)
set_target_properties(mie-tool PROPERTIES OUTPUT_NAME "mie") set_target_properties(mie-tool PROPERTIES OUTPUT_NAME "mie")
target_compile_definitions(mie-tool PRIVATE MIE_STATIC=${MIE_STATIC}) target_compile_definitions(mie-tool PRIVATE MIE_STATIC=${MIE_STATIC})

61
tool/cmd/internal/builder-test.c
View File

@@ -1,7 +1,7 @@
#include "../cmd.h" #include "../cmd.h"
#include <blue/cmd.h> #include <fx/cmd.h>
#include <blue/term.h> #include <fx/term.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/dialect/arith.h> #include <mie/dialect/arith.h>
@@ -27,7 +27,7 @@ enum {
}; };
static int builder_test( 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(); struct mie_ctx *ctx = mie_ctx_create();
mie_builtin_dialect_create(ctx); mie_builtin_dialect_create(ctx);
@@ -94,19 +94,20 @@ static int builder_test(
struct mie_pass_manager *func_pm = mie_pass_manager_nest(pm); struct mie_pass_manager *func_pm = mie_pass_manager_nest(pm);
mie_pass_manager_filter_op(module_pm, "func", "func"); mie_pass_manager_filter_op(module_pm, "func", "func");
b_arglist_iterator it; fx_arglist_iterator it;
b_arglist_foreach(&it, args) fx_arglist_foreach(&it, args)
{ {
if (it.opt_id < OPT_PASS_OFFSET) { if (it.opt_id < OPT_PASS_OFFSET) {
continue; 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) { if (!opt) {
continue; 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; struct mie_pass *pass = NULL;
enum mie_status status enum mie_status status
= mie_ctx_get_pass(ctx, pass_name, NULL, &pass); = mie_ctx_get_pass(ctx, pass_name, NULL, &pass);
@@ -121,62 +122,62 @@ static int builder_test(
mie_pass_manager_run(pm, module); mie_pass_manager_run(pm, module);
enum mie_print_flags flags = 0; 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; 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; flags |= MIE_PRINT_F_ABBREVIATED;
} }
struct mie_printer printer; 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); mie_printer_print_op(&printer, module);
printf("\n"); printf("\n");
return 0; return 0;
} }
B_COMMAND(CMD_INTERNAL_BUILDER_TEST, CMD_INTERNAL) FX_COMMAND(CMD_INTERNAL_BUILDER_TEST, CMD_INTERNAL)
{ {
B_COMMAND_NAME("builder-test"); FX_COMMAND_NAME("builder-test");
B_COMMAND_DESC("mie_builder test"); FX_COMMAND_DESC("mie_builder test");
B_COMMAND_FUNCTION(builder_test); FX_COMMAND_FUNCTION(builder_test);
B_COMMAND_OPTION(OPT_GENERIC) FX_COMMAND_OPTION(OPT_GENERIC)
{ {
B_OPTION_LONG_NAME("generic"); FX_OPTION_LONG_NAME("generic");
B_OPTION_SHORT_NAME('g'); FX_OPTION_SHORT_NAME('g');
B_OPTION_DESC("print operations in generic format."); 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"); FX_OPTION_LONG_NAME("no-abbrev");
B_OPTION_SHORT_NAME('n'); FX_OPTION_SHORT_NAME('n');
B_OPTION_DESC( FX_OPTION_DESC(
"don't use abbreviations for builtin types and ops."); "don't use abbreviations for builtin types and ops.");
} }
B_COMMAND_HELP_OPTION(); FX_COMMAND_HELP_OPTION();
struct mie_ctx *ctx = mie_ctx_create(); struct mie_ctx *ctx = mie_ctx_create();
mie_builtin_passes_register(ctx); mie_builtin_passes_register(ctx);
size_t i = 0; 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) { 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 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); FX_OPTION_LONG_NAME(pass->p_name);
B_OPTION_DESC(pass->p_description); FX_OPTION_DESC(pass->p_description);
} }
node = b_btree_next(node); node = fx_bst_next(node);
i++; i++;
} }
} }

115
tool/cmd/internal/ctx-dump.c
View File

@@ -1,8 +1,8 @@
#include "../cmd.h" #include "../cmd.h"
#include <assert.h> #include <assert.h>
#include <blue/cmd.h> #include <fx/cmd.h>
#include <blue/term.h> #include <fx/term.h>
#include <mie/attribute/attribute-definition.h> #include <mie/attribute/attribute-definition.h>
#include <mie/ctx.h> #include <mie/ctx.h>
#include <mie/diag/class.h> #include <mie/diag/class.h>
@@ -35,7 +35,7 @@ static void mie_op_definition_print(const struct mie_op_definition *op)
{ {
char id_str[MIE_ID_STRING_MAX]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&op->op_id, id_str, sizeof id_str); 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", " [bold,red]Op:[reset]%-20s [dark_grey]{%s}[reset]\n",
op->op_name, id_str); 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]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&type->ty_id, id_str, sizeof id_str); 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", " [bold,blue]Ty:[reset]%-20s [dark_grey]{%s}[reset]\n",
type->ty_name, id_str); 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]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&trait->tr_id, id_str, sizeof id_str); 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", " [bold,yellow]Tr:[reset]%-20s [dark_grey]{%s}[reset]\n",
trait->tr_name, id_str); trait->tr_name, id_str);
} }
@@ -63,7 +63,7 @@ static void mie_attribute_definition_print(
{ {
char id_str[MIE_ID_STRING_MAX]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&attribute->a_id, id_str, sizeof id_str); 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", " [bold,magenta]At:[reset]%-20s [dark_grey]{%s}[reset]\n",
attribute->a_name, id_str); attribute->a_name, id_str);
} }
@@ -73,7 +73,7 @@ static void mie_interface_definition_print(
{ {
char id_str[MIE_ID_STRING_MAX]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&interface->if_id, id_str, sizeof id_str); 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", " [bold,cyan]If:[reset]%-20s [dark_grey]{%s}[reset]\n",
interface->if_name, id_str); 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]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&interface->p_id, id_str, sizeof id_str); 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", " [bold,cyan]Ps:[reset]%-20s [dark_grey]{%s}[reset]\n",
interface->p_name, id_str); interface->p_name, id_str);
} }
@@ -92,19 +92,19 @@ static void mie_diag_class_print(
{ {
switch (c->c_type) { switch (c->c_type) {
case MIE_DIAG_CLASS_HINT: case MIE_DIAG_CLASS_HINT:
b_printf(" [bold,cyan]Hint:[reset]"); fx_printf(" [bold,cyan]Hint:[reset]");
break; break;
case MIE_DIAG_CLASS_WARNING: case MIE_DIAG_CLASS_WARNING:
b_printf(" [bold,yellow]Warn:[reset]"); fx_printf(" [bold,yellow]Warn:[reset]");
break; break;
case MIE_DIAG_CLASS_ERROR: case MIE_DIAG_CLASS_ERROR:
b_printf(" [bold,red]Err: [reset]"); fx_printf(" [bold,red]Err: [reset]");
break; break;
default: default:
return; return;
} }
b_printf( fx_printf(
"%s.%-25s [green]%s[reset]\n", dialect->d_name, "%s.%-25s [green]%s[reset]\n", dialect->d_name,
c->c_id_str_short, c->c_title); c->c_id_str_short, c->c_title);
} }
@@ -112,7 +112,11 @@ static void mie_diag_class_print(
static void mie_diag_msg_print( static void mie_diag_msg_print(
const struct mie_dialect *dialect, const struct mie_diag_msg *msg) 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", " [bold,blue]Msg: [reset]%s.%-25s [green]%s[reset]\n",
dialect->d_name, msg->msg_id_str_short, msg->msg_content); 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]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&dialect->d_id, id_str, sizeof id_str); 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", "[bold,green]D:[reset]%-20s [dark_grey]{%s}[reset]\n",
dialect->d_name, id_str); 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) { 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 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); 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) { 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 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); 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) { 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 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); 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) { 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 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); 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) { while (node) {
mie_id *id = b_unbox(mie_id, node, e_node); mie_id *id = fx_unbox(mie_id, node, e_node);
struct mie_interface_definition *interface = b_unbox( struct mie_interface_definition *interface = fx_unbox(
struct mie_interface_definition, id, if_id); struct mie_interface_definition, id, if_id);
mie_interface_definition_print(interface); 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) static void mie_ctx_print(const struct mie_ctx *ctx)
{ {
printf("Dialects:\n"); 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) { 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 struct mie_dialect *dialect
= b_unbox(struct mie_dialect, id, d_id); = fx_unbox(struct mie_dialect, id, d_id);
mie_dialect_print(dialect); mie_dialect_print(dialect);
node = b_btree_next(node); node = fx_bst_next(node);
} }
printf("\nPasses:\n"); printf("\nPasses:\n");
node = b_btree_first(&ctx->ctx_passes.map_entries); node = fx_bst_first(&ctx->ctx_passes.map_entries);
while (node) { 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 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); mie_pass_definition_print(pass);
node = b_btree_next(node); node = fx_bst_next(node);
} }
printf("\nDiagnostics:\n"); printf("\nDiagnostics:\n");
node = b_btree_first(&ctx->ctx_dialects.map_entries); node = fx_bst_first(&ctx->ctx_dialects.map_entries);
while (node) { 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 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++) { for (size_t i = 0; i < dialect->d_nr_diag_classes; i++) {
mie_diag_class_print(dialect, &dialect->d_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++) { 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]); 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(); struct mie_ctx *ctx = mie_ctx_create();
mie_builtin_dialect_create(ctx); 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)); sizeof func_out_parts / sizeof *func_out_parts));
struct mie_printer printer; 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]; char id_str[MIE_ID_STRING_MAX];
mie_id_to_string(&i32->ty_id, id_str, sizeof id_str); 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; return 0;
} }
B_COMMAND(CMD_INTERNAL_CTX_DUMP, CMD_INTERNAL) FX_COMMAND(CMD_INTERNAL_CTX_DUMP, CMD_INTERNAL)
{ {
B_COMMAND_NAME("ctx-dump"); FX_COMMAND_NAME("ctx-dump");
B_COMMAND_DESC("mie_ctx dump"); FX_COMMAND_DESC("mie_ctx dump");
B_COMMAND_FUNCTION(ctx_dump); FX_COMMAND_FUNCTION(ctx_dump);
B_COMMAND_HELP_OPTION(); FX_COMMAND_HELP_OPTION();
} }

19
tool/cmd/internal/internal.c
View File

@@ -1,20 +1,21 @@
#include "../cmd.h" #include "../cmd.h"
#include <blue/cmd.h> #include <fx/cmd.h>
#include <blue/term.h> #include <fx/term.h>
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; return 0;
} }
B_COMMAND(CMD_INTERNAL, CMD_ROOT) FX_COMMAND(CMD_INTERNAL, CMD_ROOT)
{ {
B_COMMAND_SHORT_NAME('X'); FX_COMMAND_SHORT_NAME('X');
B_COMMAND_DESC("internal frontend debugging tools."); FX_COMMAND_DESC("internal frontend debugging tools.");
B_COMMAND_FUNCTION(internal); FX_COMMAND_FUNCTION(internal);
B_COMMAND_FLAGS(B_COMMAND_SHOW_HELP_BY_DEFAULT); FX_COMMAND_FLAGS(FX_COMMAND_SHOW_HELP_BY_DEFAULT);
B_COMMAND_HELP_OPTION(); FX_COMMAND_HELP_OPTION();
} }

Some files were not shown because too many files have changed in this diff Show More