From 46a3389288260ccfc4f4ecde1e0cdc71c43cabc7 Mon Sep 17 00:00:00 2001 From: Sander Mertens Date: Fri, 18 Mar 2022 04:03:23 -0700 Subject: [PATCH] #680 reuse type info from storage table --- flecs.c | 64921 +++++++++++++++++++++++----------------------- src/bootstrap.c | 4 + src/table.c | 51 +- 3 files changed, 32503 insertions(+), 32473 deletions(-) diff --git a/flecs.c b/flecs.c index a0159e3bd..b3173ce60 100644 --- a/flecs.c +++ b/flecs.c @@ -2109,2536 +2109,2455 @@ void _assert_func( #endif +#include + +/* Marker object used to differentiate a component vs. a tag edge */ +static ecs_table_diff_t ecs_table_edge_is_component; -/* Table sanity check to detect storage issues. Only enabled in SANITIZE mode as - * this can severly slow down many ECS operations. */ -#ifdef FLECS_SANITIZE static -void check_table_sanity(ecs_table_t *table) { - int32_t size = ecs_vector_size(table->storage.entities); - int32_t count = ecs_vector_count(table->storage.entities); - - ecs_assert(size == ecs_vector_size(table->storage.record_ptrs), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(count == ecs_vector_count(table->storage.record_ptrs), - ECS_INTERNAL_ERROR, NULL); +uint64_t ids_hash(const void *ptr) { + const ecs_ids_t *type = ptr; + ecs_id_t *ids = type->array; + int32_t count = type->count; + uint64_t hash = flecs_hash(ids, count * ECS_SIZEOF(ecs_id_t)); + return hash; +} - int32_t sw_offset = table->sw_column_offset; - int32_t sw_count = table->sw_column_count; - int32_t bs_offset = table->bs_column_offset; - int32_t bs_count = table->bs_column_count; - int32_t type_count = ecs_vector_count(table->type); - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); +static +int ids_compare(const void *ptr_1, const void *ptr_2) { + const ecs_ids_t *type_1 = ptr_1; + const ecs_ids_t *type_2 = ptr_2; - ecs_assert((sw_count + sw_offset) <= type_count, ECS_INTERNAL_ERROR, NULL); - ecs_assert((bs_count + bs_offset) <= type_count, ECS_INTERNAL_ERROR, NULL); + int32_t count_1 = type_1->count; + int32_t count_2 = type_2->count; - ecs_type_t storage_type = table->storage_type; - ecs_table_t *storage_table = table->storage_table; - ecs_assert(table->storage_type == NULL || table->storage_table != NULL, - ECS_INTERNAL_ERROR, NULL); + if (count_1 != count_2) { + return (count_1 > count_2) - (count_1 < count_2); + } + const ecs_id_t *ids_1 = type_1->array; + const ecs_id_t *ids_2 = type_2->array; + int32_t i; - if (storage_table) { - ecs_assert(storage_type == storage_table->type, - ECS_INTERNAL_ERROR, NULL); - int32_t storage_count = ecs_vector_count(storage_type); - ecs_assert(type_count >= storage_count, ECS_INTERNAL_ERROR, NULL); - - int32_t *storage_map = table->storage_map; - ecs_assert(storage_map != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_id_t *storage_ids = ecs_vector_first(storage_type, ecs_id_t); - for (i = 0; i < type_count; i ++) { - if (storage_map[i] != -1) { - ecs_assert(ids[i] == storage_ids[storage_map[i]], - ECS_INTERNAL_ERROR, NULL); - } - } + for (i = 0; i < count_1; i ++) { + ecs_id_t id_1 = ids_1[i]; + ecs_id_t id_2 = ids_2[i]; - for (i = 0; i < storage_count; i ++) { - ecs_type_info_t *ti = NULL; - ecs_column_t *column = &table->storage.columns[i]; - if (table->type_info) { - ti = table->type_info[i]; - } - if (ti) { - ecs_assert(ti->size == column->size, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ti->alignment == column->alignment, - ECS_INTERNAL_ERROR, NULL); - } - ecs_assert(size == ecs_vector_size(column->data), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(count == ecs_vector_count(column->data), - ECS_INTERNAL_ERROR, NULL); - ecs_vector_assert_size(column->data, column->size); - int32_t storage_map_id = storage_map[i + type_count]; - ecs_assert(storage_map_id >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ids[storage_map_id] == storage_ids[i], - ECS_INTERNAL_ERROR, NULL); + if (id_1 != id_2) { + return (id_1 > id_2) - (id_1 < id_2); } } - if (sw_count) { - ecs_assert(table->storage.sw_columns != NULL, - ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < sw_count; i ++) { - ecs_sw_column_t *sw = &table->storage.sw_columns[i]; - ecs_assert(sw->data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ecs_vector_count(sw->data->values) == count, - ECS_INTERNAL_ERROR, NULL); - ecs_assert((ids[i + sw_offset] & ECS_ROLE_MASK) == - ECS_SWITCH, ECS_INTERNAL_ERROR, NULL); - } - } + return 0; +} - if (bs_count) { - ecs_assert(table->storage.bs_columns != NULL, - ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < bs_count; i ++) { - ecs_bs_column_t *bs = &table->storage.bs_columns[i]; - ecs_assert(flecs_bitset_count(&bs->data) == count, - ECS_INTERNAL_ERROR, NULL); - ecs_assert((ids[i + bs_offset] & ECS_ROLE_MASK) == - ECS_DISABLED, ECS_INTERNAL_ERROR, NULL); - } - } +void flecs_table_hashmap_init(ecs_hashmap_t *hm) { + flecs_hashmap_init(hm, ecs_ids_t, ecs_table_t*, ids_hash, ids_compare); } -#else -#define check_table_sanity(table) -#endif -/* Count number of switch columns */ -static -int32_t switch_column_count( - ecs_table_t *table) +const EcsComponent* flecs_component_from_id( + const ecs_world_t *world, + ecs_entity_t e) { - int32_t i, sw_count = 0, count = ecs_vector_count(table->type); - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); + ecs_entity_t pair = 0; - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; - if (ECS_HAS_ROLE(id, SWITCH)) { - if (!sw_count) { - table->sw_column_offset = i; - } - sw_count ++; + /* If this is a pair, get the pair component from the identifier */ + if (ECS_HAS_ROLE(e, PAIR)) { + pair = e; + e = ecs_get_alive(world, ECS_PAIR_FIRST(e)); + + if (ecs_has_id(world, e, EcsTag)) { + return NULL; } } - return sw_count; + if (e & ECS_ROLE_MASK) { + return NULL; + } + + const EcsComponent *component = ecs_get(world, e, EcsComponent); + if ((!component || !component->size) && pair) { + /* If this is a pair column and the pair is not a component, use + * the component type of the component the pair is applied to. */ + e = ECS_PAIR_SECOND(pair); + + /* Because generations are not stored in the pair, get the currently + * alive id */ + e = ecs_get_alive(world, e); + + /* If a pair is used with a not alive id, the pair is not valid */ + ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL); + + component = ecs_get(world, e, EcsComponent); + } + + return component; } -/* Count number of bitset columns */ +/* Ensure the ids used in the columns exist */ static -int32_t bitset_column_count( +int32_t ensure_columns( + ecs_world_t *world, ecs_table_t *table) { - int32_t count = 0; - ecs_vector_each(table->type, ecs_entity_t, c_ptr, { - ecs_entity_t component = *c_ptr; + int32_t i, count = ecs_vector_count(table->type); + ecs_id_t* ids = ecs_vector_first(table->type, ecs_id_t); - if (ECS_HAS_ROLE(component, DISABLED)) { - if (!count) { - table->bs_column_offset = c_ptr_i; - } - count ++; - } - }); + for (i = 0; i < count; i++) { + ecs_ensure_id(world, ids[i]); + } return count; } static -void init_storage_map( - ecs_table_t *table) +ecs_vector_t* ids_to_vector( + const ecs_ids_t *entities) { - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - if (!table->storage_table) { - return; + if (entities->count) { + ecs_vector_t *result = NULL; + ecs_vector_set_count(&result, ecs_entity_t, entities->count); + ecs_entity_t *array = ecs_vector_first(result, ecs_entity_t); + ecs_os_memcpy_n(array, entities->array, ecs_entity_t, entities->count); + return result; + } else { + return NULL; } +} - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - int32_t t, ids_count = ecs_vector_count(table->type); - ecs_id_t *storage_ids = ecs_vector_first(table->storage_type, ecs_id_t); - int32_t s, storage_ids_count = ecs_vector_count(table->storage_type); +static +void table_diff_free( + ecs_table_diff_t *diff) +{ + ecs_os_free(diff->added.array); + ecs_os_free(diff->removed.array); + ecs_os_free(diff->on_set.array); + ecs_os_free(diff->un_set.array); + ecs_os_free(diff); +} - if (!ids_count) { - table->storage_map = NULL; - return; +static +ecs_graph_edge_t* graph_edge_new( + ecs_world_t *world) +{ + ecs_graph_edge_t *result = (ecs_graph_edge_t*)world->store.first_free; + if (result) { + world->store.first_free = result->hdr.next; + ecs_os_zeromem(result); + } else { + result = ecs_os_calloc_t(ecs_graph_edge_t); } + return result; +} - table->storage_map = ecs_os_malloc_n( - int32_t, ids_count + storage_ids_count); - - int32_t *t2s = table->storage_map; - int32_t *s2t = &table->storage_map[ids_count]; - - for (s = 0, t = 0; (t < ids_count) && (s < storage_ids_count); ) { - ecs_id_t id = ids[t]; - ecs_id_t storage_id = storage_ids[s]; - - if (id == storage_id) { - t2s[t] = s; - s2t[s] = t; - } else { - t2s[t] = -1; - } - - /* Ids can never get ahead of storage id, as ids are a superset of the - * storage ids */ - ecs_assert(id <= storage_id, ECS_INTERNAL_ERROR, NULL); +static +void graph_edge_free( + ecs_world_t *world, + ecs_graph_edge_t *edge) +{ + if (world->is_fini) { + ecs_os_free(edge); + } else { + edge->hdr.next = world->store.first_free; + world->store.first_free = &edge->hdr; + } +} - t += (id <= storage_id); - s += (id == storage_id); +static +ecs_graph_edge_t* ensure_hi_edge( + ecs_world_t *world, + ecs_graph_edges_t *edges, + ecs_id_t id) +{ + if (!ecs_map_is_initialized(&edges->hi)) { + ecs_map_init(&edges->hi, ecs_graph_edge_t*, 1); } - /* Storage ids is always a subset of ids, so all should be iterated */ - ecs_assert(s == storage_ids_count, ECS_INTERNAL_ERROR, NULL); + ecs_graph_edge_t **ep = ecs_map_ensure(&edges->hi, ecs_graph_edge_t*, id); + ecs_graph_edge_t *edge = ep[0]; + if (edge) { + return edge; + } - /* Initialize remainder of type -> storage_type map */ - for (; (t < ids_count); t ++) { - t2s[t] = -1; + if (id < ECS_HI_COMPONENT_ID) { + edge = &edges->lo[id]; + } else { + edge = graph_edge_new(world); } + + ep[0] = edge; + return edge; } static -void init_storage_table( +ecs_graph_edge_t* ensure_edge( ecs_world_t *world, - ecs_table_t *table) + ecs_graph_edges_t *edges, + ecs_id_t id) { - if (table->storage_table) { - return; - } + ecs_graph_edge_t *edge; - int32_t i, count = ecs_vector_count(table->type); - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - ecs_ids_t storage_ids = { - .array = ecs_os_alloca_n(ecs_id_t, count) - }; + if (id < ECS_HI_COMPONENT_ID) { + if (!edges->lo) { + edges->lo = ecs_os_calloc_n(ecs_graph_edge_t, ECS_HI_COMPONENT_ID); + } + edge = &edges->lo[id]; + } else { + if (!ecs_map_is_initialized(&edges->hi)) { + ecs_map_init(&edges->hi, ecs_graph_edge_t*, 1); + } + edge = ensure_hi_edge(world, edges, id); + } - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; + return edge; +} - if ((id == ecs_id(EcsComponent)) || - (ECS_PAIR_FIRST(id) == ecs_id(EcsIdentifier))) - { - storage_ids.array[storage_ids.count ++] = id; - continue; - } +static +void disconnect_edge( + ecs_world_t *world, + ecs_id_t id, + ecs_graph_edge_t *edge) +{ + ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->id == id, ECS_INTERNAL_ERROR, NULL); + (void)id; - const EcsComponent *comp = flecs_component_from_id(world, id); - if (!comp || !comp->size) { - continue; - } + /* Remove backref from destination table */ + ecs_graph_edge_hdr_t *next = edge->hdr.next; + ecs_graph_edge_hdr_t *prev = edge->hdr.prev; - storage_ids.array[storage_ids.count ++] = id; + if (next) { + next->prev = prev; } - - if (storage_ids.count && storage_ids.count != count) { - table->storage_table = flecs_table_find_or_create(world, &storage_ids); - table->storage_type = table->storage_table->type; - table->storage_table->refcount ++; - ecs_assert(table->storage_table != NULL, ECS_INTERNAL_ERROR, NULL); - } else if (storage_ids.count) { - table->storage_table = table; - table->storage_type = table->storage_table->type; - ecs_assert(table->storage_table != NULL, ECS_INTERNAL_ERROR, NULL); + if (prev) { + prev->next = next; } - if (!table->storage_map) { - init_storage_map(table); + /* Remove data associated with edge */ + ecs_table_diff_t *diff = edge->diff; + if (diff && diff != &ecs_table_edge_is_component) { + table_diff_free(diff); + } + + /* If edge id is low, clear it from fast lookup array */ + if (id < ECS_HI_COMPONENT_ID) { + edge->from = NULL; + } else { + graph_edge_free(world, edge); } } static -ecs_flags32_t get_component_action_flags( - const ecs_type_info_t *c_info) +void remove_edge( + ecs_world_t *world, + ecs_graph_edges_t *edges, + ecs_id_t id, + ecs_graph_edge_t *edge) { - ecs_flags32_t flags = 0; + ecs_assert(edges != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ecs_map_is_initialized(&edges->hi), ECS_INTERNAL_ERROR, NULL); + disconnect_edge(world, id, edge); + ecs_map_remove(&edges->hi, id); +} - if (c_info->lifecycle.ctor) { - flags |= EcsTableHasCtors; +static +void init_edges( + ecs_graph_edges_t *edges) +{ + edges->lo = NULL; + ecs_os_zeromem(&edges->hi); +} + +static +void init_node( + ecs_graph_node_t *node) +{ + init_edges(&node->add); + init_edges(&node->remove); +} + +typedef struct { + int32_t first; + int32_t count; +} id_first_count_t; + +static +void set_trigger_flags_for_id( + ecs_world_t *world, + ecs_table_t *table, + ecs_id_t id) +{ + /* Set flags if triggers are registered for table */ + if (flecs_check_triggers_for_event(world, id, EcsOnAdd)) { + table->flags |= EcsTableHasOnAdd; } - if (c_info->lifecycle.dtor) { - flags |= EcsTableHasDtors; + if (flecs_check_triggers_for_event(world, id, EcsOnRemove)) { + table->flags |= EcsTableHasOnRemove; } - if (c_info->lifecycle.on_remove) { - flags |= EcsTableHasDtors; + if (flecs_check_triggers_for_event(world, id, EcsOnSet)) { + table->flags |= EcsTableHasOnSet; } - if (c_info->lifecycle.copy) { - flags |= EcsTableHasCopy; + if (flecs_check_triggers_for_event(world, id, EcsUnSet)) { + table->flags |= EcsTableHasUnSet; } - if (c_info->lifecycle.move) { - flags |= EcsTableHasMove; - } +} - return flags; +static +void register_table_for_id( + ecs_world_t *world, + ecs_table_t *table, + ecs_id_t id, + int32_t column, + int32_t count, + ecs_table_record_t *tr) +{ + id = ecs_strip_generation(id); + + ecs_id_record_t *idr = flecs_ensure_id_record(world, id); + ecs_table_cache_insert(&idr->cache, table, &tr->hdr); + tr->column = column; + tr->count = count; + tr->id = id; + set_trigger_flags_for_id(world, table, id); + ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL); } static -void init_type_info( +void flecs_table_records_register( ecs_world_t *world, ecs_table_t *table) { - ecs_type_t type = table->storage_type; - if (!type) { + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); + int32_t count = ecs_vector_count(table->type); + + if (!count) { return; } - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t i, count = ecs_vector_count(type); - - table->type_info = ecs_os_calloc_n(ecs_type_info_t*, count); + /* Count number of unique ids, pairs, relations and objects so we can figure + * out how many table records are needed for this table. */ + int32_t id_count = 0, pair_count = 0, type_flag_count = 0; + int32_t first_id = -1, first_pair = -1; + ecs_map_t relations = ECS_MAP_INIT(0), objects = ECS_MAP_INIT(0); + bool has_childof = false; + int32_t i; for (i = 0; i < count; i ++) { ecs_id_t id = ids[i]; - ecs_entity_t t = ecs_get_typeid(world, id); + ecs_entity_t rel = 0, obj = 0; - const ecs_type_info_t *ti = flecs_get_type_info(world, t); - if (ti) { - table->flags |= get_component_action_flags(ti); - } + if (ECS_HAS_ROLE(id, PAIR)) { + id_first_count_t *r; - table->type_info[i] = (ecs_type_info_t*)ti; - } -} + rel = ECS_PAIR_FIRST(id); + obj = ECS_PAIR_SECOND(id); -void flecs_table_init_data( - ecs_world_t *world, - ecs_table_t *table) -{ - init_storage_table(world, table); - init_type_info(world, table); + if (0 == pair_count ++) { + first_pair = i; + } - int32_t sw_count = table->sw_column_count = switch_column_count(table); - int32_t bs_count = table->bs_column_count = bitset_column_count(table); + if (rel == EcsChildOf) { + has_childof = true; + } - ecs_data_t *storage = &table->storage; - ecs_type_t type = table->storage_type; + if (!ecs_map_is_initialized(&relations)) { + ecs_map_init(&relations, id_first_count_t, count); + ecs_map_init(&objects, id_first_count_t, count); + } - int32_t i, count = ecs_vector_count(type); + r = ecs_map_ensure(&relations, id_first_count_t, rel); + if ((++r->count) == 1) { + r->first = i; + } - /* Root tables don't have columns */ - if (!count && !sw_count && !bs_count) { - storage->columns = NULL; + r = ecs_map_ensure(&objects, id_first_count_t, obj); + if ((++r->count) == 1) { + r->first = i; + } + } else { + rel = id & ECS_COMPONENT_MASK; + if (rel != id) { + type_flag_count ++; + } + + if (0 == id_count ++) { + first_id = i; + } + } } - if (count) { - ecs_entity_t *ids = ecs_vector_first(type, ecs_entity_t); - storage->columns = ecs_os_calloc_n(ecs_column_t, count); - - for (i = 0; i < count; i ++) { - ecs_entity_t id = ids[i]; - - /* Bootstrap components */ - if (id == ecs_id(EcsComponent)) { - storage->columns[i].size = ECS_SIZEOF(EcsComponent); - storage->columns[i].alignment = ECS_ALIGNOF(EcsComponent); - continue; - } else if (ECS_PAIR_FIRST(id) == ecs_id(EcsIdentifier)) { - storage->columns[i].size = ECS_SIZEOF(EcsIdentifier); - storage->columns[i].alignment = ECS_ALIGNOF(EcsIdentifier); - continue; - } - - const EcsComponent *component = flecs_component_from_id(world, id); - ecs_assert(component != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(component->size != 0, ECS_INTERNAL_ERROR, NULL); + int32_t record_count = count + type_flag_count + (id_count != 0) + + (pair_count != 0) + ecs_map_count(&relations) + ecs_map_count(&objects) + + 1 /* for any */; + int32_t r = 0; - storage->columns[i].size = flecs_itoi16(component->size); - storage->columns[i].alignment = flecs_itoi16(component->alignment); - } + if (!has_childof) { + record_count ++; } - if (sw_count) { - ecs_entity_t *ids = ecs_vector_first(table->type, ecs_entity_t); - int32_t sw_offset = table->sw_column_offset; - storage->sw_columns = ecs_os_calloc_n(ecs_sw_column_t, sw_count); - - for (i = 0; i < sw_count; i ++) { - ecs_entity_t e = ids[i + sw_offset]; - ecs_assert(ECS_HAS_ROLE(e, SWITCH), ECS_INTERNAL_ERROR, NULL); - e = e & ECS_COMPONENT_MASK; - const EcsType *type_ptr = ecs_get(world, e, EcsType); - ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_table_t *sw_table = type_ptr->normalized; - ecs_type_t sw_type = sw_table->type; - - ecs_entity_t *sw_array = ecs_vector_first(sw_type, ecs_entity_t); - int32_t sw_array_count = ecs_vector_count(sw_type); - - ecs_switch_t *sw = flecs_switch_new( - sw_array[0], - sw_array[sw_array_count - 1], - 0); + table->records = ecs_os_calloc_n(ecs_table_record_t, record_count); + table->record_count = record_count; - storage->sw_columns[i].data = sw; - storage->sw_columns[i].type = sw_table; + /* First initialize records for regular (non-wildcard) ids */ + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + register_table_for_id(world, table, id, i, 1, &table->records[r]); + r ++; + + ecs_entity_t role = id & ECS_ROLE_MASK; + if (role && role != ECS_PAIR) { + id &= ECS_COMPONENT_MASK; + id = ecs_pair(id, EcsWildcard); + register_table_for_id(world, table, id, i, 1, &table->records[r]); + r ++; } } - if (bs_count) { - storage->bs_columns = ecs_os_calloc_n(ecs_bs_column_t, bs_count); - for (i = 0; i < bs_count; i ++) { - flecs_bitset_init(&storage->bs_columns[i].data); - } + /* Initialize records for relation wildcards */ + ecs_map_iter_t mit = ecs_map_iter(&relations); + id_first_count_t *elem; + uint64_t key; + while ((elem = ecs_map_next(&mit, id_first_count_t, &key))) { + ecs_id_t id = ecs_pair(key, EcsWildcard); + register_table_for_id(world, table, id, elem->first, elem->count, + &table->records[r]); + r ++; } -} - -static -void notify_trigger( - ecs_world_t *world, - ecs_table_t *table, - ecs_entity_t event) -{ - (void)world; - if (event == EcsOnAdd) { - table->flags |= EcsTableHasOnAdd; - } else if (event == EcsOnRemove) { - table->flags |= EcsTableHasOnRemove; - } else if (event == EcsOnSet) { - table->flags |= EcsTableHasOnSet; - } else if (event == EcsUnSet) { - table->flags |= EcsTableHasUnSet; + /* Initialize records for object wildcards */ + mit = ecs_map_iter(&objects); + while ((elem = ecs_map_next(&mit, id_first_count_t, &key))) { + ecs_id_t id = ecs_pair(EcsWildcard, key); + register_table_for_id(world, table, id, elem->first, elem->count, + &table->records[r]); + r ++; } -} -static -void run_on_remove( - ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data) -{ - int32_t count = ecs_vector_count(data->entities); + /* Initialize records for all wildcards ids */ + if (id_count) { + register_table_for_id(world, table, EcsWildcard, + first_id, id_count, &table->records[r]); + r ++; + } + if (pair_count) { + register_table_for_id(world, table, ecs_pair(EcsWildcard, EcsWildcard), + first_pair, pair_count, &table->records[r]); + r ++; + } if (count) { - ecs_ids_t removed = { - .array = ecs_vector_first(table->type, ecs_id_t), - .count = ecs_vector_count(table->type) - }; - - ecs_table_diff_t diff = { - .removed = removed, - .un_set = removed - }; - - flecs_notify_on_remove(world, table, NULL, 0, count, &diff); + register_table_for_id(world, table, EcsAny, 0, 1, &table->records[r]); + r ++; } -} - -/* -- Private functions -- */ -static -void ctor_component( - ecs_world_t *world, - ecs_type_info_t *ti, - ecs_column_t *column, - ecs_entity_t *entities, - int32_t row, - int32_t count) -{ - /* A new component is constructed */ - ecs_xtor_t ctor; - if (ti && (ctor = ti->lifecycle.ctor)) { - int16_t size = column->size; - int16_t alignment = column->alignment; - void *ptr = ecs_vector_get_t(column->data, size, alignment, row); - ctor(world, entities, ptr, count, ti); + /* Insert into (ChildOf, 0) (root) if table doesn't have childof */ + if (!has_childof && count) { + register_table_for_id(world, table, ecs_pair(EcsChildOf, 0), + 0, 1, &table->records[r]); } -} - -static -void on_remove_component( - ecs_world_t *world, - ecs_table_t *table, - ecs_iter_action_t on_remove, - void *ptr, - ecs_size_t size, - ecs_entity_t *entities, - ecs_id_t id, - int32_t count, - void *ctx) -{ - ecs_iter_t it = { .term_count = 1 }; - it.entities = entities; - flecs_iter_init(&it); - it.world = world; - it.real_world = world; - it.table = table; - it.type = table->type; - it.ptrs[0] = ptr; - it.sizes[0] = size; - it.ids[0] = id; - it.event = EcsOnRemove; - it.event_id = id; - it.ctx = ctx; - it.count = count; - on_remove(&it); + ecs_map_fini(&relations); + ecs_map_fini(&objects); } -static -void dtor_component( +void flecs_table_records_unregister( ecs_world_t *world, - ecs_table_t *table, - ecs_type_info_t *ti, - ecs_column_t *column, - ecs_entity_t *entities, - ecs_id_t id, - int32_t row, - int32_t count, - bool is_remove) + ecs_table_t *table) { - if (!count) { - return; - } + int32_t i, count = table->record_count; + for (i = 0; i < count; i ++) { + ecs_table_record_t *tr = &table->records[i]; + ecs_table_cache_t *cache = tr->hdr.cache; + ecs_id_t id = tr->id; - if (!ti) { - return; - } + ecs_assert(tr->hdr.cache == cache, ECS_INTERNAL_ERROR, NULL); + ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL); + ecs_assert(flecs_get_id_record(world, id) == (ecs_id_record_t*)cache, + ECS_INTERNAL_ERROR, NULL); - ecs_iter_action_t on_remove = 0; - if (is_remove) { - on_remove = ti->lifecycle.on_remove; - } + ecs_table_cache_remove(cache, table, &tr->hdr); - ecs_xtor_t dtor = ti->lifecycle.dtor; - if (!on_remove && !dtor) { - return; + if (ecs_table_cache_is_empty(cache)) { + ecs_id_record_t *idr = (ecs_id_record_t*)cache; + flecs_remove_id_record(world, id, idr); + } } + + ecs_os_free(table->records); +} - void *ctx = ti->lifecycle.ctx; - int16_t size = column->size; - int16_t alignment = column->alignment; - ecs_entity_t *entity_elem = &entities[row]; - - ecs_assert(column->data != NULL, ECS_INTERNAL_ERROR, NULL); - void *ptr = ecs_vector_get_t(column->data, size, alignment, row); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); +bool flecs_table_records_update_empty( + ecs_table_t *table) +{ + bool result = false; + bool is_empty = ecs_table_count(table) == 0; - if (on_remove) { - on_remove_component(world, table, on_remove, ptr, size, - entity_elem, id, count, ctx); + int32_t i, count = table->record_count; + for (i = 0; i < count; i ++) { + ecs_table_record_t *tr = &table->records[i]; + ecs_table_cache_t *cache = tr->hdr.cache; + result |= ecs_table_cache_set_empty(cache, table, is_empty); } - if (dtor) { - dtor(world, entity_elem, ptr, count, ti); - } + return result; } static -void dtor_all_components( +void init_flags( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - int32_t row, - int32_t count, - bool update_entity_index, - bool is_delete) + ecs_table_t *table) { - /* Can't delete and not update the entity index */ - ecs_assert(!is_delete || update_entity_index, ECS_INTERNAL_ERROR, NULL); + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); + int32_t count = ecs_vector_count(table->type); - ecs_id_t *ids = ecs_vector_first(table->storage_type, ecs_id_t); - ecs_record_t **records = ecs_vector_first(data->record_ptrs, ecs_record_t*); - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - int32_t i, c, end = row + count; - int32_t column_count = ecs_vector_count(table->storage_type); + /* Iterate components to initialize table flags */ + int32_t i; + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; - (void)records; + /* As we're iterating over the table components, also set the table + * flags. These allow us to quickly determine if the table contains + * data that needs to be handled in a special way, like prefabs or + * containers */ + if (id <= EcsLastInternalComponentId) { + table->flags |= EcsTableHasBuiltins; + } - /* If table has components with destructors, iterate component columns */ - if (table->flags & EcsTableHasDtors) { - /* Prevent the storage from getting modified while deleting */ - ecs_defer_begin(world); + if (id == EcsModule) { + table->flags |= EcsTableHasBuiltins; + table->flags |= EcsTableHasModule; + } - /* Throw up a lock just to be sure */ - table->lock = true; + if (id == EcsPrefab) { + table->flags |= EcsTableIsPrefab; + } - /* Run on_remove callbacks in bulk for improved performance */ - for (c = 0; c < column_count; c++) { - ecs_column_t *column = &data->columns[c]; - ecs_type_info_t *cdata = table->type_info[c]; - if (!cdata) { - continue; - } + /* If table contains disabled entities, mark it as disabled */ + if (id == EcsDisabled) { + table->flags |= EcsTableIsDisabled; + } - ecs_iter_action_t on_remove = cdata->lifecycle.on_remove; - if (on_remove) { - ecs_size_t size = column->size; - ecs_size_t align = column->alignment; - void *ptr = ecs_vector_get_t(column->data, size, align, row); - on_remove_component(world, table, on_remove, ptr, column->size, - &entities[row], ids[c], count, cdata->lifecycle.ctx); - } + /* Does table have exclusive or columns */ + if (ECS_HAS_ROLE(id, XOR)) { + table->flags |= EcsTableHasXor; } - /* Iterate entities first, then components. This ensures that only one - * entity is invalidated at a time, which ensures that destructors can - * safely access other entities. */ - for (i = row; i < end; i ++) { - for (c = 0; c < column_count; c++) { - ecs_column_t *column = &data->columns[c]; - dtor_component(world, table, table->type_info[c], column, - entities, ids[c], i, 1, false); - } + /* Does the table have pairs */ + if (ECS_HAS_ROLE(id, PAIR)) { + table->flags |= EcsTableHasPairs; + } - /* Update entity index after invoking destructors so that entity can - * be safely used in destructor callbacks. */ - if (update_entity_index) { - ecs_entity_t e = entities[i]; - ecs_assert(!e || ecs_is_valid(world, e), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i] == ecs_eis_get(world, e), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i]->table == table, - ECS_INTERNAL_ERROR, NULL); + /* Does table have IsA relations */ + if (ECS_HAS_RELATION(id, EcsIsA)) { + table->flags |= EcsTableHasIsA; + } - if (is_delete) { - ecs_eis_delete(world, e); - ecs_assert(ecs_is_valid(world, e) == false, - ECS_INTERNAL_ERROR, NULL); - } else { - // If this is not a delete, clear the entity index record - records[i]->table = NULL; - records[i]->row = 0; - } - } else { - /* This should only happen in rare cases, such as when the data - * cleaned up is not part of the world (like with snapshots) */ - } + /* Does table have ChildOf relations */ + if (ECS_HAS_RELATION(id, EcsChildOf)) { + table->flags |= EcsTableHasChildOf; } - table->lock = false; - - ecs_defer_end(world); + /* Does table have switch columns */ + if (ECS_HAS_ROLE(id, SWITCH)) { + table->flags |= EcsTableHasSwitch; + } - /* If table does not have destructors, just update entity index */ - } else if (update_entity_index) { - if (is_delete) { - for (i = row; i < end; i ++) { - ecs_entity_t e = entities[i]; - ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i] == ecs_eis_get(world, e), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i]->table == table, - ECS_INTERNAL_ERROR, NULL); + /* Does table support component disabling */ + if (ECS_HAS_ROLE(id, DISABLED)) { + table->flags |= EcsTableHasDisabled; + } - ecs_eis_delete(world, e); - ecs_assert(!ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); - } - } else { - for (i = row; i < end; i ++) { - ecs_entity_t e = entities[i]; - ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i] == ecs_eis_get(world, e), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!e || records[i]->table == table, - ECS_INTERNAL_ERROR, NULL); - records[i]->table = NULL; - records[i]->row = 0; - (void)e; + if (ECS_HAS_RELATION(id, EcsChildOf)) { + ecs_poly_assert(world, ecs_world_t); + ecs_entity_t obj = ecs_pair_second(world, id); + ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); + + if (obj == EcsFlecs || obj == EcsFlecsCore || + ecs_has_id(world, obj, EcsModule)) + { + /* If table contains entities that are inside one of the builtin + * modules, it contains builtin entities */ + table->flags |= EcsTableHasBuiltins; + table->flags |= EcsTableHasModule; } } } } static -void fini_data( +void init_table( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - bool do_on_remove, - bool update_entity_index, - bool is_delete, - bool deactivate) + ecs_table_t *table) { - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - - if (!data) { - return; - } + table->type_info = NULL; + table->flags = 0; + table->dirty_state = NULL; + table->alloc_count = 0; + table->lock = 0; + table->refcount = 1; - ecs_flags32_t flags = table->flags; + /* Ensure the component ids for the table exist */ + ensure_columns(world, table); - if (do_on_remove && (flags & EcsTableHasOnRemove)) { - run_on_remove(world, table, data); - } + init_node(&table->node); + init_flags(world, table); + flecs_table_records_register(world, table); + flecs_table_init_data(world, table); +} - int32_t count = flecs_table_data_count(data); - if (count) { - dtor_all_components(world, table, data, 0, count, - update_entity_index, is_delete); - } +static +ecs_table_t *create_table( + ecs_world_t *world, + ecs_vector_t *type, + flecs_hashmap_result_t table_elem) +{ + ecs_table_t *result = flecs_sparse_add(&world->store.tables, ecs_table_t); + ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); - /* Sanity check */ - ecs_assert(ecs_vector_count(data->record_ptrs) == - ecs_vector_count(data->entities), ECS_INTERNAL_ERROR, NULL); + ecs_vector_reclaim(&type, ecs_id_t); - ecs_column_t *columns = data->columns; - if (columns) { - int32_t c, column_count = ecs_vector_count(table->storage_type); - for (c = 0; c < column_count; c ++) { - /* Sanity check */ - ecs_assert(!columns[c].data || (ecs_vector_count(columns[c].data) == - ecs_vector_count(data->entities)), ECS_INTERNAL_ERROR, NULL); + result->id = flecs_sparse_last_id(&world->store.tables); + result->type = type; - ecs_vector_free(columns[c].data); - } - ecs_os_free(columns); - data->columns = NULL; - } + init_table(world, result); - ecs_sw_column_t *sw_columns = data->sw_columns; - if (sw_columns) { - int32_t c, column_count = table->sw_column_count; - for (c = 0; c < column_count; c ++) { - flecs_switch_free(sw_columns[c].data); - } - ecs_os_free(sw_columns); - data->sw_columns = NULL; + if (ecs_should_log_2()) { + char *expr = ecs_type_str(world, result->type); + ecs_dbg_2( + "#[green]table#[normal] [%s] #[green]created#[normal] with id %d", + expr, result->id); + ecs_os_free(expr); } - ecs_bs_column_t *bs_columns = data->bs_columns; - if (bs_columns) { - int32_t c, column_count = table->bs_column_count; - for (c = 0; c < column_count; c ++) { - flecs_bitset_fini(&bs_columns[c].data); - } - ecs_os_free(bs_columns); - data->bs_columns = NULL; - } + ecs_log_push_2(); - ecs_vector_free(data->entities); - ecs_vector_free(data->record_ptrs); + /* Store table in table hashmap */ + *(ecs_table_t**)table_elem.value = result; - data->entities = NULL; - data->record_ptrs = NULL; + /* Set keyvalue to one that has the same lifecycle as the table */ + ecs_ids_t key = { + .array = ecs_vector_first(result->type, ecs_id_t), + .count = ecs_vector_count(result->type) + }; + *(ecs_ids_t*)table_elem.key = key; - if (deactivate && count) { - flecs_table_set_empty(world, table); - } -} + flecs_notify_queries(world, &(ecs_query_event_t) { + .kind = EcsQueryTableMatch, + .table = result + }); -/* Cleanup, no OnRemove, don't update entity index, don't deactivate table */ -void flecs_table_clear_data( - ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data) -{ - fini_data(world, table, data, false, false, false, false); -} + ecs_log_pop_2(); -/* Cleanup, no OnRemove, clear entity index, deactivate table */ -void flecs_table_clear_entities_silent( - ecs_world_t *world, - ecs_table_t *table) -{ - fini_data(world, table, &table->storage, false, true, false, true); + return result; } -/* Cleanup, run OnRemove, clear entity index, deactivate table */ -void flecs_table_clear_entities( +static +ecs_table_t* find_or_create( ecs_world_t *world, - ecs_table_t *table) -{ - fini_data(world, table, &table->storage, true, true, false, true); -} + const ecs_ids_t *ids, + ecs_vector_t *type) +{ + ecs_poly_assert(world, ecs_world_t); -/* Cleanup, run OnRemove, delete from entity index, deactivate table */ -void flecs_table_delete_entities( - ecs_world_t *world, - ecs_table_t *table) -{ - fini_data(world, table, &table->storage, true, true, true, true); -} + /* Make sure array is ordered and does not contain duplicates */ + int32_t id_count = ids->count; -/* Unset all components in table. This function is called before a table is - * deleted, and invokes all UnSet handlers, if any */ -void flecs_table_remove_actions( - ecs_world_t *world, - ecs_table_t *table) -{ - (void)world; - run_on_remove(world, table, &table->storage); + if (!id_count) { + return &world->store.root; + } + + ecs_table_t *table; + flecs_hashmap_result_t elem = flecs_hashmap_ensure( + &world->store.table_map, ids, ecs_table_t*); + if ((table = *(ecs_table_t**)elem.value)) { + if (type) { + ecs_vector_free(type); + } + return table; + } + + if (!type) { + type = ids_to_vector(ids); + } + + /* If we get here, table needs to be created which is only allowed when the + * application is not currently in progress */ + ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); + + /* If we get here, the table has not been found, so create it. */ + return create_table(world, type, elem); } -/* Free table resources. */ -void flecs_table_free( - ecs_world_t *world, - ecs_table_t *table) +static +void add_id_to_ids( + ecs_vector_t **idv, + ecs_entity_t add, + ecs_entity_t r_exclusive) { - bool is_root = table == &world->store.root; - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_assert(is_root || table->id != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(is_root || flecs_sparse_is_alive(&world->store.tables, table->id), - ECS_INTERNAL_ERROR, NULL); - (void)world; + int32_t i, count = ecs_vector_count(idv[0]); + ecs_id_t *array = ecs_vector_first(idv[0], ecs_id_t); - ecs_assert(table->refcount == 0, ECS_INTERNAL_ERROR, NULL); + for (i = 0; i < count; i ++) { + ecs_id_t e = array[i]; - if (!is_root) { - flecs_notify_queries( - world, &(ecs_query_event_t){ - .kind = EcsQueryTableUnmatch, - .table = table - }); + if (e == add) { + return; + } + + if (r_exclusive && ECS_HAS_ROLE(e, PAIR)) { + if (ECS_PAIR_FIRST(e) == r_exclusive) { + array[i] = add; /* Replace */ + return; + } + } + + if (e >= add) { + if (e != add) { + ecs_id_t *ptr = ecs_vector_insert_at(idv, ecs_id_t, i); + ptr[0] = add; + return; + } + } } - if (ecs_should_log_2()) { - char *expr = ecs_type_str(world, table->type); - ecs_dbg_2( - "#[green]table#[normal] [%s] #[red]deleted#[normal] with id %d", - expr, table->id); - ecs_os_free(expr); + ecs_id_t *ptr = ecs_vector_add(idv, ecs_id_t); + ptr[0] = add; +} + +static +void remove_id_from_ids( + ecs_type_t type, + ecs_id_t remove, + ecs_ids_t *out) +{ + int32_t count = ecs_vector_count(type); + ecs_id_t *array = ecs_vector_first(type, ecs_id_t); + int32_t i, el = 0; + + if (ecs_id_is_wildcard(remove)) { + for (i = 0; i < count; i ++) { + ecs_id_t id = array[i]; + if (!ecs_id_match(id, remove)) { + out->array[el ++] = id; + ecs_assert(el <= count, ECS_INTERNAL_ERROR, NULL); + } + } + } else { + for (i = 0; i < count; i ++) { + ecs_id_t id = array[i]; + if (id != remove) { + out->array[el ++] = id; + ecs_assert(el <= count, ECS_INTERNAL_ERROR, NULL); + } + } } - /* Cleanup data, no OnRemove, delete from entity index, don't deactivate */ - fini_data(world, table, &table->storage, false, true, true, false); + out->count = el; +} - flecs_table_clear_edges(world, table); +int32_t flecs_table_switch_from_case( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_entity_t add) +{ + ecs_type_t type = table->type; + ecs_entity_t *array = ecs_vector_first(type, ecs_entity_t); - if (!is_root) { - ecs_ids_t ids = { - .array = ecs_vector_first(table->type, ecs_id_t), - .count = ecs_vector_count(table->type) - }; + int32_t i, count = table->sw_column_count; + ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL); - flecs_hashmap_remove(&world->store.table_map, &ids, ecs_table_t*); - } + add = add & ECS_COMPONENT_MASK; - ecs_os_free(table->dirty_state); - ecs_os_free(table->storage_map); + ecs_sw_column_t *sw_columns = NULL; - if (table->type_info) { - ecs_os_free(table->type_info); - } + if ((sw_columns = table->storage.sw_columns)) { + /* Fast path, we can get the switch type from the column data */ + for (i = 0; i < count; i ++) { + ecs_table_t *sw_type = sw_columns[i].type; + if (ecs_search(world, sw_type, add, 0) != -1) { + return i; + } + } + } else { + /* Slow path, table is empty, so we'll have to get the switch types by + * actually inspecting the switch type entities. */ + for (i = 0; i < count; i ++) { + ecs_entity_t e = array[i + table->sw_column_offset]; + ecs_assert(ECS_HAS_ROLE(e, SWITCH), ECS_INTERNAL_ERROR, NULL); + e = e & ECS_COMPONENT_MASK; - flecs_table_records_unregister(world, table); + const EcsType *type_ptr = ecs_get(world, e, EcsType); + ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); - if (table->storage_table && table->storage_table != table) { - flecs_table_release(world, table->storage_table); + if (ecs_search(world, type_ptr->normalized, add, 0) != -1) { + return i; + } + } } - if (!world->is_fini) { - ecs_assert(!is_root, ECS_INTERNAL_ERROR, NULL); - flecs_table_free_type(table); - flecs_sparse_remove(&world->store.tables, table->id); - } + /* If a table was not found, this is an invalid switch case */ + ecs_abort(ECS_TYPE_INVALID_CASE, NULL); + + return -1; } -void flecs_table_claim( - ecs_world_t *world, - ecs_table_t *table) +static +void ids_append( + ecs_ids_t *ids, + ecs_id_t id) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table->refcount > 0, ECS_INTERNAL_ERROR, NULL); - table->refcount ++; - (void)world; + ids->array = ecs_os_realloc_n(ids->array, ecs_id_t, ids->count + 1); + ids->array[ids->count ++] = id; } -bool flecs_table_release( +static +void diff_insert_isa( ecs_world_t *world, - ecs_table_t *table) + ecs_table_t *table, + ecs_table_diff_t *base_diff, + ecs_ids_t *append_to, + ecs_ids_t *append_from, + ecs_id_t add) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table->refcount > 0, ECS_INTERNAL_ERROR, NULL); - - if (--table->refcount == 0) { - flecs_table_free(world, table); - return true; + ecs_entity_t base = ecs_pair_second(world, add); + ecs_table_t *base_table = ecs_get_table(world, base); + if (!base_table) { + return; } - - return false; -} -/* Free table type. Do this separately from freeing the table as types can be - * in use by application destructors. */ -void flecs_table_free_type( - ecs_table_t *table) -{ - ecs_vector_free((ecs_vector_t*)table->type); + ecs_type_t base_type = base_table->type, type = table->type; + ecs_table_t *table_wo_base = base_table; + + /* If the table does not have a component from the base, it should + * trigger an OnSet */ + ecs_id_t *ids = ecs_vector_first(base_type, ecs_id_t); + int32_t j, i, count = ecs_vector_count(base_type); + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + + if (ECS_HAS_RELATION(id, EcsIsA)) { + /* The base has an IsA relation. Find table without the base, which + * gives us the list of ids the current base inherits and doesn't + * override. This saves us from having to recursively check for each + * base in the hierarchy whether the component is overridden. */ + table_wo_base = flecs_table_traverse_remove( + world, table_wo_base, &id, base_diff); + + /* Because we removed, the ids are stored in un_set vs. on_set */ + for (j = 0; j < append_from->count; j ++) { + ecs_id_t base_id = append_from->array[j]; + /* We still have to make sure the id isn't overridden by the + * current table */ + if (!type || ecs_search(world, table, base_id, NULL) == -1) { + ids_append(append_to, base_id); + } + } + + continue; + } + + /* Identifiers are not inherited */ + if (ECS_HAS_RELATION(id, ecs_id(EcsIdentifier))) { + continue; + } + + if (!ecs_get_typeid(world, id)) { + continue; + } + + if (!type || ecs_search(world, table, id, NULL) == -1) { + ids_append(append_to, id); + } + } } -/* Reset a table to its initial state. */ -void flecs_table_reset( +static +void diff_insert_added_isa( ecs_world_t *world, - ecs_table_t *table) + ecs_table_t *table, + ecs_table_diff_t *diff, + ecs_id_t id) { - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - flecs_table_clear_edges(world, table); + ecs_table_diff_t base_diff; + diff_insert_isa(world, table, &base_diff, &diff->on_set, + &base_diff.un_set, id); } static -void mark_table_dirty( +void diff_insert_removed_isa( ecs_world_t *world, ecs_table_t *table, - int32_t index) + ecs_table_diff_t *diff, + ecs_id_t id) { - (void)world; - if (table->dirty_state) { - table->dirty_state[index] ++; - } + ecs_table_diff_t base_diff; + diff_insert_isa(world, table, &base_diff, &diff->un_set, + &base_diff.un_set, id); } -void flecs_table_mark_dirty( +static +void diff_insert_added( ecs_world_t *world, ecs_table_t *table, - ecs_entity_t component) + ecs_table_diff_t *diff, + ecs_id_t id) { - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + diff->added.array[diff->added.count ++] = id; - if (table->dirty_state) { - int32_t index = ecs_search(world, table->storage_table, component, 0); - ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL); - table->dirty_state[index + 1] ++; + if (ECS_HAS_RELATION(id, EcsIsA)) { + diff_insert_added_isa(world, table, diff, id); } } static -void move_switch_columns( - ecs_table_t *new_table, - ecs_data_t *new_data, - int32_t new_index, - ecs_table_t *old_table, - ecs_data_t *old_data, - int32_t old_index, - int32_t count, - bool clear) +void diff_insert_removed( + ecs_world_t *world, + ecs_table_t *table, + ecs_table_diff_t *diff, + ecs_id_t id) { - int32_t i_old = 0, old_column_count = old_table->sw_column_count; - int32_t i_new = 0, new_column_count = new_table->sw_column_count; + diff->removed.array[diff->removed.count ++] = id; - if (!old_column_count && !new_column_count) { + if (ECS_HAS_RELATION(id, EcsIsA)) { + /* Removing an IsA relation also "removes" all components from the + * instance. Any id from base that's not overridden should be UnSet. */ + diff_insert_removed_isa(world, table, diff, id); return; } - ecs_sw_column_t *old_columns = old_data->sw_columns; - ecs_sw_column_t *new_columns = new_data->sw_columns; - - ecs_type_t new_type = new_table->type; - ecs_type_t old_type = old_table->type; - - int32_t offset_new = new_table->sw_column_offset; - int32_t offset_old = old_table->sw_column_offset; - - ecs_id_t *new_ids = ecs_vector_first(new_type, ecs_id_t); - ecs_id_t *old_ids = ecs_vector_first(old_type, ecs_id_t); - - for (; (i_new < new_column_count) && (i_old < old_column_count);) { - ecs_entity_t new_id = new_ids[i_new + offset_new]; - ecs_entity_t old_id = old_ids[i_old + offset_old]; - - if (new_id == old_id) { - ecs_switch_t *old_switch = old_columns[i_old].data; - ecs_switch_t *new_switch = new_columns[i_new].data; - - flecs_switch_ensure(new_switch, new_index + count); - - int i; - for (i = 0; i < count; i ++) { - uint64_t value = flecs_switch_get(old_switch, old_index + i); - flecs_switch_set(new_switch, new_index + i, value); - } - - if (clear) { - ecs_assert(count == flecs_switch_count(old_switch), - ECS_INTERNAL_ERROR, NULL); - flecs_switch_clear(old_switch); - } + if (table->flags & EcsTableHasIsA) { + if (!ecs_get_typeid(world, id)) { + /* Do nothing if id is not a component */ + return; } - i_new += new_id <= old_id; - i_old += new_id >= old_id; + /* If next table has a base and component is removed, check if + * the removed component was an override. Removed overrides reexpose the + * base component, thus "changing" the value which requires an OnSet. */ + if (ecs_search_relation(world, table, 0, id, EcsIsA, + 1, -1, NULL, NULL, NULL) != -1) + { + ids_append(&diff->on_set, id); + return; + } } - /* Clear remaining columns */ - if (clear) { - for (; (i_old < old_column_count); i_old ++) { - ecs_switch_t *old_switch = old_columns[i_old].data; - ecs_assert(count == flecs_switch_count(old_switch), - ECS_INTERNAL_ERROR, NULL); - flecs_switch_clear(old_switch); - } + if (ecs_get_typeid(world, id) != 0) { + ids_append(&diff->un_set, id); } } static -void move_bitset_columns( - ecs_table_t *new_table, - ecs_data_t *new_data, - int32_t new_index, - ecs_table_t *old_table, - ecs_data_t *old_data, - int32_t old_index, - int32_t count, - bool clear) +void compute_table_diff( + ecs_world_t *world, + ecs_table_t *node, + ecs_table_t *next, + ecs_graph_edge_t *edge, + ecs_id_t id) { - int32_t i_old = 0, old_column_count = old_table->bs_column_count; - int32_t i_new = 0, new_column_count = new_table->bs_column_count; - - if (!old_column_count && !new_column_count) { + if (node == next) { return; } - ecs_bs_column_t *old_columns = old_data->bs_columns; - ecs_bs_column_t *new_columns = new_data->bs_columns; + ecs_type_t node_type = node->type; + ecs_type_t next_type = next->type; - ecs_type_t new_type = new_table->type; - ecs_type_t old_type = old_table->type; + ecs_id_t *ids_node = ecs_vector_first(node_type, ecs_id_t); + ecs_id_t *ids_next = ecs_vector_first(next_type, ecs_id_t); + int32_t i_node = 0, node_count = ecs_vector_count(node_type); + int32_t i_next = 0, next_count = ecs_vector_count(next_type); + int32_t added_count = 0; + int32_t removed_count = 0; + bool trivial_edge = !ECS_HAS_RELATION(id, EcsIsA) && + !(node->flags & EcsTableHasIsA) && !(next->flags & EcsTableHasIsA); - int32_t offset_new = new_table->bs_column_offset; - int32_t offset_old = old_table->bs_column_offset; + /* First do a scan to see how big the diff is, so we don't have to realloc + * or alloc more memory than required. */ + for (; i_node < node_count && i_next < next_count; ) { + ecs_id_t id_node = ids_node[i_node]; + ecs_id_t id_next = ids_next[i_next]; - ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); - ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); + bool added = id_next < id_node; + bool removed = id_node < id_next; - for (; (i_new < new_column_count) && (i_old < old_column_count);) { - ecs_entity_t new_component = new_components[i_new + offset_new]; - ecs_entity_t old_component = old_components[i_old + offset_old]; + trivial_edge &= !added || id_next == id; + trivial_edge &= !removed || id_node == id; - if (new_component == old_component) { - ecs_bitset_t *old_bs = &old_columns[i_old].data; - ecs_bitset_t *new_bs = &new_columns[i_new].data; + added_count += added; + removed_count += removed; - flecs_bitset_ensure(new_bs, new_index + count); + i_node += id_node <= id_next; + i_next += id_next <= id_node; + } - int i; - for (i = 0; i < count; i ++) { - uint64_t value = flecs_bitset_get(old_bs, old_index + i); - flecs_bitset_set(new_bs, new_index + i, value); - } + added_count += next_count - i_next; + removed_count += node_count - i_node; - if (clear) { - ecs_assert(count == flecs_bitset_count(old_bs), - ECS_INTERNAL_ERROR, NULL); - flecs_bitset_fini(old_bs); - } - } + trivial_edge &= (added_count + removed_count) <= 1 && + !ecs_id_is_wildcard(id); - i_new += new_component <= old_component; - i_old += new_component >= old_component; + if (trivial_edge) { + /* If edge is trivial there's no need to create a diff element for it. + * Store whether the id is a tag or not, so that we can still tell + * whether an UnSet handler should be called or not. */ + if (node->storage_table != next->storage_table) { + edge->diff = &ecs_table_edge_is_component; + } + return; } - /* Clear remaining columns */ - if (clear) { - for (; (i_old < old_column_count); i_old ++) { - ecs_bitset_t *old_bs = &old_columns[i_old].data; - ecs_assert(count == flecs_bitset_count(old_bs), - ECS_INTERNAL_ERROR, NULL); - flecs_bitset_fini(old_bs); + ecs_table_diff_t *diff = ecs_os_calloc_t(ecs_table_diff_t); + edge->diff = diff; + if (added_count) { + diff->added.array = ecs_os_malloc_n(ecs_id_t, added_count); + diff->added.count = 0; + diff->added.size = added_count; + } + if (removed_count) { + diff->removed.array = ecs_os_malloc_n(ecs_id_t, removed_count); + diff->removed.count = 0; + diff->removed.size = removed_count; + } + + for (i_node = 0, i_next = 0; i_node < node_count && i_next < next_count; ) { + ecs_id_t id_node = ids_node[i_node]; + ecs_id_t id_next = ids_next[i_next]; + + if (id_next < id_node) { + diff_insert_added(world, node, diff, id_next); + } else if (id_node < id_next) { + diff_insert_removed(world, next, diff, id_node); } + + i_node += id_node <= id_next; + i_next += id_next <= id_node; } + + for (; i_next < next_count; i_next ++) { + diff_insert_added(world, node, diff, ids_next[i_next]); + } + for (; i_node < node_count; i_node ++) { + diff_insert_removed(world, next, diff, ids_node[i_node]); + } + + ecs_assert(diff->added.count == added_count, ECS_INTERNAL_ERROR, NULL); + ecs_assert(diff->removed.count == removed_count, ECS_INTERNAL_ERROR, NULL); } static -void grow_column( +void add_with_ids_to_ids( ecs_world_t *world, - ecs_entity_t *entities, - ecs_column_t *column, - ecs_type_info_t *ti, - int32_t to_add, - int32_t new_size, - bool construct) + ecs_vector_t **idv, + ecs_entity_t r, + ecs_entity_t o) { - ecs_vector_t *vec = column->data; - int16_t alignment = column->alignment; - - int32_t size = column->size; - int32_t count = ecs_vector_count(vec); - int32_t old_size = ecs_vector_size(vec); - int32_t new_count = count + to_add; - bool can_realloc = new_size != old_size; - - ecs_assert(new_size >= new_count, ECS_INTERNAL_ERROR, NULL); - - /* If the array could possibly realloc and the component has a move action - * defined, move old elements manually */ - ecs_move_t move_ctor; - if (ti && count && can_realloc && - (move_ctor = ti->lifecycle.move_ctor)) - { - ecs_xtor_t ctor = ti->lifecycle.ctor; - ecs_assert(ctor != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL); - - /* Create new vector */ - ecs_vector_t *new_vec = ecs_vector_new_t(size, alignment, new_size); - ecs_vector_set_count_t(&new_vec, size, alignment, new_count); + /* Check if component/relation has With pairs, which contain ids + * that need to be added to the table. */ + ecs_table_t *id_table = ecs_get_table(world, r); + if (!id_table) { + return; + } + + ecs_table_record_t *tr = flecs_get_table_record(world, id_table, + ecs_pair(EcsWith, EcsWildcard)); + if (tr) { + int32_t i, with_count = tr->count; + int32_t start = tr->column; + int32_t end = start + with_count; + ecs_id_t *id_ids = ecs_vector_first(id_table->type, ecs_id_t); - void *old_buffer = ecs_vector_first_t(vec, size, alignment); - void *new_buffer = ecs_vector_first_t(new_vec, size, alignment); + for (i = start; i < end; i ++) { + ecs_assert(ECS_PAIR_FIRST(id_ids[i]) == EcsWith, + ECS_INTERNAL_ERROR, NULL); + ecs_id_t id_r = ECS_PAIR_SECOND(id_ids[i]); + ecs_id_t id = id_r; + if (o) { + id = ecs_pair(id_r, o); + } - /* Move (and construct) existing elements to new vector */ - move_ctor(world, entities, entities, new_buffer, old_buffer, count, ti); + /* Always make sure vector has room for one more */ + add_id_to_ids(idv, id, 0); - if (construct) { - /* Construct new element(s) */ - void *elem = ECS_OFFSET(new_buffer, size * count); - ctor(world, &entities[count], elem, to_add, ti); + /* Add recursively in case id also has With pairs */ + add_with_ids_to_ids(world, idv, id_r, o); } + } +} - /* Free old vector */ - ecs_vector_free(vec); - - column->data = new_vec; +static +ecs_table_t* find_or_create_table_with_id( + ecs_world_t *world, + ecs_table_t *node, + ecs_entity_t id) +{ + /* If table has one or more switches and this is a case, return self */ + if (ECS_HAS_ROLE(id, CASE)) { + ecs_assert((node->flags & EcsTableHasSwitch) != 0, + ECS_TYPE_INVALID_CASE, NULL); + return node; } else { - /* If array won't realloc or has no move, simply add new elements */ - if (can_realloc) { - ecs_vector_set_size_t(&vec, size, alignment, new_size); - } + ecs_type_t type = node->type; + ecs_entity_t r_exclusive = 0; + ecs_entity_t r = 0, o = 0, re = 0; - void *elem = ecs_vector_addn_t(&vec, size, alignment, to_add); + if (ECS_HAS_ROLE(id, PAIR)) { + r = ECS_PAIR_FIRST(id); + o = ECS_PAIR_SECOND(id); + re = ecs_get_alive(world, r); + if (re && ecs_has_id(world, re, EcsExclusive)) { + r_exclusive = (uint32_t)re; + } + } else { + r = id & ECS_COMPONENT_MASK; + re = ecs_get_alive(world, r); + } - ecs_xtor_t ctor; - if (construct && ti && (ctor = ti->lifecycle.ctor)) { - /* If new elements need to be constructed and component has a - * constructor, construct */ - ctor(world, &entities[count], elem, to_add, ti); + ecs_vector_t *idv = ecs_vector_copy(type, ecs_id_t); + add_id_to_ids(&idv, id, r_exclusive); + if (re) { + add_with_ids_to_ids(world, &idv, re, o); } - column->data = vec; - } + ecs_ids_t ids = { + .array = ecs_vector_first(idv, ecs_id_t), + .count = ecs_vector_count(idv) + }; - ecs_assert(ecs_vector_size(column->data) == new_size, - ECS_INTERNAL_ERROR, NULL); + return find_or_create(world, &ids, idv); + } } static -int32_t grow_data( +ecs_table_t* find_or_create_table_without_id( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - int32_t to_add, - int32_t size, - const ecs_entity_t *ids) + ecs_table_t *node, + ecs_entity_t id) { - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - - int32_t cur_count = flecs_table_data_count(data); - int32_t column_count = ecs_vector_count(table->storage_type); - int32_t sw_column_count = table->sw_column_count; - int32_t bs_column_count = table->bs_column_count; - ecs_column_t *columns = data->columns; - ecs_sw_column_t *sw_columns = data->sw_columns; - ecs_bs_column_t *bs_columns = data->bs_columns; - - /* Add record to record ptr array */ - ecs_vector_set_size(&data->record_ptrs, ecs_record_t*, size); - ecs_record_t **r = ecs_vector_addn(&data->record_ptrs, ecs_record_t*, to_add); - ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); - if (ecs_vector_size(data->record_ptrs) > size) { - size = ecs_vector_size(data->record_ptrs); - } - - /* Add entity to column with entity ids */ - ecs_vector_set_size(&data->entities, ecs_entity_t, size); - ecs_entity_t *e = ecs_vector_addn(&data->entities, ecs_entity_t, to_add); - ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ecs_vector_size(data->entities) == size, ECS_INTERNAL_ERROR, NULL); - - /* Initialize entity ids and record ptrs */ - int32_t i; - if (ids) { - for (i = 0; i < to_add; i ++) { - e[i] = ids[i]; - } + /* If table has one or more switches and this is a case, return self */ + if (ECS_HAS_ROLE(id, CASE)) { + ecs_assert((node->flags & EcsTableHasSwitch) != 0, + ECS_TYPE_INVALID_CASE, NULL); + return node; } else { - ecs_os_memset(e, 0, ECS_SIZEOF(ecs_entity_t) * to_add); - } - ecs_os_memset(r, 0, ECS_SIZEOF(ecs_record_t*) * to_add); + ecs_type_t type = node->type; + int32_t count = ecs_vector_count(type); - /* Add elements to each column array */ - ecs_type_info_t **c_info_array = table->type_info; - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - ecs_assert(column->size != 0, ECS_INTERNAL_ERROR, NULL); + ecs_ids_t ids = { + .array = ecs_os_alloca_n(ecs_id_t, count), + .count = count + }; - ecs_type_info_t *c_info = NULL; - if (c_info_array) { - c_info = c_info_array[i]; - } + remove_id_from_ids(type, id, &ids); - grow_column(world, entities, column, c_info, to_add, size, true); - ecs_assert(ecs_vector_size(columns[i].data) == size, - ECS_INTERNAL_ERROR, NULL); + return flecs_table_find_or_create(world, &ids);; } +} - /* Add elements to each switch column */ - for (i = 0; i < sw_column_count; i ++) { - ecs_switch_t *sw = sw_columns[i].data; - flecs_switch_addn(sw, to_add); - } +static +ecs_table_t* find_or_create_table_with_isa( + ecs_world_t *world, + ecs_table_t *node, + ecs_entity_t base) +{ + ecs_type_t base_type = ecs_get_type(world, base); + ecs_id_t *ids = ecs_vector_first(base_type, ecs_id_t); + int32_t i, count = ecs_vector_count(base_type); - /* Add elements to each bitset column */ - for (i = 0; i < bs_column_count; i ++) { - ecs_bitset_t *bs = &bs_columns[i].data; - flecs_bitset_addn(bs, to_add); - } + /* Start from back, as roles have high ids */ + for (i = count - 1; i >= 0; i --) { + ecs_id_t id = ids[i]; + if (!(id & ECS_ROLE_MASK)) { /* early out if we found everything */ + break; + } - /* If the table is monitored indicate that there has been a change */ - mark_table_dirty(world, table, 0); + if (ECS_HAS_RELATION(id, EcsIsA)) { + ecs_entity_t base_of_base = ecs_pair_second(world, id); + node = find_or_create_table_with_isa(world, node, base_of_base); + } - if (!world->is_readonly && !cur_count) { - flecs_table_set_empty(world, table); + if (ECS_HAS_ROLE(id, OVERRIDE)) { + /* Override found, add it to table */ + id &= ECS_COMPONENT_MASK; + node = flecs_table_traverse_add(world, node, &id, NULL); + } } - table->alloc_count ++; - - /* Return index of first added entity */ - return cur_count; + return node; } static -void fast_append( - ecs_column_t *columns, - int32_t column_count) +void init_edge( + ecs_table_t *table, + ecs_graph_edge_t *edge, + ecs_id_t id, + ecs_table_t *to) { - /* Add elements to each column array */ - int32_t i; - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - int16_t size = column->size; - if (size) { - int16_t alignment = column->alignment; - ecs_vector_add_t(&column->data, size, alignment); - } - } + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->id == 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->hdr.next == NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->hdr.prev == NULL, ECS_INTERNAL_ERROR, NULL); + + edge->from = table; + edge->to = to; + edge->id = id; } -int32_t flecs_table_append( +static +void init_add_edge( ecs_world_t *world, ecs_table_t *table, - ecs_data_t *data, - ecs_entity_t entity, - ecs_record_t *record, - bool construct) + ecs_graph_edge_t *edge, + ecs_id_t id, + ecs_table_t *to) { - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - - check_table_sanity(table); - - /* Get count & size before growing entities array. This tells us whether the - * arrays will realloc */ - int32_t count = ecs_vector_count(data->entities); - int32_t size = ecs_vector_size(data->entities); - int32_t column_count = ecs_vector_count(table->storage_type); - ecs_column_t *columns = table->storage.columns; - - /* Grow buffer with entity ids, set new element to new entity */ - ecs_entity_t *e = ecs_vector_add(&data->entities, ecs_entity_t); - ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); - *e = entity; + init_edge(table, edge, id, to); - /* Keep track of alloc count. This allows references to check if cached - * pointers need to be updated. */ - table->alloc_count += (count == size); + ensure_hi_edge(world, &table->node.add, id); - /* Add record ptr to array with record ptrs */ - ecs_record_t **r = ecs_vector_add(&data->record_ptrs, ecs_record_t*); - ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); - *r = record; - - /* If the table is monitored indicate that there has been a change */ - mark_table_dirty(world, table, 0); - ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL); + if (table != to) { + /* Add edges are appended to refs.next */ + ecs_graph_edge_hdr_t *to_refs = &to->node.refs; + ecs_graph_edge_hdr_t *next = to_refs->next; + + to_refs->next = &edge->hdr; + edge->hdr.prev = to_refs; - /* Fast path: no switch columns, no lifecycle actions */ - if (!(table->flags & EcsTableIsComplex)) { - fast_append(columns, column_count); - if (!count) { - flecs_table_set_empty(world, table); /* See below */ + edge->hdr.next = next; + if (next) { + next->prev = &edge->hdr; } - return count; + + compute_table_diff(world, table, to, edge, id); } +} - int32_t sw_column_count = table->sw_column_count; - int32_t bs_column_count = table->bs_column_count; - ecs_sw_column_t *sw_columns = table->storage.sw_columns; - ecs_bs_column_t *bs_columns = table->storage.bs_columns; +static +void init_remove_edge( + ecs_world_t *world, + ecs_table_t *table, + ecs_graph_edge_t *edge, + ecs_id_t id, + ecs_table_t *to) +{ + init_edge(table, edge, id, to); - ecs_type_info_t **c_info_array = table->type_info; - ecs_entity_t *entities = ecs_vector_first( - data->entities, ecs_entity_t); + ensure_hi_edge(world, &table->node.remove, id); - /* Reobtain size to ensure that the columns have the same size as the - * entities and record vectors. This keeps reasoning about when allocations - * occur easier. */ - size = ecs_vector_size(data->entities); + if (table != to) { + /* Remove edges are appended to refs.prev */ + ecs_graph_edge_hdr_t *to_refs = &to->node.refs; + ecs_graph_edge_hdr_t *prev = to_refs->prev; - /* Grow component arrays with 1 element */ - int32_t i; - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - ecs_assert(column->size != 0, ECS_INTERNAL_ERROR, NULL); + to_refs->prev = &edge->hdr; + edge->hdr.next = to_refs; - ecs_type_info_t *c_info = NULL; - if (c_info_array) { - c_info = c_info_array[i]; + edge->hdr.prev = prev; + if (prev) { + prev->next = &edge->hdr; } - grow_column(world, entities, column, c_info, 1, size, construct); - - ecs_assert( - ecs_vector_size(columns[i].data) == ecs_vector_size(data->entities), - ECS_INTERNAL_ERROR, NULL); - - ecs_assert( - ecs_vector_count(columns[i].data) == ecs_vector_count(data->entities), - ECS_INTERNAL_ERROR, NULL); - } - - /* Add element to each switch column */ - for (i = 0; i < sw_column_count; i ++) { - ecs_assert(sw_columns != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_switch_t *sw = sw_columns[i].data; - flecs_switch_add(sw); - } - - /* Add element to each bitset column */ - for (i = 0; i < bs_column_count; i ++) { - ecs_assert(bs_columns != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_bitset_t *bs = &bs_columns[i].data; - flecs_bitset_addn(bs, 1); - } - - /* If this is the first entity in this table, signal queries so that the - * table moves from an inactive table to an active table. */ - if (!count) { - flecs_table_set_empty(world, table); + compute_table_diff(world, table, to, edge, id); } - - check_table_sanity(table); - - return count; } static -void fast_delete_last( - ecs_column_t *columns, - int32_t column_count) +ecs_table_t* find_or_create_table_without( + ecs_world_t *world, + ecs_table_t *node, + ecs_graph_edge_t *edge, + ecs_id_t id) { - int i; - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - ecs_vector_remove_last(column->data); - } + ecs_table_t *to = find_or_create_table_without_id(world, node, id); + + init_remove_edge(world, node, edge, id, to); + + return to; } static -void fast_delete( - ecs_column_t *columns, - int32_t column_count, - int32_t index) +ecs_table_t* find_or_create_table_with( + ecs_world_t *world, + ecs_table_t *node, + ecs_graph_edge_t *edge, + ecs_id_t id) { - int i; - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - int16_t size = column->size; - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); + ecs_table_t *to = find_or_create_table_with_id(world, node, id); - int16_t alignment = column->alignment; - ecs_vector_remove_t(column->data, size, alignment, index); + if (ECS_HAS_ROLE(id, PAIR) && ECS_PAIR_FIRST(id) == EcsIsA) { + ecs_entity_t base = ecs_pair_second(world, id); + to = find_or_create_table_with_isa(world, to, base); } + + init_add_edge(world, node, edge, id, to); + + return to; } -void flecs_table_delete( - ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - int32_t index, - bool destruct) +static +void populate_diff( + ecs_graph_edge_t *edge, + ecs_id_t *add_ptr, + ecs_id_t *remove_ptr, + ecs_table_diff_t *out) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - - check_table_sanity(table); + if (out) { + ecs_table_diff_t *diff = edge->diff; - ecs_vector_t *v_entities = data->entities; - int32_t count = ecs_vector_count(v_entities); + if (diff && diff != &ecs_table_edge_is_component) { + ecs_assert(!add_ptr || !ECS_HAS_ROLE(add_ptr[0], CASE), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!remove_ptr || !ECS_HAS_ROLE(remove_ptr[0], CASE), + ECS_INTERNAL_ERROR, NULL); + *out = *diff; + } else { + out->on_set.count = 0; - ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL); - count --; - ecs_assert(index <= count, ECS_INTERNAL_ERROR, NULL); + if (add_ptr) { + out->added.array = add_ptr; + out->added.count = 1; + } else { + out->added.count = 0; + } - /* Move last entity id to index */ - ecs_entity_t *entities = ecs_vector_first(v_entities, ecs_entity_t); - ecs_entity_t entity_to_move = entities[count]; - ecs_entity_t entity_to_delete = entities[index]; - entities[index] = entity_to_move; - ecs_vector_remove_last(v_entities); - - /* Move last record ptr to index */ - ecs_vector_t *v_records = data->record_ptrs; - ecs_assert(count < ecs_vector_count(v_records), ECS_INTERNAL_ERROR, NULL); - - ecs_record_t **records = ecs_vector_first(v_records, ecs_record_t*); - ecs_record_t *record_to_move = records[count]; - records[index] = record_to_move; - ecs_vector_remove_last(v_records); - - /* Update record of moved entity in entity index */ - if (index != count) { - if (record_to_move) { - uint32_t row_flags = record_to_move->row & ECS_ROW_FLAGS_MASK; - record_to_move->row = ECS_ROW_TO_RECORD(index, row_flags); - ecs_assert(record_to_move->table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(record_to_move->table == table, ECS_INTERNAL_ERROR, NULL); - } - } - - /* If the table is monitored indicate that there has been a change */ - mark_table_dirty(world, table, 0); - - /* If table is empty, deactivate it */ - if (!count) { - flecs_table_set_empty(world, table); - } - - /* Destruct component data */ - ecs_type_info_t **c_info_array = table->type_info; - ecs_column_t *columns = data->columns; - int32_t column_count = ecs_vector_count(table->storage_type); - int32_t i; - - /* If this is a table without lifecycle callbacks or special columns, take - * fast path that just remove an element from the array(s) */ - if (!(table->flags & EcsTableIsComplex)) { - if (index == count) { - fast_delete_last(columns, column_count); - } else { - fast_delete(columns, column_count, index); - } - - check_table_sanity(table); - - return; - } - - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - - /* Last element, destruct & remove */ - if (index == count) { - /* If table has component destructors, invoke */ - if (destruct && (table->flags & EcsTableHasDtors)) { - ecs_assert(c_info_array != NULL, ECS_INTERNAL_ERROR, NULL); - - for (i = 0; i < column_count; i ++) { - ecs_type_info_t *ti = c_info_array[i]; - if (!ti) { - continue; - } - - dtor_component(world, table, ti, &columns[i], - entities, ids[i], index, 1, true); - } - } - - fast_delete_last(columns, column_count); - - /* Not last element, move last element to deleted element & destruct */ - } else { - /* If table has component destructors, invoke */ - if (destruct && (table->flags & (EcsTableHasDtors | EcsTableHasMove))) { - ecs_assert(c_info_array != NULL, ECS_INTERNAL_ERROR, NULL); - - for (i = 0; i < column_count; i ++) { - ecs_column_t *column = &columns[i]; - ecs_size_t size = column->size; - ecs_size_t align = column->alignment; - ecs_vector_t *vec = column->data; - void *dst = ecs_vector_get_t(vec, size, align, index); - void *src = ecs_vector_last_t(vec, size, align); - - ecs_type_info_t *ti = c_info_array[i]; - - ecs_iter_action_t on_remove; - if (ti && (on_remove = ti->lifecycle.on_remove)) { - on_remove_component(world, table, on_remove, dst, - size, &entity_to_delete, ids[i], 1, - ti->lifecycle.ctx); - } - - ecs_move_t move_dtor; - if (ti && (move_dtor = ti->lifecycle.move_dtor)) { - move_dtor(world, &entity_to_move, - &entity_to_delete, dst, src, 1, ti); + if (remove_ptr) { + out->removed.array = remove_ptr; + out->removed.count = 1; + if (diff == &ecs_table_edge_is_component) { + out->un_set.array = remove_ptr; + out->un_set.count = 1; } else { - ecs_os_memcpy(dst, src, size); + out->un_set.count = 0; } - - ecs_vector_remove_last(vec); + } else { + out->removed.count = 0; + out->un_set.count = 0; } - } else { - fast_delete(columns, column_count, index); } } - - /* Remove elements from switch columns */ - ecs_sw_column_t *sw_columns = data->sw_columns; - int32_t sw_column_count = table->sw_column_count; - for (i = 0; i < sw_column_count; i ++) { - flecs_switch_remove(sw_columns[i].data, index); - } - - /* Remove elements from bitset columns */ - ecs_bs_column_t *bs_columns = data->bs_columns; - int32_t bs_column_count = table->bs_column_count; - for (i = 0; i < bs_column_count; i ++) { - flecs_bitset_remove(&bs_columns[i].data, index); - } - - check_table_sanity(table); } -static -void fast_move( - ecs_table_t *new_table, - ecs_data_t *new_data, - int32_t new_index, - ecs_table_t *old_table, - ecs_data_t *old_data, - int32_t old_index) +ecs_table_t* flecs_table_traverse_remove( + ecs_world_t *world, + ecs_table_t *node, + ecs_id_t *id_ptr, + ecs_table_diff_t *diff) { - ecs_type_t new_type = new_table->storage_type; - ecs_type_t old_type = old_table->storage_type; - - int32_t i_new = 0, new_column_count = ecs_vector_count(new_table->storage_type); - int32_t i_old = 0, old_column_count = ecs_vector_count(old_table->storage_type); - ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); - ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - - ecs_column_t *old_columns = old_data->columns; - ecs_column_t *new_columns = new_data->columns; + ecs_poly_assert(world, ecs_world_t); + node = node ? node : &world->store.root; - for (; (i_new < new_column_count) && (i_old < old_column_count);) { - ecs_entity_t new_component = new_components[i_new]; - ecs_entity_t old_component = old_components[i_old]; + /* Removing 0 from an entity is not valid */ + ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL); - if (new_component == old_component) { - ecs_column_t *new_column = &new_columns[i_new]; - ecs_column_t *old_column = &old_columns[i_old]; - int16_t size = new_column->size; - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); + ecs_id_t id = id_ptr[0]; + ecs_graph_edge_t *edge = ensure_edge(world, &node->node.remove, id); + ecs_table_t *to = edge->to; - int16_t alignment = new_column->alignment; - void *dst = ecs_vector_get_t( - new_column->data, size, alignment, new_index); - void *src = ecs_vector_get_t( - old_column->data, size, alignment, old_index); + if (!to) { + to = find_or_create_table_without(world, node, edge, id); + ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL); + } - ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(src != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_os_memcpy(dst, src, size); - } + populate_diff(edge, NULL, id_ptr, diff); - i_new += new_component <= old_component; - i_old += new_component >= old_component; - } + return to; +error: + return NULL; } -void flecs_table_move( +ecs_table_t* flecs_table_traverse_add( ecs_world_t *world, - ecs_entity_t dst_entity, - ecs_entity_t src_entity, - ecs_table_t *new_table, - ecs_data_t *new_data, - int32_t new_index, - ecs_table_t *old_table, - ecs_data_t *old_data, - int32_t old_index, - bool construct) + ecs_table_t *node, + ecs_id_t *id_ptr, + ecs_table_diff_t *diff) { - ecs_assert(new_table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(old_table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!new_table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_assert(!old_table->lock, ECS_LOCKED_STORAGE, NULL); + ecs_poly_assert(world, ecs_world_t); - ecs_assert(old_index >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(new_index >= 0, ECS_INTERNAL_ERROR, NULL); + node = node ? node : &world->store.root; - ecs_assert(old_data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(new_data != NULL, ECS_INTERNAL_ERROR, NULL); + /* Adding 0 to an entity is not valid */ + ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL); - check_table_sanity(new_table); - check_table_sanity(old_table); + ecs_id_t id = id_ptr[0]; + ecs_graph_edge_t *edge = ensure_edge(world, &node->node.add, id); + ecs_table_t *to = edge->to; - if (!((new_table->flags | old_table->flags) & EcsTableIsComplex)) { - fast_move(new_table, new_data, new_index, old_table, old_data, - old_index); - check_table_sanity(new_table); - check_table_sanity(old_table); - return; + if (!to) { + to = find_or_create_table_with(world, node, edge, id); + ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL); } - move_switch_columns(new_table, new_data, new_index, old_table, old_data, - old_index, 1, false); - move_bitset_columns(new_table, new_data, new_index, old_table, old_data, - old_index, 1, false); + populate_diff(edge, id_ptr, NULL, diff); - bool same_entity = dst_entity == src_entity; + return to; +error: + return NULL; +} - ecs_type_t new_type = new_table->storage_type; - ecs_type_t old_type = old_table->storage_type; +ecs_table_t* flecs_table_find_or_create( + ecs_world_t *world, + const ecs_ids_t *ids) +{ + ecs_poly_assert(world, ecs_world_t); + return find_or_create(world, ids, NULL); +} - int32_t i_new = 0, new_column_count = ecs_vector_count(new_table->storage_type); - int32_t i_old = 0, old_column_count = ecs_vector_count(old_table->storage_type); - ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); - ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); +void flecs_init_root_table( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); - ecs_column_t *old_columns = old_data->columns; - ecs_column_t *new_columns = new_data->columns; + ecs_ids_t entities = { + .array = NULL, + .count = 0 + }; - for (; (i_new < new_column_count) && (i_old < old_column_count);) { - ecs_entity_t new_component = new_components[i_new]; - ecs_entity_t old_component = old_components[i_old]; + world->store.root.type = ids_to_vector(&entities); + init_table(world, &world->store.root); - if (new_component == old_component) { - ecs_column_t *new_column = &new_columns[i_new]; - ecs_column_t *old_column = &old_columns[i_old]; - int16_t size = new_column->size; - int16_t alignment = new_column->alignment; + /* Ensure table indices start at 1, as 0 is reserved for the root */ + uint64_t new_id = flecs_sparse_new_id(&world->store.tables); + ecs_assert(new_id == 0, ECS_INTERNAL_ERROR, NULL); + (void)new_id; +} - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); +void flecs_table_clear_edges( + ecs_world_t *world, + ecs_table_t *table) +{ + (void)world; + ecs_poly_assert(world, ecs_world_t); - void *dst = ecs_vector_get_t( - new_column->data, size, alignment, new_index); - void *src = ecs_vector_get_t( - old_column->data, size, alignment, old_index); + ecs_log_push_1(); - ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(src != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_map_iter_t it; + ecs_graph_node_t *table_node = &table->node; + ecs_graph_edges_t *node_add = &table_node->add; + ecs_graph_edges_t *node_remove = &table_node->remove; + ecs_map_t *add_hi = &node_add->hi; + ecs_map_t *remove_hi = &node_remove->hi; + ecs_graph_edge_hdr_t *node_refs = &table_node->refs; + ecs_graph_edge_t *edge; + uint64_t key; - ecs_type_info_t *ti = new_table->type_info[i_new]; - if (same_entity) { - ecs_move_t callback; - if (ti && (callback = ti->lifecycle.ctor_move_dtor)) { - /* ctor + move + dtor */ - callback(world, &dst_entity, &src_entity, dst, src, 1, ti); - } else { - ecs_os_memcpy(dst, src, size); - } - } else { - ecs_copy_t copy; - if (ti && (copy = ti->lifecycle.copy_ctor)) { - copy(world, &dst_entity, &src_entity, dst, src, 1, ti); - } else { - ecs_os_memcpy(dst, src, size); - } - } - } else { - if (new_component < old_component) { - if (construct) { - ctor_component(world, new_table->type_info[i_new], - &new_columns[i_new], &dst_entity, new_index, 1); - } - } else { - dtor_component(world, old_table, old_table->type_info[i_old], - &old_columns[i_old], &src_entity, old_component, - old_index, 1, true); - } - } + /* Cleanup outgoing edges */ + it = ecs_map_iter(add_hi); + while ((edge = ecs_map_next_ptr(&it, ecs_graph_edge_t*, &key))) { + disconnect_edge(world, key, edge); + } - i_new += new_component <= old_component; - i_old += new_component >= old_component; + it = ecs_map_iter(remove_hi); + while ((edge = ecs_map_next_ptr(&it, ecs_graph_edge_t*, &key))) { + disconnect_edge(world, key, edge); } - if (construct) { - for (; (i_new < new_column_count); i_new ++) { - ctor_component(world, new_table->type_info[i_new], - &new_columns[i_new], &dst_entity, new_index, 1); - } + /* Cleanup incoming add edges */ + ecs_graph_edge_hdr_t *next, *cur = node_refs->next; + if (cur) { + do { + edge = (ecs_graph_edge_t*)cur; + ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL); + next = cur->next; + remove_edge(world, &edge->from->node.add, edge->id, edge); + } while ((cur = next)); } - for (; (i_old < old_column_count); i_old ++) { - dtor_component(world, old_table, old_table->type_info[i_old], - &old_columns[i_old], &src_entity, old_components[i_old], - old_index, 1, true); + /* Cleanup incoming remove edges */ + cur = node_refs->prev; + if (cur) { + do { + edge = (ecs_graph_edge_t*)cur; + ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL); + ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL); + next = cur->prev; + remove_edge(world, &edge->from->node.remove, edge->id, edge); + } while ((cur = next)); } - check_table_sanity(new_table); - check_table_sanity(old_table); + ecs_os_free(node_add->lo); + ecs_os_free(node_remove->lo); + ecs_map_fini(add_hi); + ecs_map_fini(remove_hi); + table_node->add.lo = NULL; + table_node->remove.lo = NULL; + + ecs_log_pop_1(); } -int32_t flecs_table_appendn( +/* Public convenience functions for traversing table graph */ +ecs_table_t* ecs_table_add_id( ecs_world_t *world, ecs_table_t *table, - ecs_data_t *data, - int32_t to_add, - const ecs_entity_t *ids) + ecs_id_t id) { - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - - check_table_sanity(table); - - int32_t cur_count = flecs_table_data_count(data); - int32_t result = grow_data( - world, table, data, to_add, cur_count + to_add, ids); - check_table_sanity(table); - return result; + return flecs_table_traverse_add(world, table, &id, NULL); } -void flecs_table_set_size( +ecs_table_t* ecs_table_remove_id( ecs_world_t *world, ecs_table_t *table, - ecs_data_t *data, - int32_t size) + ecs_id_t id) { - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); + return flecs_table_traverse_remove(world, table, &id, NULL); +} - check_table_sanity(table); +#include - int32_t cur_count = flecs_table_data_count(data); +static +int32_t count_events( + const ecs_entity_t *events) +{ + int32_t i; - if (cur_count < size) { - grow_data(world, table, data, 0, size, NULL); - check_table_sanity(table); + for (i = 0; i < ECS_TRIGGER_DESC_EVENT_COUNT_MAX; i ++) { + if (!events[i]) { + break; + } } -} -int32_t flecs_table_data_count( - const ecs_data_t *data) -{ - return data ? ecs_vector_count(data->entities) : 0; + return i; } static -void swap_switch_columns( - ecs_table_t *table, - ecs_data_t *data, - int32_t row_1, - int32_t row_2) +ecs_entity_t get_actual_event( + ecs_trigger_t *trigger, + ecs_entity_t event) { - int32_t i = 0, column_count = table->sw_column_count; - if (!column_count) { - return; + /* If operator is Not, reverse the event */ + if (trigger->term.oper == EcsNot) { + if (event == EcsOnAdd) { + event = EcsOnRemove; + } else if (event == EcsOnRemove) { + event = EcsOnAdd; + } } - ecs_sw_column_t *columns = data->sw_columns; + return event; +} - for (i = 0; i < column_count; i ++) { - ecs_switch_t *sw = columns[i].data; - flecs_switch_swap(sw, row_1, row_2); +static +void unregister_event_trigger( + ecs_event_record_t *evt, + ecs_id_t id) +{ + if (ecs_map_remove(&evt->event_ids, id) == 0) { + ecs_map_fini(&evt->event_ids); } } static -void swap_bitset_columns( - ecs_table_t *table, - ecs_data_t *data, - int32_t row_1, - int32_t row_2) +ecs_event_id_record_t* ensure_event_id_record( + ecs_map_t *map, + ecs_id_t id) { - int32_t i = 0, column_count = table->bs_column_count; - if (!column_count) { - return; + ecs_event_id_record_t **idt = ecs_map_ensure( + map, ecs_event_id_record_t*, id); + if (!idt[0]) { + idt[0] = ecs_os_calloc_t(ecs_event_id_record_t); } - ecs_bs_column_t *columns = data->bs_columns; - - for (i = 0; i < column_count; i ++) { - ecs_bitset_t *bs = &columns[i].data; - flecs_bitset_swap(bs, row_1, row_2); - } + return idt[0]; } -void flecs_table_swap( +static +void inc_trigger_count( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - int32_t row_1, - int32_t row_2) -{ - (void)world; - - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(row_1 >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(row_2 >= 0, ECS_INTERNAL_ERROR, NULL); - - check_table_sanity(table); + ecs_entity_t event, + ecs_event_record_t *evt, + ecs_id_t id, + int32_t value) +{ + ecs_event_id_record_t *idt = ensure_event_id_record(&evt->event_ids, id); + ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); - if (row_1 == row_2) { - return; - } - - /* If the table is monitored indicate that there has been a change */ - mark_table_dirty(world, table, 0); - - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - ecs_entity_t e1 = entities[row_1]; - ecs_entity_t e2 = entities[row_2]; - - ecs_record_t **record_ptrs = ecs_vector_first(data->record_ptrs, ecs_record_t*); - ecs_record_t *record_ptr_1 = record_ptrs[row_1]; - ecs_record_t *record_ptr_2 = record_ptrs[row_2]; - - ecs_assert(record_ptr_1 != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(record_ptr_2 != NULL, ECS_INTERNAL_ERROR, NULL); - - /* Keep track of whether entity is watched */ - uint32_t flags_1 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_1->row); - uint32_t flags_2 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_2->row); - - /* Swap entities & records */ - entities[row_1] = e2; - entities[row_2] = e1; - record_ptr_1->row = ECS_ROW_TO_RECORD(row_2, flags_1); - record_ptr_2->row = ECS_ROW_TO_RECORD(row_1, flags_2); - record_ptrs[row_1] = record_ptr_2; - record_ptrs[row_2] = record_ptr_1; - - swap_switch_columns(table, data, row_1, row_2); - swap_bitset_columns(table, data, row_1, row_2); - - ecs_column_t *columns = data->columns; - if (!columns) { - check_table_sanity(table); - return; - } - - /* Swap columns */ - int32_t i, column_count = ecs_vector_count(table->storage_type); - - for (i = 0; i < column_count; i ++) { - int16_t size = columns[i].size; - int16_t alignment = columns[i].alignment; - - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); - - void *ptr = ecs_vector_first_t(columns[i].data, size, alignment); - void *tmp = ecs_os_alloca(size); - - void *el_1 = ECS_OFFSET(ptr, size * row_1); - void *el_2 = ECS_OFFSET(ptr, size * row_2); + int32_t result = idt->trigger_count += value; + if (result == 1) { + /* Notify framework that there are triggers for the event/id. This + * allows parts of the code to skip event evaluation early */ + flecs_notify_tables(world, id, &(ecs_table_event_t){ + .kind = EcsTableTriggersForId, + .event = event + }); + } else if (result == 0) { + /* Ditto, but the reverse */ + flecs_notify_tables(world, id, &(ecs_table_event_t){ + .kind = EcsTableNoTriggersForId, + .event = event + }); - ecs_os_memcpy(tmp, el_1, size); - ecs_os_memcpy(el_1, el_2, size); - ecs_os_memcpy(el_2, tmp, size); + /* Remove admin for id for event */ + if (!ecs_map_is_initialized(&idt->triggers) && + !ecs_map_is_initialized(&idt->set_triggers)) + { + unregister_event_trigger(evt, id); + ecs_os_free(idt); + } } - - check_table_sanity(table); } static -void merge_vector( - ecs_vector_t **dst_out, - ecs_vector_t *src, - int16_t size, - int16_t alignment) +void register_trigger_for_id( + ecs_world_t *world, + ecs_observable_t *observable, + ecs_trigger_t *trigger, + ecs_id_t id, + size_t triggers_offset) { - ecs_vector_t *dst = *dst_out; - int32_t dst_count = ecs_vector_count(dst); + ecs_sparse_t *events = observable->events; + ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_id_t term_id = trigger->term.id; - if (!dst_count) { - if (dst) { - ecs_vector_free(dst); + int i; + for (i = 0; i < trigger->event_count; i ++) { + ecs_entity_t event = get_actual_event(trigger, trigger->events[i]); + + /* Get triggers for event */ + ecs_event_record_t *evt = flecs_sparse_ensure( + events, ecs_event_record_t, event); + ecs_assert(evt != NULL, ECS_INTERNAL_ERROR, NULL); + + if (!ecs_map_is_initialized(&evt->event_ids)) { + ecs_map_init(&evt->event_ids, ecs_event_id_record_t*, 1); } - *dst_out = src; - - /* If the new table is not empty, copy the contents from the - * src into the dst. */ - } else { - int32_t src_count = ecs_vector_count(src); - ecs_vector_set_count_t(&dst, size, alignment, dst_count + src_count); - - void *dst_ptr = ecs_vector_first_t(dst, size, alignment); - void *src_ptr = ecs_vector_first_t(src, size, alignment); + /* Get triggers for (component) id for event */ + ecs_event_id_record_t *idt = ensure_event_id_record( + &evt->event_ids, id); + ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); - dst_ptr = ECS_OFFSET(dst_ptr, size * dst_count); - - ecs_os_memcpy(dst_ptr, src_ptr, size * src_count); + ecs_map_t *triggers = ECS_OFFSET(idt, triggers_offset); + if (!ecs_map_is_initialized(triggers)) { + ecs_map_init(triggers, ecs_trigger_t*, 1); + } - ecs_vector_free(src); - *dst_out = dst; + ecs_map_ensure(triggers, ecs_trigger_t*, trigger->id)[0] = trigger; + + inc_trigger_count(world, event, evt, term_id, 1); + if (term_id != id) { + inc_trigger_count(world, event, evt, id, 1); + } } } static -void merge_column( +void register_trigger( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - int32_t column_id, - ecs_vector_t *src) + ecs_observable_t *observable, + ecs_trigger_t *trigger) { - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - ecs_type_info_t *ti = table->type_info[column_id]; - ecs_column_t *column = &data->columns[column_id]; - ecs_vector_t *dst = column->data; - int16_t size = column->size; - int16_t alignment = column->alignment; - int32_t dst_count = ecs_vector_count(dst); + ecs_term_t *term = &trigger->term; - if (!dst_count) { - if (dst) { - ecs_vector_free(dst); + if (term->subj.set.mask & EcsSelf) { + if (term->subj.entity == EcsThis) { + register_trigger_for_id(world, observable, trigger, term->id, + offsetof(ecs_event_id_record_t, triggers)); + } else { + register_trigger_for_id(world, observable, trigger, term->id, + offsetof(ecs_event_id_record_t, entity_triggers)); } + } - column->data = src; - - /* If the new table is not empty, copy the contents from the - * src into the dst. */ - } else { - int32_t src_count = ecs_vector_count(src); - ecs_vector_set_count_t(&dst, size, alignment, dst_count + src_count); - column->data = dst; - - /* Construct new values */ - if (ti) { - ctor_component(world, ti, column, entities, dst_count, src_count); - } - - void *dst_ptr = ecs_vector_first_t(dst, size, alignment); - void *src_ptr = ecs_vector_first_t(src, size, alignment); + if (trigger->term.subj.set.mask & EcsSuperSet) { + ecs_id_t pair = ecs_pair(term->subj.set.relation, EcsWildcard); + register_trigger_for_id(world, observable, trigger, pair, + offsetof(ecs_event_id_record_t, set_triggers)); + } - dst_ptr = ECS_OFFSET(dst_ptr, size * dst_count); - - /* Move values into column */ - ecs_move_t move; - if (ti && (move = ti->lifecycle.move)) { - move(world, entities, entities, dst_ptr, src_ptr, src_count, ti); - } else { - ecs_os_memcpy(dst_ptr, src_ptr, size * src_count); - } + if (ECS_HAS_ROLE(term->id, SWITCH)) { + ecs_entity_t sw = term->id & ECS_COMPONENT_MASK; + ecs_id_t sw_case = ecs_case(sw, EcsWildcard); + register_trigger_for_id(world, observable, trigger, sw_case, + offsetof(ecs_event_id_record_t, triggers)); + } - ecs_vector_free(src); + if (ECS_HAS_ROLE(term->id, CASE)) { + ecs_entity_t sw = ECS_PAIR_FIRST(term->id); + register_trigger_for_id(world, observable, trigger, ECS_SWITCH | sw, + offsetof(ecs_event_id_record_t, triggers)); } } static -void merge_table_data( +void unregister_trigger_for_id( ecs_world_t *world, - ecs_table_t *new_table, - ecs_table_t *old_table, - int32_t old_count, - int32_t new_count, - ecs_data_t *old_data, - ecs_data_t *new_data) + ecs_observable_t *observable, + ecs_trigger_t *trigger, + ecs_id_t id, + size_t triggers_offset) { - ecs_type_t new_type = new_table->storage_type; - ecs_type_t old_type = old_table->storage_type; - int32_t i_new = 0, new_column_count = ecs_vector_count(new_type); - int32_t i_old = 0, old_column_count = ecs_vector_count(old_type); - ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); - ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - - ecs_column_t *old_columns = old_data->columns; - ecs_column_t *new_columns = new_data->columns; - - if (!new_columns && !new_data->entities) { - new_columns = new_data->columns; - } - - ecs_assert(!new_column_count || new_columns, ECS_INTERNAL_ERROR, NULL); - - if (!old_count) { - return; - } + ecs_sparse_t *events = observable->events; + ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_id_t term_id = trigger->term.id; - /* Merge entities */ - merge_vector(&new_data->entities, old_data->entities, ECS_SIZEOF(ecs_entity_t), - ECS_ALIGNOF(ecs_entity_t)); - old_data->entities = NULL; - ecs_entity_t *entities = ecs_vector_first(new_data->entities, ecs_entity_t); + int i; + for (i = 0; i < trigger->event_count; i ++) { + ecs_entity_t event = get_actual_event(trigger, trigger->events[i]); - ecs_assert(ecs_vector_count(new_data->entities) == old_count + new_count, - ECS_INTERNAL_ERROR, NULL); + /* Get triggers for event */ + ecs_event_record_t *evt = flecs_sparse_get( + events, ecs_event_record_t, event); + ecs_assert(evt != NULL, ECS_INTERNAL_ERROR, NULL); - /* Merge entity index record pointers */ - merge_vector(&new_data->record_ptrs, old_data->record_ptrs, - ECS_SIZEOF(ecs_record_t*), ECS_ALIGNOF(ecs_record_t*)); - old_data->record_ptrs = NULL; + /* Get triggers for (component) id */ + ecs_event_id_record_t *idt = ecs_map_get_ptr( + &evt->event_ids, ecs_event_id_record_t*, id); + ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); - for (; (i_new < new_column_count) && (i_old < old_column_count); ) { - ecs_entity_t new_component = new_components[i_new]; - ecs_entity_t old_component = old_components[i_old]; - int16_t size = new_columns[i_new].size; - int16_t alignment = new_columns[i_new].alignment; - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); + ecs_map_t *id_triggers = ECS_OFFSET(idt, triggers_offset); - if (new_component == old_component) { - merge_column(world, new_table, new_data, i_new, - old_columns[i_old].data); - old_columns[i_old].data = NULL; + if (ecs_map_remove(id_triggers, trigger->id) == 0) { + ecs_map_fini(id_triggers); + } - /* Mark component column as dirty */ - mark_table_dirty(world, new_table, i_new + 1); - - i_new ++; - i_old ++; - } else if (new_component < old_component) { - /* New column does not occur in old table, make sure vector is large - * enough. */ - ecs_column_t *column = &new_columns[i_new]; - ecs_vector_set_count_t(&column->data, size, alignment, - old_count + new_count); + inc_trigger_count(world, event, evt, term_id, -1); - /* Construct new values */ - ecs_type_info_t *c_info = new_table->type_info[i_new]; - if (c_info) { - ctor_component(world, c_info, column, - entities, 0, old_count + new_count); - } - - i_new ++; - } else if (new_component > old_component) { - ecs_column_t *column = &old_columns[i_old]; - - /* Destruct old values */ - ecs_type_info_t *c_info = old_table->type_info[i_old]; - if (c_info) { - dtor_component(world, old_table, c_info, column, - entities, 0, 0, old_count, false); + if (id != term_id) { + /* Id is different from term_id in case of a set trigger. If they're + * the same, inc_trigger_count could already have done cleanup */ + if (!ecs_map_is_initialized(&idt->triggers) && + !ecs_map_is_initialized(&idt->set_triggers) && + !idt->trigger_count) + { + unregister_event_trigger(evt, id); } - /* Old column does not occur in new table, remove */ - ecs_vector_free(column->data); - column->data = NULL; - - i_old ++; + inc_trigger_count(world, event, evt, id, -1); } } +} - move_switch_columns(new_table, new_data, new_count, old_table, old_data, 0, - old_count, true); - move_bitset_columns(new_table, new_data, new_count, old_table, old_data, 0, - old_count, true); +static +void unregister_trigger( + ecs_world_t *world, + ecs_observable_t *observable, + ecs_trigger_t *trigger) +{ + ecs_term_t *term = &trigger->term; - /* Initialize remaining columns */ - for (; i_new < new_column_count; i_new ++) { - ecs_column_t *column = &new_columns[i_new]; - int16_t size = column->size; - int16_t alignment = column->alignment; - ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); + if (term->subj.set.mask & EcsSelf) { + if (term->subj.entity == EcsThis) { + unregister_trigger_for_id(world, observable, trigger, term->id, + offsetof(ecs_event_id_record_t, triggers)); + } else { + unregister_trigger_for_id(world, observable, trigger, term->id, + offsetof(ecs_event_id_record_t, entity_triggers)); + } + } - ecs_vector_set_count_t(&column->data, size, alignment, - old_count + new_count); + if (term->subj.set.mask & EcsSuperSet) { + ecs_id_t pair = ecs_pair(term->subj.set.relation, EcsWildcard); + unregister_trigger_for_id(world, observable, trigger, pair, + offsetof(ecs_event_id_record_t, set_triggers)); + } - /* Construct new values */ - ecs_type_info_t *c_info = new_table->type_info[i_new]; - if (c_info) { - ctor_component(world, c_info, column, - entities, 0, old_count + new_count); - } + if (ECS_HAS_ROLE(term->id, SWITCH)) { + ecs_entity_t sw = term->id & ECS_COMPONENT_MASK; + ecs_id_t sw_case = ecs_case(sw, EcsWildcard); + unregister_trigger_for_id(world, observable, trigger, sw_case, + offsetof(ecs_event_id_record_t, triggers)); } - /* Destroy remaining columns */ - for (; i_old < old_column_count; i_old ++) { - ecs_column_t *column = &old_columns[i_old]; + if (ECS_HAS_ROLE(term->id, CASE)) { + ecs_entity_t sw = ECS_PAIR_FIRST(term->id); + unregister_trigger_for_id(world, observable, trigger, ECS_SWITCH | sw, + offsetof(ecs_event_id_record_t, triggers)); + } +} - /* Destruct old values */ - ecs_type_info_t *c_info = old_table->type_info[i_old]; - if (c_info) { - dtor_component(world, old_table, c_info, column, entities, 0, - 0, old_count, false); - } +static +ecs_map_t* get_triggers_for_event( + const ecs_observable_t *observable, + ecs_entity_t event) +{ + ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(event != 0, ECS_INTERNAL_ERROR, NULL); - /* Old column does not occur in new table, remove */ - ecs_vector_free(column->data); - column->data = NULL; - } + ecs_sparse_t *events = observable->events; + ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); - /* Mark entity column as dirty */ - mark_table_dirty(world, new_table, 0); + const ecs_event_record_t *evt = flecs_sparse_get( + events, ecs_event_record_t, event); + + if (evt) { + return (ecs_map_t*)&evt->event_ids; + } + +error: + return NULL; } -int32_t ecs_table_count( - const ecs_table_t *table) +static +ecs_event_id_record_t* get_triggers_for_id( + const ecs_map_t *evt, + ecs_id_t id) { - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - return flecs_table_data_count(&table->storage); + return ecs_map_get_ptr(evt, ecs_event_id_record_t*, id); } -void flecs_table_merge( - ecs_world_t *world, - ecs_table_t *new_table, - ecs_table_t *old_table, - ecs_data_t *new_data, - ecs_data_t *old_data) -{ - ecs_assert(old_table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!old_table->lock, ECS_LOCKED_STORAGE, NULL); +bool flecs_check_triggers_for_event( + const ecs_poly_t *object, + ecs_id_t id, + ecs_entity_t event) +{ + ecs_observable_t *observable = ecs_get_observable(object); + const ecs_map_t *evt = get_triggers_for_event(observable, event); + if (!evt) { + return false; + } - check_table_sanity(new_table); - check_table_sanity(old_table); - - bool move_data = false; - - /* If there is nothing to merge to, just clear the old table */ - if (!new_table) { - flecs_table_clear_data(world, old_table, old_data); - check_table_sanity(old_table); - return; + ecs_event_id_record_t *edr = get_triggers_for_id(evt, id); + if (edr) { + return edr->trigger_count != 0; } else { - ecs_assert(!new_table->lock, ECS_LOCKED_STORAGE, NULL); + return false; } +} - /* If there is no data to merge, drop out */ - if (!old_data) { +static +void init_iter( + ecs_iter_t *it, + bool *iter_set) +{ + ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL); + + if (*iter_set) { return; } - if (!new_data) { - new_data = &new_table->storage; - if (new_table == old_table) { - move_data = true; - } + if (it->table_only) { + it->ids = it->priv.cache.ids; + it->ids[0] = it->event_id; + return; } - ecs_entity_t *old_entities = ecs_vector_first(old_data->entities, ecs_entity_t); - int32_t old_count = ecs_vector_count(old_data->entities); - int32_t new_count = ecs_vector_count(new_data->entities); + flecs_iter_init(it); - ecs_record_t **old_records = ecs_vector_first( - old_data->record_ptrs, ecs_record_t*); + *iter_set = true; - /* First, update entity index so old entities point to new type */ - int32_t i; - for(i = 0; i < old_count; i ++) { - ecs_record_t *record; - if (new_table != old_table) { - record = old_records[i]; - ecs_assert(record != NULL, ECS_INTERNAL_ERROR, NULL); - } else { - record = ecs_eis_ensure(world, old_entities[i]); - } + it->ids[0] = it->event_id; - uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row); - record->row = ECS_ROW_TO_RECORD(new_count + i, flags); - record->table = new_table; - } + ecs_assert(it->table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!it->count || it->offset < ecs_table_count(it->table), + ECS_INTERNAL_ERROR, NULL); + ecs_assert((it->offset + it->count) <= ecs_table_count(it->table), + ECS_INTERNAL_ERROR, NULL); - /* Merge table columns */ - if (move_data) { - *new_data = *old_data; + int32_t index = ecs_search_relation(it->world, it->table, 0, + it->event_id, EcsIsA, 0, 0, it->subjects, NULL, NULL); + + if (index == -1) { + it->columns[0] = 0; + } else if (it->subjects[0]) { + it->columns[0] = -index - 1; } else { - merge_table_data(world, new_table, old_table, old_count, new_count, - old_data, new_data); + it->columns[0] = index + 1; } - new_table->alloc_count ++; + ecs_term_t term = { + .id = it->event_id + }; - if (old_count) { - if (!new_count) { - flecs_table_set_empty(world, new_table); - } - flecs_table_set_empty(world, old_table); - } + it->term_count = 1; + it->terms = &term; + flecs_iter_populate_data(it->world, it, it->table, it->offset, + it->count, it->ptrs, it->sizes); +} - check_table_sanity(old_table); - check_table_sanity(new_table); -} - -void flecs_table_replace_data( +static +bool ignore_trigger( ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data) + ecs_trigger_t *t, + ecs_table_t *table) { - int32_t prev_count = 0; - ecs_data_t *table_data = &table->storage; - ecs_assert(!data || data != table_data, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - - check_table_sanity(table); - - prev_count = ecs_vector_count(table_data->entities); - run_on_remove(world, table, table_data); - flecs_table_clear_data(world, table, table_data); - - if (data) { - table->storage = *data; - } else { - flecs_table_init_data(world, table); + int32_t *last_event_id = t->last_event_id; + if (last_event_id && last_event_id[0] == world->event_id) { + return true; } - int32_t count = ecs_table_count(table); - - if (!prev_count && count) { - flecs_table_set_empty(world, table); - } else if (prev_count && !count) { - flecs_table_set_empty(world, table); + if (!table) { + return false; } - table->alloc_count ++; - - check_table_sanity(table); -} - -int32_t* flecs_table_get_dirty_state( - ecs_table_t *table) -{ - if (!table->dirty_state) { - int32_t column_count = ecs_vector_count(table->storage_type); - table->dirty_state = ecs_os_malloc_n( int32_t, column_count + 1); - ecs_assert(table->dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); - - for (int i = 0; i < column_count + 1; i ++) { - table->dirty_state[i] = 1; - } + if (!t->match_prefab && (table->flags & EcsTableIsPrefab)) { + return true; } - return table->dirty_state; + if (!t->match_disabled && (table->flags & EcsTableIsDisabled)) { + return true; + } + + return false; } -int32_t* flecs_table_get_monitor( - ecs_table_t *table) +static +void notify_self_triggers( + ecs_world_t *world, + ecs_iter_t *it, + const ecs_map_t *triggers) { - int32_t *dirty_state = flecs_table_get_dirty_state(table); - ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); - int32_t column_count = ecs_vector_count(table->storage_type); - return ecs_os_memdup(dirty_state, (column_count + 1) * ECS_SIZEOF(int32_t)); -} + ecs_map_iter_t mit = ecs_map_iter(triggers); + ecs_trigger_t *t; + while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { + if (ignore_trigger(world, t, it->table)) { + continue; + } -void flecs_table_notify( - ecs_world_t *world, - ecs_table_t *table, - ecs_table_event_t *event) -{ - if (world->is_fini) { - return; - } + it->is_filter = t->term.inout == EcsInOutFilter; + it->system = t->entity; + it->self = t->self; + it->ctx = t->ctx; + it->binding_ctx = t->binding_ctx; + it->term_index = t->term.index; + it->terms = &t->term; - switch(event->kind) { - case EcsTableTriggersForId: - notify_trigger(world, table, event->event); - break; - case EcsTableNoTriggersForId: - break; + t->callback(it); } } -void ecs_table_lock( +static +void notify_entity_triggers( ecs_world_t *world, - ecs_table_t *table) + ecs_iter_t *it, + const ecs_map_t *triggers) { - if (table) { - if (ecs_poly_is(world, ecs_world_t) && !world->is_readonly) { - table->lock ++; - } - } -} + ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); -void ecs_table_unlock( - ecs_world_t *world, - ecs_table_t *table) -{ - if (table) { - if (ecs_poly_is(world, ecs_world_t) && !world->is_readonly) { - table->lock --; - ecs_assert(table->lock >= 0, ECS_INVALID_OPERATION, NULL); - } + if (it->table_only) { + return; } -} -bool ecs_table_has_module( - ecs_table_t *table) -{ - return table->flags & EcsTableHasModule; -} + ecs_map_iter_t mit = ecs_map_iter(triggers); + ecs_trigger_t *t; + int32_t offset = it->offset, count = it->count; + ecs_entity_t *entities = it->entities; + + ecs_entity_t dummy = 0; + it->entities = &dummy; -ecs_column_t* ecs_table_column_for_id( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_id_t id) -{ - ecs_table_t *storage_table = table->storage_table; - if (!storage_table) { - return NULL; - } + while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { + if (ignore_trigger(world, t, it->table)) { + continue; + } - ecs_table_record_t *tr = flecs_get_table_record(world, storage_table, id); - if (tr) { - return &table->storage.columns[tr->column]; - } + int32_t i, entity_count = it->count; + for (i = 0; i < entity_count; i ++) { + if (entities[i] != t->term.subj.entity) { + continue; + } - return NULL; -} + it->is_filter = t->term.inout == EcsInOutFilter; + it->system = t->entity; + it->self = t->self; + it->ctx = t->ctx; + it->binding_ctx = t->binding_ctx; + it->term_index = t->term.index; + it->terms = &t->term; + it->offset = i; + it->count = 1; + it->subjects[0] = entities[i]; -ecs_type_t ecs_table_get_type( - const ecs_table_t *table) -{ - if (table) { - return table->type; - } else { - return NULL; + t->callback(it); + } } -} -ecs_table_t* ecs_table_get_storage_table( - const ecs_table_t *table) -{ - return table->storage_table; + it->offset = offset; + it->count = count; + it->entities = entities; + it->subjects[0] = 0; } -int32_t ecs_table_storage_count( - const ecs_table_t *table) +static +void notify_set_base_triggers( + ecs_world_t *world, + ecs_iter_t *it, + const ecs_map_t *triggers) { - return ecs_vector_count(table->storage_type); -} + ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); -int32_t ecs_table_type_to_storage_index( - const ecs_table_t *table, - int32_t index) -{ - ecs_assert(index >= 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(index < ecs_vector_count(table->type), - ECS_INVALID_PARAMETER, NULL); - int32_t *storage_map = table->storage_map; - if (storage_map) { - return storage_map[index]; + ecs_entity_t event_id = it->event_id; + ecs_entity_t rel = ECS_PAIR_FIRST(event_id); + ecs_entity_t obj = ecs_pair_second(world, event_id); + ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); + ecs_table_t *obj_table = ecs_get_table(world, obj); + if (!obj_table) { + return; } -error: - return -1; -} -int32_t ecs_table_storage_to_type_index( - const ecs_table_t *table, - int32_t index) -{ - ecs_check(index < ecs_vector_count(table->storage_type), - ECS_INVALID_PARAMETER, NULL); - ecs_check(table->storage_map != NULL, ECS_INVALID_PARAMETER, NULL); - int32_t offset = ecs_vector_count(table->type); - return table->storage_map[offset + index]; -error: - return -1; -} + ecs_map_iter_t mit = ecs_map_iter(triggers); + ecs_trigger_t *t; + while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { + if (ignore_trigger(world, t, it->table)) { + continue; + } -ecs_record_t* ecs_record_find( - const ecs_world_t *world, - ecs_entity_t entity) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL); + ecs_term_t *term = &t->term; + ecs_id_t id = term->id; + int32_t column = ecs_search_relation(world, obj_table, 0, id, rel, + 0, 0, it->subjects, it->ids, 0); + + bool result = column != -1; + if (term->oper == EcsNot) { + result = !result; + } + if (!result) { + continue; + } - world = ecs_get_world(world); + if (!term->subj.set.min_depth && flecs_get_table_record( + world, it->table, id) != NULL) + { + continue; + } - ecs_record_t *r = ecs_eis_get(world, entity); - if (r) { - return r; + if (!it->table_only) { + if (!it->subjects[0]) { + it->subjects[0] = obj; + } + + if (column != -1) { + it->columns[0] = -(column + 1); + } else { + it->columns[0] = 0; + } + } + + it->is_filter = t->term.inout == EcsInOutFilter; + it->event_id = t->term.id; + it->system = t->entity; + it->self = t->self; + it->ctx = t->ctx; + it->binding_ctx = t->binding_ctx; + it->term_index = t->term.index; + it->terms = &t->term; + + t->callback(it); } -error: - return NULL; } -void* ecs_record_get_column( - ecs_record_t *r, - int32_t column, - size_t c_size) +static +void notify_set_triggers( + ecs_world_t *world, + ecs_iter_t *it, + const ecs_map_t *triggers) { - (void)c_size; - ecs_table_t *table = r->table; + ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(it->count != 0, ECS_INTERNAL_ERROR, NULL); - ecs_check(column < ecs_vector_count(table->storage_type), - ECS_INVALID_PARAMETER, NULL); + if (it->table_only) { + return; + } - ecs_column_t *c = &table->storage.columns[column]; - ecs_assert(c != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_map_iter_t mit = ecs_map_iter(triggers); + ecs_trigger_t *t; + while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { + if (!ecs_id_match(it->event_id, t->term.id)) { + continue; + } - ecs_check(!flecs_utosize(c_size) || - flecs_utosize(c_size) == c->size, - ECS_INVALID_PARAMETER, NULL); + if (ignore_trigger(world, t, it->table)) { + continue; + } - return ecs_vector_get_t(c->data, c->size, c->alignment, - ECS_RECORD_TO_ROW(r->row)); -error: - return NULL; -} + ecs_entity_t subj = it->entities[0]; + int32_t i, count = it->count; + ecs_entity_t term_subj = t->term.subj.entity; -#include + /* If trigger is for a specific entity, make sure it is in the table + * being triggered for */ + if (term_subj != EcsThis) { + for (i = 0; i < count; i ++) { + if (it->entities[i] == term_subj) { + break; + } + } -static const char* mixin_kind_str[] = { - [EcsMixinBase] = "base (should never be requested by application)", - [EcsMixinWorld] = "world", - [EcsMixinObservable] = "observable", - [EcsMixinIterable] = "iterable", - [EcsMixinMax] = "max (should never be requested by application)" -}; + if (i == count) { + continue; + } -ecs_mixins_t ecs_world_t_mixins = { - .type_name = "ecs_world_t", - .elems = { - [EcsMixinWorld] = offsetof(ecs_world_t, self), - [EcsMixinObservable] = offsetof(ecs_world_t, observable), - [EcsMixinIterable] = offsetof(ecs_world_t, iterable) - } -}; + /* If the entity matches, trigger for no other entities */ + it->entities[0] = 0; + it->count = 1; + } -ecs_mixins_t ecs_stage_t_mixins = { - .type_name = "ecs_stage_t", - .elems = { - [EcsMixinBase] = offsetof(ecs_stage_t, world), - [EcsMixinWorld] = offsetof(ecs_stage_t, world) - } -}; + if (flecs_term_match_table(world, &t->term, it->table, it->type, + it->ids, it->columns, it->subjects, NULL, true)) + { + if (!it->subjects[0]) { + /* Do not match owned components */ + continue; + } -ecs_mixins_t ecs_query_t_mixins = { - .type_name = "ecs_query_t", - .elems = { - [EcsMixinWorld] = offsetof(ecs_query_t, world), - [EcsMixinIterable] = offsetof(ecs_query_t, iterable) - } -}; + it->is_filter = t->term.inout == EcsInOutFilter; + it->system = t->entity; + it->self = t->self; + it->ctx = t->ctx; + it->binding_ctx = t->binding_ctx; + it->term_index = t->term.index; + it->terms = &t->term; -ecs_mixins_t ecs_filter_t_mixins = { - .type_name = "ecs_filter_t", - .elems = { - [EcsMixinIterable] = offsetof(ecs_filter_t, iterable) + /* Triggers for supersets can be instanced */ + if (it->count == 1 || t->instanced || it->is_filter || !it->sizes[0]) { + it->is_instanced = t->instanced; + t->callback(it); + it->is_instanced = false; + } else { + ecs_entity_t *entities = it->entities; + it->count = 1; + for (i = 0; i < count; i ++) { + it->entities = &entities[i]; + t->callback(it); + } + it->entities = entities; + } + } + + it->entities[0] = subj; + it->count = count; } -}; +} static -void* get_mixin( - const ecs_poly_t *poly, - ecs_mixin_kind_t kind) +void notify_triggers_for_id( + ecs_world_t *world, + const ecs_map_t *evt, + ecs_id_t event_id, + ecs_iter_t *it, + bool *iter_set) { - ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(kind < EcsMixinMax, ECS_INVALID_PARAMETER, NULL); - - const ecs_header_t *hdr = poly; - ecs_assert(hdr != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); - - const ecs_mixins_t *mixins = hdr->mixins; - if (!mixins) { - /* Object has no mixins */ - goto not_found; + const ecs_event_id_record_t *idt = get_triggers_for_id(evt, event_id); + if (!idt) { + return; } - ecs_size_t offset = mixins->elems[kind]; - if (offset == 0) { - /* Object has mixins but not the requested one. Try to find the mixin - * in the poly's base */ - goto find_in_base; + if (ecs_map_is_initialized(&idt->triggers)) { + init_iter(it, iter_set); + notify_self_triggers(world, it, &idt->triggers); } - - /* Object has mixin, return its address */ - return ECS_OFFSET(hdr, offset); - -find_in_base: - if (offset) { - /* If the poly has a base, try to find the mixin in the base */ - ecs_poly_t *base = *(ecs_poly_t**)ECS_OFFSET(hdr, offset); - if (base) { - return get_mixin(base, kind); - } + if (ecs_map_is_initialized(&idt->entity_triggers)) { + init_iter(it, iter_set); + notify_entity_triggers(world, it, &idt->entity_triggers); + } + if (ecs_map_is_initialized(&idt->set_triggers)) { + init_iter(it, iter_set); + notify_set_base_triggers(world, it, &idt->set_triggers); } - -not_found: - /* Mixin wasn't found for poly */ - return NULL; } static -void* assert_mixin( - const ecs_poly_t *poly, - ecs_mixin_kind_t kind) +void notify_set_triggers_for_id( + ecs_world_t *world, + const ecs_map_t *evt, + ecs_iter_t *it, + bool *iter_set, + ecs_id_t set_id) { - void *ptr = get_mixin(poly, kind); - if (!ptr) { - const ecs_header_t *header = poly; - const ecs_mixins_t *mixins = header->mixins; - ecs_err("%s not available for type %s", - mixin_kind_str[kind], - mixins ? mixins->type_name : "unknown"); - ecs_os_abort(); + const ecs_event_id_record_t *idt = get_triggers_for_id(evt, set_id); + if (idt && ecs_map_is_initialized(&idt->set_triggers)) { + init_iter(it, iter_set); + notify_set_triggers(world, it, &idt->set_triggers); } - - return ptr; } -void* _ecs_poly_init( - ecs_poly_t *poly, - int32_t type, - ecs_size_t size, - ecs_mixins_t *mixins) +static +void trigger_yield_existing( + ecs_world_t *world, + ecs_trigger_t *trigger) { - ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_iter_action_t callback = trigger->callback; - ecs_header_t *hdr = poly; - ecs_os_memset(poly, 0, size); + /* If yield existing is enabled, trigger for each thing that matches + * the event, if the event is iterable. */ + int i, count = trigger->event_count; + for (i = 0; i < count; i ++) { + ecs_entity_t evt = trigger->events[i]; + const EcsIterable *iterable = ecs_get(world, evt, EcsIterable); + if (!iterable) { + continue; + } - hdr->magic = ECS_OBJECT_MAGIC; - hdr->type = type; - hdr->mixins = mixins; + ecs_iter_t it; + iterable->init(world, world, &it, &trigger->term); + it.system = trigger->entity; + it.ctx = trigger->ctx; + it.binding_ctx = trigger->binding_ctx; + it.event = evt; - return poly; + ecs_iter_next_action_t next = it.next; + ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL); + while (next(&it)) { + it.event_id = it.ids[0]; + callback(&it); + } + } } -void _ecs_poly_fini( - ecs_poly_t *poly, - int32_t type) +void flecs_triggers_notify( + ecs_iter_t *it, + ecs_observable_t *observable, + ecs_ids_t *ids, + ecs_entity_t event) { - ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); - (void)type; + ecs_assert(ids != NULL && ids->count != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ids->array != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t events[2] = {event, EcsWildcard}; + int32_t e, i, ids_count = ids->count; + ecs_id_t *ids_array = ids->array; + ecs_world_t *world = it->real_world; - ecs_header_t *hdr = poly; + for (e = 0; e < 2; e ++) { + event = events[e]; + const ecs_map_t *evt = get_triggers_for_event(observable, event); + if (!evt) { + continue; + } - /* Don't deinit poly that wasn't initialized */ - ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); - ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER, NULL); - hdr->magic = 0; -} + it->event = event; -#define assert_object(cond, file, line)\ - _ecs_assert((cond), ECS_INVALID_PARAMETER, #cond, file, line, NULL);\ - assert(cond) + for (i = 0; i < ids_count; i ++) { + ecs_id_t id = ids_array[i]; + ecs_entity_t role = id & ECS_ROLE_MASK; + bool iter_set = false; -#ifndef FLECS_NDEBUG -void _ecs_poly_assert( - const ecs_poly_t *poly, - int32_t type, - const char *file, - int32_t line) -{ - assert_object(poly != NULL, file, line); - - const ecs_header_t *hdr = poly; - assert_object(hdr->magic == ECS_OBJECT_MAGIC, file, line); - assert_object(hdr->type == type, file, line); + it->event_id = id; + + notify_triggers_for_id(world, evt, id, it, &iter_set); + + if (role == ECS_PAIR || role == ECS_CASE) { + ecs_entity_t pred = ECS_PAIR_FIRST(id); + ecs_entity_t obj = ECS_PAIR_SECOND(id); + + ecs_id_t tid = role | ecs_entity_t_comb(EcsWildcard, pred); + notify_triggers_for_id(world, evt, tid, it, &iter_set); + + tid = role | ecs_entity_t_comb(obj, EcsWildcard); + notify_triggers_for_id(world, evt, tid, it, &iter_set); + + tid = role | ecs_entity_t_comb(EcsWildcard, EcsWildcard); + notify_triggers_for_id(world, evt, tid, it, &iter_set); + } else { + notify_triggers_for_id(world, evt, EcsWildcard, it, &iter_set); + } + } + } } -#endif -bool _ecs_poly_is( - const ecs_poly_t *poly, - int32_t type) +void flecs_set_triggers_notify( + ecs_iter_t *it, + ecs_observable_t *observable, + ecs_ids_t *ids, + ecs_entity_t event, + ecs_id_t set_id) { - ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(ids != NULL && ids->count != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ids->array != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t events[2] = {event, EcsWildcard}; + int32_t e, i, ids_count = ids->count; + ecs_id_t *ids_array = ids->array; + ecs_world_t *world = it->real_world; - const ecs_header_t *hdr = poly; - ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); - return hdr->type == type; + for (e = 0; e < 2; e ++) { + event = events[e]; + const ecs_map_t *evt = get_triggers_for_event(observable, event); + if (!evt) { + continue; + } + + it->event = event; + + for (i = 0; i < ids_count; i ++) { + ecs_id_t id = ids_array[i]; + bool iter_set = false; + + it->event_id = id; + + notify_set_triggers_for_id(world, evt, it, &iter_set, set_id); + } + } } -ecs_iterable_t* ecs_get_iterable( - const ecs_poly_t *poly) +ecs_entity_t ecs_trigger_init( + ecs_world_t *world, + const ecs_trigger_desc_t *desc) { - return (ecs_iterable_t*)assert_mixin(poly, EcsMixinIterable); + char *name = NULL; + + ecs_poly_assert(world, ecs_world_t); + ecs_check(!world->is_readonly, ECS_INVALID_OPERATION, NULL); + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); + + const char *expr = desc->expr; + ecs_trigger_t *trigger = NULL; + + ecs_observable_t *observable = desc->observable; + if (!observable) { + observable = ecs_get_observable(world); + } + + /* If entity is provided, create it */ + ecs_entity_t existing = desc->entity.entity; + ecs_entity_t entity = ecs_entity_init(world, &desc->entity); + if (!existing && !desc->entity.name) { + ecs_add_pair(world, entity, EcsChildOf, EcsFlecsHidden); + } + + bool added = false; + EcsTrigger *comp = ecs_get_mut(world, entity, EcsTrigger, &added); + if (added) { + ecs_check(desc->callback != NULL, ECS_INVALID_PARAMETER, NULL); + + /* Something went wrong with the construction of the entity */ + ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL); + name = ecs_get_fullpath(world, entity); + + ecs_term_t term; + if (expr) { + #ifdef FLECS_PARSER + const char *ptr = ecs_parse_term(world, name, expr, expr, &term); + if (!ptr) { + goto error; + } + + if (!ecs_term_is_initialized(&term)) { + ecs_parser_error( + name, expr, 0, "invalid empty trigger expression"); + goto error; + } + + if (ptr[0]) { + ecs_parser_error(name, expr, 0, + "too many terms in trigger expression (expected 1)"); + goto error; + } + #else + ecs_abort(ECS_UNSUPPORTED, "parser addon is not available"); + #endif + } else { + term = ecs_term_copy(&desc->term); + } + + if (ecs_term_finalize(world, name, &term)) { + ecs_term_fini(&term); + goto error; + } + + trigger = flecs_sparse_add(world->triggers, ecs_trigger_t); + trigger->id = flecs_sparse_last_id(world->triggers); + + trigger->term = ecs_term_move(&term); + trigger->callback = desc->callback; + trigger->ctx = desc->ctx; + trigger->binding_ctx = desc->binding_ctx; + trigger->ctx_free = desc->ctx_free; + trigger->binding_ctx_free = desc->binding_ctx_free; + trigger->event_count = count_events(desc->events); + ecs_os_memcpy(trigger->events, desc->events, + trigger->event_count * ECS_SIZEOF(ecs_entity_t)); + trigger->entity = entity; + trigger->self = desc->self; + trigger->observable = observable; + trigger->match_prefab = desc->match_prefab; + trigger->match_disabled = desc->match_disabled; + trigger->instanced = desc->instanced; + trigger->last_event_id = desc->last_event_id; + + if (trigger->term.id == EcsPrefab) { + trigger->match_prefab = true; + } + if (trigger->term.id == EcsDisabled) { + trigger->match_disabled = true; + } + + comp->trigger = trigger; + + /* Trigger must have at least one event */ + ecs_check(trigger->event_count != 0, ECS_INVALID_PARAMETER, NULL); + + register_trigger(world, observable, trigger); + + ecs_term_fini(&term); + + if (desc->entity.name) { + ecs_trace("#[green]trigger#[reset] %s created", + ecs_get_name(world, entity)); + } + + if (desc->yield_existing) { + trigger_yield_existing(world, trigger); + } + } else { + ecs_assert(comp->trigger != NULL, ECS_INTERNAL_ERROR, NULL); + + /* If existing entity handle was provided, override existing params */ + if (existing) { + if (desc->callback) { + ((ecs_trigger_t*)comp->trigger)->callback = desc->callback; + } + if (desc->ctx) { + ((ecs_trigger_t*)comp->trigger)->ctx = desc->ctx; + } + if (desc->binding_ctx) { + ((ecs_trigger_t*)comp->trigger)->binding_ctx = desc->binding_ctx; + } + } + } + + ecs_os_free(name); + return entity; +error: + ecs_os_free(name); + ecs_delete(world, entity); + return 0; } -ecs_observable_t* ecs_get_observable( - const ecs_poly_t *poly) +void* ecs_get_trigger_ctx( + const ecs_world_t *world, + ecs_entity_t trigger) { - return (ecs_observable_t*)assert_mixin(poly, EcsMixinObservable); + const EcsTrigger *t = ecs_get(world, trigger, EcsTrigger); + if (t) { + return t->trigger->ctx; + } else { + return NULL; + } } -const ecs_world_t* ecs_get_world( - const ecs_poly_t *poly) +void* ecs_get_trigger_binding_ctx( + const ecs_world_t *world, + ecs_entity_t trigger) { - return *(ecs_world_t**)assert_mixin(poly, EcsMixinWorld); + const EcsTrigger *t = ecs_get(world, trigger, EcsTrigger); + if (t) { + return t->trigger->binding_ctx; + } else { + return NULL; + } +} + +void flecs_trigger_fini( + ecs_world_t *world, + ecs_trigger_t *trigger) +{ + unregister_trigger(world, trigger->observable, trigger); + ecs_term_fini(&trigger->term); + + if (trigger->ctx_free) { + trigger->ctx_free(trigger->ctx); + } + + if (trigger->binding_ctx_free) { + trigger->binding_ctx_free(trigger->binding_ctx); + } + + flecs_sparse_remove(world->triggers, trigger->id); } @@ -8870,1973 +8789,1863 @@ bool flecs_defer_purge( } -static -ecs_defer_op_t* new_defer_op(ecs_stage_t *stage) { - ecs_defer_op_t *result = ecs_vector_add(&stage->defer_queue, ecs_defer_op_t); - ecs_os_memset(result, 0, ECS_SIZEOF(ecs_defer_op_t)); - return result; -} +#ifdef ECS_TARGET_GNU +#pragma GCC diagnostic ignored "-Wimplicit-fallthrough" +#endif -static -bool defer_add_remove( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_defer_op_kind_t op_kind, - ecs_entity_t entity, - ecs_id_t id) -{ - if (stage->defer) { - if (!id) { - return true; - } +/* See explanation below. The hashing function may read beyond the memory passed + * into the hashing function, but only at word boundaries. This should be safe, + * but trips up address sanitizers and valgrind. + * This ensures clean valgrind logs in debug mode & the best perf in release */ +#if !defined(FLECS_NDEBUG) || defined(ADDRESS_SANITIZER) +#ifndef VALGRIND +#define VALGRIND +#endif +#endif - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = op_kind; - op->id = id; - op->is._1.entity = entity; +/* +------------------------------------------------------------------------------- +lookup3.c, by Bob Jenkins, May 2006, Public Domain. + http://burtleburtle.net/bob/c/lookup3.c +------------------------------------------------------------------------------- +*/ - if (op_kind == EcsOpNew) { - world->new_count ++; - } else if (op_kind == EcsOpAdd) { - world->add_count ++; - } else if (op_kind == EcsOpRemove) { - world->remove_count ++; - } +#ifdef ECS_TARGET_MSVC +//FIXME +#else +#include /* attempt to define endianness */ +#endif +#ifdef ECS_TARGET_LINUX +# include /* attempt to define endianness */ +#endif - return true; - } else { - stage->defer ++; - } - - return false; +/* + * My best guess at if you are big-endian or little-endian. This may + * need adjustment. + */ +#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \ + __BYTE_ORDER == __LITTLE_ENDIAN) || \ + (defined(i386) || defined(__i386__) || defined(__i486__) || \ + defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL)) +# define HASH_LITTLE_ENDIAN 1 +#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \ + __BYTE_ORDER == __BIG_ENDIAN) || \ + (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel)) +# define HASH_LITTLE_ENDIAN 0 +#else +# define HASH_LITTLE_ENDIAN 0 +#endif + +#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) + +/* +------------------------------------------------------------------------------- +mix -- mix 3 32-bit values reversibly. +This is reversible, so any information in (a,b,c) before mix() is +still in (a,b,c) after mix(). +If four pairs of (a,b,c) inputs are run through mix(), or through +mix() in reverse, there are at least 32 bits of the output that +are sometimes the same for one pair and different for another pair. +This was tested for: +* pairs that differed by one bit, by two bits, in any combination + of top bits of (a,b,c), or in any combination of bottom bits of + (a,b,c). +* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed + the output delta to a Gray code (a^(a>>1)) so a string of 1's (as + is commonly produced by subtraction) look like a single 1-bit + difference. +* the base values were pseudorandom, all zero but one bit set, or + all zero plus a counter that starts at zero. +Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that +satisfy this are + 4 6 8 16 19 4 + 9 15 3 18 27 15 + 14 9 3 7 17 3 +Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing +for "differ" defined as + with a one-bit base and a two-bit delta. I +used http://burtleburtle.net/bob/hash/avalanche.html to choose +the operations, constants, and arrangements of the variables. +This does not achieve avalanche. There are input bits of (a,b,c) +that fail to affect some output bits of (a,b,c), especially of a. The +most thoroughly mixed value is c, but it doesn't really even achieve +avalanche in c. +This allows some parallelism. Read-after-writes are good at doubling +the number of bits affected, so the goal of mixing pulls in the opposite +direction as the goal of parallelism. I did what I could. Rotates +seem to cost as much as shifts on every machine I could lay my hands +on, and rotates are much kinder to the top and bottom bits, so I used +rotates. +------------------------------------------------------------------------------- +*/ +#define mix(a,b,c) \ +{ \ + a -= c; a ^= rot(c, 4); c += b; \ + b -= a; b ^= rot(a, 6); a += c; \ + c -= b; c ^= rot(b, 8); b += a; \ + a -= c; a ^= rot(c,16); c += b; \ + b -= a; b ^= rot(a,19); a += c; \ + c -= b; c ^= rot(b, 4); b += a; \ +} + +/* +------------------------------------------------------------------------------- +final -- final mixing of 3 32-bit values (a,b,c) into c +Pairs of (a,b,c) values differing in only a few bits will usually +produce values of c that look totally different. This was tested for +* pairs that differed by one bit, by two bits, in any combination + of top bits of (a,b,c), or in any combination of bottom bits of + (a,b,c). +* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed + the output delta to a Gray code (a^(a>>1)) so a string of 1's (as + is commonly produced by subtraction) look like a single 1-bit + difference. +* the base values were pseudorandom, all zero but one bit set, or + all zero plus a counter that starts at zero. +These constants passed: + 14 11 25 16 4 14 24 + 12 14 25 16 4 14 24 +and these came close: + 4 8 15 26 3 22 24 + 10 8 15 26 3 22 24 + 11 8 15 26 3 22 24 +------------------------------------------------------------------------------- +*/ +#define final(a,b,c) \ +{ \ + c ^= b; c -= rot(b,14); \ + a ^= c; a -= rot(c,11); \ + b ^= a; b -= rot(a,25); \ + c ^= b; c -= rot(b,16); \ + a ^= c; a -= rot(c,4); \ + b ^= a; b -= rot(a,14); \ + c ^= b; c -= rot(b,24); \ } + +/* + * hashlittle2: return 2 32-bit hash values + * + * This is identical to hashlittle(), except it returns two 32-bit hash + * values instead of just one. This is good enough for hash table + * lookup with 2^^64 buckets, or if you want a second hash if you're not + * happy with the first, or if you want a probably-unique 64-bit ID for + * the key. *pc is better mixed than *pb, so use *pc first. If you want + * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)". + */ static -void merge_stages( - ecs_world_t *world, - bool force_merge) +void hashlittle2( + const void *key, /* the key to hash */ + size_t length, /* length of the key */ + uint32_t *pc, /* IN: primary initval, OUT: primary hash */ + uint32_t *pb) /* IN: secondary initval, OUT: secondary hash */ { - bool is_stage = ecs_poly_is(world, ecs_stage_t); - ecs_stage_t *stage = flecs_stage_from_world(&world); + uint32_t a,b,c; /* internal state */ + union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ - bool measure_frame_time = world->measure_frame_time; + /* Set up the internal state */ + a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc; + c += *pb; - ecs_time_t t_start; - if (measure_frame_time) { - ecs_os_get_time(&t_start); + u.ptr = key; + if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) { + const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */ + const uint8_t *k8; + (void)k8; + + /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */ + while (length > 12) + { + a += k[0]; + b += k[1]; + c += k[2]; + mix(a,b,c); + length -= 12; + k += 3; } - if (is_stage) { - /* Check for consistency if force_merge is enabled. In practice this - * function will never get called with force_merge disabled for just - * a single stage. */ - if (force_merge || stage->auto_merge) { - ecs_defer_end((ecs_world_t*)stage); - } - } else { - /* Merge stages. Only merge if the stage has auto_merging turned on, or - * if this is a forced merge (like when ecs_merge is called) */ - int32_t i, count = ecs_get_stage_count(world); - for (i = 0; i < count; i ++) { - ecs_stage_t *s = (ecs_stage_t*)ecs_get_stage(world, i); - ecs_poly_assert(s, ecs_stage_t); - if (force_merge || s->auto_merge) { - ecs_defer_end((ecs_world_t*)s); - } - } + /*----------------------------- handle the last (probably partial) block */ + /* + * "k[2]&0xffffff" actually reads beyond the end of the string, but + * then masks off the part it's not allowed to read. Because the + * string is aligned, the masked-off tail is in the same word as the + * rest of the string. Every machine with memory protection I've seen + * does it on word boundaries, so is OK with this. But VALGRIND will + * still catch it and complain. The masking trick does make the hash + * noticably faster for short strings (like English words). + */ +#ifndef VALGRIND + + switch(length) + { + case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; + case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break; + case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break; + case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break; + case 8 : b+=k[1]; a+=k[0]; break; + case 7 : b+=k[1]&0xffffff; a+=k[0]; break; + case 6 : b+=k[1]&0xffff; a+=k[0]; break; + case 5 : b+=k[1]&0xff; a+=k[0]; break; + case 4 : a+=k[0]; break; + case 3 : a+=k[0]&0xffffff; break; + case 2 : a+=k[0]&0xffff; break; + case 1 : a+=k[0]&0xff; break; + case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ } - flecs_eval_component_monitors(world); +#else /* make valgrind happy */ - if (measure_frame_time) { - world->stats.merge_time_total += (float)ecs_time_measure(&t_start); + k8 = (const uint8_t *)k; + switch(length) + { + case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; + case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ + case 10: c+=((uint32_t)k8[9])<<8; /* fall through */ + case 9 : c+=k8[8]; /* fall through */ + case 8 : b+=k[1]; a+=k[0]; break; + case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ + case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */ + case 5 : b+=k8[4]; /* fall through */ + case 4 : a+=k[0]; break; + case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ + case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */ + case 1 : a+=k8[0]; break; + case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ } - world->stats.merge_count_total ++; +#endif /* !valgrind */ - /* If stage is asynchronous, deferring is always enabled */ - if (stage->asynchronous) { - ecs_defer_begin((ecs_world_t*)stage); + } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { + const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */ + const uint8_t *k8; + + /*--------------- all but last block: aligned reads and different mixing */ + while (length > 12) + { + a += k[0] + (((uint32_t)k[1])<<16); + b += k[2] + (((uint32_t)k[3])<<16); + c += k[4] + (((uint32_t)k[5])<<16); + mix(a,b,c); + length -= 12; + k += 6; + } + + /*----------------------------- handle the last (probably partial) block */ + k8 = (const uint8_t *)k; + switch(length) + { + case 12: c+=k[4]+(((uint32_t)k[5])<<16); + b+=k[2]+(((uint32_t)k[3])<<16); + a+=k[0]+(((uint32_t)k[1])<<16); + break; + case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ + case 10: c+=k[4]; + b+=k[2]+(((uint32_t)k[3])<<16); + a+=k[0]+(((uint32_t)k[1])<<16); + break; + case 9 : c+=k8[8]; /* fall through */ + case 8 : b+=k[2]+(((uint32_t)k[3])<<16); + a+=k[0]+(((uint32_t)k[1])<<16); + break; + case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ + case 6 : b+=k[2]; + a+=k[0]+(((uint32_t)k[1])<<16); + break; + case 5 : b+=k8[4]; /* fall through */ + case 4 : a+=k[0]+(((uint32_t)k[1])<<16); + break; + case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ + case 2 : a+=k[0]; + break; + case 1 : a+=k8[0]; + break; + case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ + } + + } else { /* need to read the key one byte at a time */ + const uint8_t *k = (const uint8_t *)key; + + /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ + while (length > 12) + { + a += k[0]; + a += ((uint32_t)k[1])<<8; + a += ((uint32_t)k[2])<<16; + a += ((uint32_t)k[3])<<24; + b += k[4]; + b += ((uint32_t)k[5])<<8; + b += ((uint32_t)k[6])<<16; + b += ((uint32_t)k[7])<<24; + c += k[8]; + c += ((uint32_t)k[9])<<8; + c += ((uint32_t)k[10])<<16; + c += ((uint32_t)k[11])<<24; + mix(a,b,c); + length -= 12; + k += 12; + } + + /*-------------------------------- last block: affect all 32 bits of (c) */ + switch(length) /* all the case statements fall through */ + { + case 12: c+=((uint32_t)k[11])<<24; + case 11: c+=((uint32_t)k[10])<<16; + case 10: c+=((uint32_t)k[9])<<8; + case 9 : c+=k[8]; + case 8 : b+=((uint32_t)k[7])<<24; + case 7 : b+=((uint32_t)k[6])<<16; + case 6 : b+=((uint32_t)k[5])<<8; + case 5 : b+=k[4]; + case 4 : a+=((uint32_t)k[3])<<24; + case 3 : a+=((uint32_t)k[2])<<16; + case 2 : a+=((uint32_t)k[1])<<8; + case 1 : a+=k[0]; + break; + case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ } + } + + final(a,b,c); + *pc=c; *pb=b; } -static -void do_auto_merge( - ecs_world_t *world) +uint64_t flecs_hash( + const void *data, + ecs_size_t length) { - merge_stages(world, false); + uint32_t h_1 = 0; + uint32_t h_2 = 0; + + hashlittle2( + data, + flecs_ito(size_t, length), + &h_1, + &h_2); + + return h_1 | ((uint64_t)h_2 << 32); } + +/** The number of elements in a single chunk */ +#define CHUNK_COUNT (4096) + +/** Compute the chunk index from an id by stripping the first 12 bits */ +#define CHUNK(index) ((int32_t)((uint32_t)index >> 12)) + +/** This computes the offset of an index inside a chunk */ +#define OFFSET(index) ((int32_t)index & 0xFFF) + +/* Utility to get a pointer to the payload */ +#define DATA(array, size, offset) (ECS_OFFSET(array, size * offset)) + +typedef struct chunk_t { + int32_t *sparse; /* Sparse array with indices to dense array */ + void *data; /* Store data in sparse array to reduce + * indirection and provide stable pointers. */ +} chunk_t; + static -void do_manual_merge( - ecs_world_t *world) +chunk_t* chunk_new( + ecs_sparse_t *sparse, + int32_t chunk_index) { - merge_stages(world, true); + int32_t count = ecs_vector_count(sparse->chunks); + chunk_t *chunks; + + if (count <= chunk_index) { + ecs_vector_set_count(&sparse->chunks, chunk_t, chunk_index + 1); + chunks = ecs_vector_first(sparse->chunks, chunk_t); + ecs_os_memset(&chunks[count], 0, (1 + chunk_index - count) * ECS_SIZEOF(chunk_t)); + } else { + chunks = ecs_vector_first(sparse->chunks, chunk_t); + } + + ecs_assert(chunks != NULL, ECS_INTERNAL_ERROR, NULL); + + chunk_t *result = &chunks[chunk_index]; + ecs_assert(result->sparse == NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(result->data == NULL, ECS_INTERNAL_ERROR, NULL); + + /* Initialize sparse array with zero's, as zero is used to indicate that the + * sparse element has not been paired with a dense element. Use zero + * as this means we can take advantage of calloc having a possibly better + * performance than malloc + memset. */ + result->sparse = ecs_os_calloc(ECS_SIZEOF(int32_t) * CHUNK_COUNT); + + /* Initialize the data array with zero's to guarantee that data is + * always initialized. When an entry is removed, data is reset back to + * zero. Initialize now, as this can take advantage of calloc. */ + result->data = ecs_os_calloc(sparse->size * CHUNK_COUNT); + + ecs_assert(result->sparse != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(result->data != NULL, ECS_INTERNAL_ERROR, NULL); + + return result; } -bool flecs_defer_none( - ecs_world_t *world, - ecs_stage_t *stage) +static +void chunk_free( + chunk_t *chunk) { - (void)world; - return (++ stage->defer) == 1; + ecs_os_free(chunk->sparse); + ecs_os_free(chunk->data); } -bool flecs_defer_modified( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_id_t id) +static +chunk_t* get_chunk( + const ecs_sparse_t *sparse, + int32_t chunk_index) { - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpModified; - op->id = id; - op->is._1.entity = entity; - return true; - } else { - stage->defer ++; + if (!sparse->chunks) { + return NULL; + } + if (chunk_index >= ecs_vector_count(sparse->chunks)) { + return NULL; } - - return false; -} -bool flecs_defer_clone( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_entity_t src, - bool clone_value) -{ - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpClone; - op->id = src; - op->is._1.entity = entity; - op->is._1.clone_value = clone_value; - return true; - } else { - stage->defer ++; + /* If chunk_index is below zero, application used an invalid entity id */ + ecs_assert(chunk_index >= 0, ECS_INVALID_PARAMETER, NULL); + chunk_t *result = ecs_vector_get(sparse->chunks, chunk_t, chunk_index); + if (result && !result->sparse) { + return NULL; } - - return false; + + return result; } -bool flecs_defer_delete( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity) +static +chunk_t* get_or_create_chunk( + ecs_sparse_t *sparse, + int32_t chunk_index) { - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpDelete; - op->is._1.entity = entity; - world->delete_count ++; - return true; - } else { - stage->defer ++; + chunk_t *chunk = get_chunk(sparse, chunk_index); + if (chunk) { + return chunk; } - return false; + + return chunk_new(sparse, chunk_index); } -bool flecs_defer_clear( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity) +static +void grow_dense( + ecs_sparse_t *sparse) { - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpClear; - op->is._1.entity = entity; - world->clear_count ++; - return true; - } else { - stage->defer ++; - } - return false; + ecs_vector_add(&sparse->dense, uint64_t); } -bool flecs_defer_on_delete_action( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_id_t id, - ecs_entity_t action) +static +uint64_t strip_generation( + uint64_t *index_out) { - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpOnDeleteAction; - op->id = id; - op->is._1.entity = action; - world->clear_count ++; - return true; - } else { - stage->defer ++; - } - return false; + uint64_t index = *index_out; + uint64_t gen = index & ECS_GENERATION_MASK; + /* Make sure there's no junk in the id */ + ecs_assert(gen == (index & (0xFFFFFFFFull << 32)), + ECS_INVALID_PARAMETER, NULL); + *index_out -= gen; + return gen; } -bool flecs_defer_enable( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_id_t id, - bool enable) +static +void assign_index( + chunk_t * chunk, + uint64_t * dense_array, + uint64_t index, + int32_t dense) { - (void)world; - if (stage->defer) { - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = enable ? EcsOpEnable : EcsOpDisable; - op->is._1.entity = entity; - op->id = id; - return true; - } else { - stage->defer ++; - } - return false; + /* Initialize sparse-dense pair. This assigns the dense index to the sparse + * array, and the sparse index to the dense array .*/ + chunk->sparse[OFFSET(index)] = dense; + dense_array[dense] = index; } -bool flecs_defer_bulk_new( - ecs_world_t *world, - ecs_stage_t *stage, - int32_t count, - ecs_id_t id, - const ecs_entity_t **ids_out) +static +uint64_t inc_gen( + uint64_t index) { - if (stage->defer) { - ecs_entity_t *ids = ecs_os_malloc(count * ECS_SIZEOF(ecs_entity_t)); - world->bulk_new_count ++; - - /* Use ecs_new_id as this is thread safe */ - int i; - for (i = 0; i < count; i ++) { - ids[i] = ecs_new_id(world); - } - - *ids_out = ids; - - /* Store data in op */ - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = EcsOpBulkNew; - op->id = id; - op->is._n.entities = ids; - op->is._n.count = count; - - return true; - } else { - stage->defer ++; - } - - return false; + /* When an index is deleted, its generation is increased so that we can do + * liveliness checking while recycling ids */ + return ECS_GENERATION_INC(index); } -bool flecs_defer_new( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_id_t id) -{ - return defer_add_remove(world, stage, EcsOpNew, entity, id); +static +uint64_t inc_id( + ecs_sparse_t *sparse) +{ + /* Generate a new id. The last issued id could be stored in an external + * variable, such as is the case with the last issued entity id, which is + * stored on the world. */ + return ++ (sparse->max_id[0]); } -bool flecs_defer_add( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_id_t id) -{ - return defer_add_remove(world, stage, EcsOpAdd, entity, id); +static +uint64_t get_id( + const ecs_sparse_t *sparse) +{ + return sparse->max_id[0]; } -bool flecs_defer_remove( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t entity, - ecs_id_t id) +static +void set_id( + ecs_sparse_t *sparse, + uint64_t value) { - return defer_add_remove(world, stage, EcsOpRemove, entity, id); + /* Sometimes the max id needs to be assigned directly, which typically + * happens when the API calls get_or_create for an id that hasn't been + * issued before. */ + sparse->max_id[0] = value; } -bool flecs_defer_set( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_defer_op_kind_t op_kind, - ecs_entity_t entity, - ecs_id_t id, - ecs_size_t size, - const void *value, - void **value_out, - bool *is_added) +/* Pair dense id with new sparse id */ +static +uint64_t create_id( + ecs_sparse_t *sparse, + int32_t dense) { - if (stage->defer) { - world->set_count ++; - if (!size) { - const EcsComponent *cptr = flecs_component_from_id(world, id); - ecs_check(cptr != NULL, ECS_INVALID_PARAMETER, NULL); - size = cptr->size; - } + uint64_t index = inc_id(sparse); + grow_dense(sparse); - ecs_defer_op_t *op = new_defer_op(stage); - op->kind = op_kind; - op->id = id; - op->is._1.entity = entity; - op->is._1.size = size; - op->is._1.value = ecs_os_malloc(size); + chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); + ecs_assert(chunk->sparse[OFFSET(index)] == 0, ECS_INTERNAL_ERROR, NULL); + + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + assign_index(chunk, dense_array, index, dense); + + return index; +} - if (!value) { - value = ecs_get_id(world, entity, id); - if (is_added) { - *is_added = value == NULL; - } - } +/* Create new id */ +static +uint64_t new_index( + ecs_sparse_t *sparse) +{ + ecs_vector_t *dense = sparse->dense; + int32_t dense_count = ecs_vector_count(dense); + int32_t count = sparse->count ++; - const ecs_type_info_t *ti = NULL; - ecs_entity_t real_id = ecs_get_typeid(world, id); - if (real_id) { - ti = flecs_get_type_info(world, real_id); - } + ecs_assert(count <= dense_count, ECS_INTERNAL_ERROR, NULL); - if (value) { - ecs_copy_t copy; - if (ti && (copy = ti->lifecycle.copy_ctor)) { - copy(world, &entity, &entity, op->is._1.value, value, 1, ti); - } else { - ecs_os_memcpy(op->is._1.value, value, size); - } - } else { - ecs_xtor_t ctor; - if (ti && (ctor = ti->lifecycle.ctor)) { - ctor(world, &entity, op->is._1.value, 1, ti); - } - } + if (count < dense_count) { + /* If there are unused elements in the dense array, return first */ + uint64_t *dense_array = ecs_vector_first(dense, uint64_t); + return dense_array[count]; + } else { + return create_id(sparse, count); + } +} - if (value_out) { - *value_out = op->is._1.value; - } +/* Try obtaining a value from the sparse set, don't care about whether the + * provided index matches the current generation count. */ +static +void* try_sparse_any( + const ecs_sparse_t *sparse, + uint64_t index) +{ + strip_generation(&index); - return true; - } else { - stage->defer ++; + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + if (!chunk) { + return NULL; } -error: - return false; + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; + bool in_use = dense && (dense < sparse->count); + if (!in_use) { + return NULL; + } + + ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); + return DATA(chunk->data, sparse->size, offset); } -void flecs_stage_merge_post_frame( - ecs_world_t *world, - ecs_stage_t *stage) +/* Try obtaining a value from the sparse set, make sure it's alive. */ +static +void* try_sparse( + const ecs_sparse_t *sparse, + uint64_t index) { - /* Execute post frame actions */ - ecs_vector_each(stage->post_frame_actions, ecs_action_elem_t, action, { - action->action(world, action->ctx); - }); + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + if (!chunk) { + return NULL; + } - ecs_vector_free(stage->post_frame_actions); - stage->post_frame_actions = NULL; + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; + bool in_use = dense && (dense < sparse->count); + if (!in_use) { + return NULL; + } + + uint64_t gen = strip_generation(&index); + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK; + + if (cur_gen != gen) { + return NULL; + } + + ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); + return DATA(chunk->data, sparse->size, offset); } -void flecs_stage_init( - ecs_world_t *world, - ecs_stage_t *stage) +/* Get value from sparse set when it is guaranteed that the value exists. This + * function is used when values are obtained using a dense index */ +static +void* get_sparse( + const ecs_sparse_t *sparse, + int32_t dense, + uint64_t index) { - ecs_poly_assert(world, ecs_world_t); - - ecs_poly_init(stage, ecs_stage_t); + strip_generation(&index); + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + int32_t offset = OFFSET(index); + + ecs_assert(chunk != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); + (void)dense; - stage->world = world; - stage->thread_ctx = world; - stage->auto_merge = true; - stage->asynchronous = false; + return DATA(chunk->data, sparse->size, offset); } -void flecs_stage_deinit( - ecs_world_t *world, - ecs_stage_t *stage) +/* Swap dense elements. A swap occurs when an element is removed, or when a + * removed element is recycled. */ +static +void swap_dense( + ecs_sparse_t * sparse, + chunk_t * chunk_a, + int32_t a, + int32_t b) { - (void)world; - ecs_poly_assert(world, ecs_world_t); - ecs_poly_assert(stage, ecs_stage_t); + ecs_assert(a != b, ECS_INTERNAL_ERROR, NULL); + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + uint64_t index_a = dense_array[a]; + uint64_t index_b = dense_array[b]; - /* Make sure stage has no unmerged data */ - ecs_assert(ecs_vector_count(stage->defer_queue) == 0, - ECS_INTERNAL_ERROR, NULL); + chunk_t *chunk_b = get_or_create_chunk(sparse, CHUNK(index_b)); + assign_index(chunk_a, dense_array, index_a, b); + assign_index(chunk_b, dense_array, index_b, a); +} - ecs_poly_fini(stage, ecs_stage_t); +void _flecs_sparse_init( + ecs_sparse_t *result, + ecs_size_t size) +{ + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + result->size = size; + result->max_id_local = UINT64_MAX; + result->max_id = &result->max_id_local; - ecs_vector_free(stage->defer_queue); + /* Consume first value in dense array as 0 is used in the sparse array to + * indicate that a sparse element hasn't been paired yet. */ + uint64_t *first = ecs_vector_add(&result->dense, uint64_t); + *first = 0; + + result->count = 1; } -void ecs_set_stages( - ecs_world_t *world, - int32_t stage_count) +ecs_sparse_t* _flecs_sparse_new( + ecs_size_t size) { - ecs_poly_assert(world, ecs_world_t); + ecs_sparse_t *result = ecs_os_calloc_t(ecs_sparse_t); - ecs_stage_t *stages; - int32_t i, count = ecs_vector_count(world->worker_stages); + _flecs_sparse_init(result, size); - if (count && count != stage_count) { - stages = ecs_vector_first(world->worker_stages, ecs_stage_t); + return result; +} - for (i = 0; i < count; i ++) { - /* If stage contains a thread handle, ecs_set_threads was used to - * create the stages. ecs_set_threads and ecs_set_stages should not - * be mixed. */ - ecs_poly_assert(&stages[i], ecs_stage_t); - ecs_check(stages[i].thread == 0, ECS_INVALID_OPERATION, NULL); - flecs_stage_deinit(world, &stages[i]); - } +void flecs_sparse_set_id_source( + ecs_sparse_t * sparse, + uint64_t * id_source) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + sparse->max_id = id_source; +} - ecs_vector_free(world->worker_stages); - } - - if (stage_count) { - world->worker_stages = ecs_vector_new(ecs_stage_t, stage_count); +void flecs_sparse_clear( + ecs_sparse_t *sparse) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - for (i = 0; i < stage_count; i ++) { - ecs_stage_t *stage = ecs_vector_add( - &world->worker_stages, ecs_stage_t); - flecs_stage_init(world, stage); - stage->id = 1 + i; /* 0 is reserved for main/temp stage */ + ecs_vector_each(sparse->chunks, chunk_t, chunk, { + chunk_free(chunk); + }); - /* Set thread_ctx to stage, as this stage might be used in a - * multithreaded context */ - stage->thread_ctx = (ecs_world_t*)stage; - } - } else { - /* Set to NULL to prevent double frees */ - world->worker_stages = NULL; - } + ecs_vector_free(sparse->chunks); + ecs_vector_set_count(&sparse->dense, uint64_t, 1); - /* Regardless of whether the stage was just initialized or not, when the - * ecs_set_stages function is called, all stages inherit the auto_merge - * property from the world */ - for (i = 0; i < stage_count; i ++) { - ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); - stage->auto_merge = world->stage.auto_merge; - } -error: - return; + sparse->chunks = NULL; + sparse->count = 1; + sparse->max_id_local = 0; } -int32_t ecs_get_stage_count( - const ecs_world_t *world) +void _flecs_sparse_fini( + ecs_sparse_t *sparse) { - world = ecs_get_world(world); - return ecs_vector_count(world->worker_stages); + ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL); + flecs_sparse_clear(sparse); + ecs_vector_free(sparse->dense); } -int32_t ecs_get_stage_id( - const ecs_world_t *world) +void flecs_sparse_free( + ecs_sparse_t *sparse) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - - if (ecs_poly_is(world, ecs_stage_t)) { - ecs_stage_t *stage = (ecs_stage_t*)world; - - /* Index 0 is reserved for main stage */ - return stage->id - 1; - } else if (ecs_poly_is(world, ecs_world_t)) { - return 0; - } else { - ecs_throw(ECS_INTERNAL_ERROR, NULL); + if (sparse) { + _flecs_sparse_fini(sparse); + ecs_os_free(sparse); } -error: - return 0; } -ecs_world_t* ecs_get_stage( - const ecs_world_t *world, - int32_t stage_id) +uint64_t flecs_sparse_new_id( + ecs_sparse_t *sparse) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(ecs_vector_count(world->worker_stages) > stage_id, - ECS_INVALID_PARAMETER, NULL); - - return (ecs_world_t*)ecs_vector_get( - world->worker_stages, ecs_stage_t, stage_id); -error: - return NULL; + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + return new_index(sparse); } -bool ecs_staging_begin( - ecs_world_t *world) +const uint64_t* flecs_sparse_new_ids( + ecs_sparse_t *sparse, + int32_t new_count) { - ecs_poly_assert(world, ecs_world_t); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + int32_t dense_count = ecs_vector_count(sparse->dense); + int32_t count = sparse->count; + int32_t remaining = dense_count - count; + int32_t i, to_create = new_count - remaining; - flecs_process_pending_tables(world); + if (to_create > 0) { + flecs_sparse_set_size(sparse, dense_count + to_create); + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - int32_t i, count = ecs_get_stage_count(world); - for (i = 0; i < count; i ++) { - ecs_world_t *stage = ecs_get_stage(world, i); - ((ecs_stage_t*)stage)->lookup_path = world->stage.lookup_path; - ecs_defer_begin(stage); + for (i = 0; i < to_create; i ++) { + uint64_t index = create_id(sparse, count + i); + dense_array[dense_count + i] = index; + } } - bool is_readonly = world->is_readonly; + sparse->count += new_count; - /* From this point on, the world is "locked" for mutations, and it is only - * allowed to enqueue commands from stages */ - world->is_readonly = true; - - ecs_dbg_3("staging: begin"); - - return is_readonly; + return ecs_vector_get(sparse->dense, uint64_t, count); } -void ecs_staging_end( - ecs_world_t *world) +void* _flecs_sparse_add( + ecs_sparse_t *sparse, + ecs_size_t size) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(world->is_readonly == true, ECS_INVALID_OPERATION, NULL); - - /* After this it is safe again to mutate the world directly */ - world->is_readonly = false; - - ecs_dbg_3("staging: end"); - - do_auto_merge(world); -error: - return; + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + uint64_t index = new_index(sparse); + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + ecs_assert(chunk != NULL, ECS_INTERNAL_ERROR, NULL); + return DATA(chunk->data, size, OFFSET(index)); } -void ecs_merge( - ecs_world_t *world) +uint64_t flecs_sparse_last_id( + const ecs_sparse_t *sparse) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(ecs_poly_is(world, ecs_world_t) || - ecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL); - do_manual_merge(world); -error: - return; + ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL); + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + return dense_array[sparse->count - 1]; } -void ecs_set_automerge( - ecs_world_t *world, - bool auto_merge) +void* _flecs_sparse_ensure( + ecs_sparse_t *sparse, + ecs_size_t size, + uint64_t index) { - /* If a world is provided, set auto_merge globally for the world. This - * doesn't actually do anything (the main stage never merges) but it serves - * as the default for when stages are created. */ - if (ecs_poly_is(world, ecs_world_t)) { - world->stage.auto_merge = auto_merge; + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + ecs_assert(ecs_vector_count(sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL); + (void)size; - /* Propagate change to all stages */ - int i, stage_count = ecs_get_stage_count(world); - for (i = 0; i < stage_count; i ++) { - ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); - stage->auto_merge = auto_merge; + uint64_t gen = strip_generation(&index); + chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; + + if (dense) { + /* Check if element is alive. If element is not alive, update indices so + * that the first unused dense element points to the sparse element. */ + int32_t count = sparse->count; + if (dense == count) { + /* If dense is the next unused element in the array, simply increase + * the count to make it part of the alive set. */ + sparse->count ++; + } else if (dense > count) { + /* If dense is not alive, swap it with the first unused element. */ + swap_dense(sparse, chunk, dense, count); + + /* First unused element is now last used element */ + sparse->count ++; + } else { + /* Dense is already alive, nothing to be done */ } - /* If a stage is provided, override the auto_merge value for the individual - * stage. This allows an application to control per-stage which stage should - * be automatically merged and which one shouldn't */ + /* Ensure provided generation matches current. Only allow mismatching + * generations if the provided generation count is 0. This allows for + * using the ensure function in combination with ids that have their + * generation stripped. */ + ecs_vector_t *dense_vector = sparse->dense; + uint64_t *dense_array = ecs_vector_first(dense_vector, uint64_t); + ecs_assert(!gen || dense_array[dense] == (index | gen), ECS_INTERNAL_ERROR, NULL); + (void)dense_vector; + (void)dense_array; } else { - ecs_poly_assert(world, ecs_stage_t); - ecs_stage_t *stage = (ecs_stage_t*)world; - stage->auto_merge = auto_merge; - } -} + /* Element is not paired yet. Must add a new element to dense array */ + grow_dense(sparse); -bool ecs_stage_is_readonly( - const ecs_world_t *stage) -{ - const ecs_world_t *world = ecs_get_world(stage); + ecs_vector_t *dense_vector = sparse->dense; + uint64_t *dense_array = ecs_vector_first(dense_vector, uint64_t); + int32_t dense_count = ecs_vector_count(dense_vector) - 1; + int32_t count = sparse->count ++; - if (ecs_poly_is(stage, ecs_stage_t)) { - if (((ecs_stage_t*)stage)->asynchronous) { - return false; + /* If index is larger than max id, update max id */ + if (index >= get_id(sparse)) { + set_id(sparse, index); } - } - if (world->is_readonly) { - if (ecs_poly_is(stage, ecs_world_t)) { - return true; - } - } else { - if (ecs_poly_is(stage, ecs_stage_t)) { - return true; + if (count < dense_count) { + /* If there are unused elements in the list, move the first unused + * element to the end of the list */ + uint64_t unused = dense_array[count]; + chunk_t *unused_chunk = get_or_create_chunk(sparse, CHUNK(unused)); + assign_index(unused_chunk, dense_array, unused, dense_count); } + + assign_index(chunk, dense_array, index, count); + dense_array[count] |= gen; } - return false; + return DATA(chunk->data, sparse->size, offset); } -ecs_world_t* ecs_async_stage_new( - ecs_world_t *world) +void* _flecs_sparse_set( + ecs_sparse_t * sparse, + ecs_size_t elem_size, + uint64_t index, + void* value) { - ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t)); - flecs_stage_init(world, stage); + void *ptr = _flecs_sparse_ensure(sparse, elem_size, index); + ecs_os_memcpy(ptr, value, elem_size); + return ptr; +} - stage->id = -1; - stage->auto_merge = false; - stage->asynchronous = true; +void* _flecs_sparse_remove_get( + ecs_sparse_t *sparse, + ecs_size_t size, + uint64_t index) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + (void)size; - ecs_defer_begin((ecs_world_t*)stage); + chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); + uint64_t gen = strip_generation(&index); + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; - return (ecs_world_t*)stage; -} + if (dense) { + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK; + if (gen != cur_gen) { + /* Generation doesn't match which means that the provided entity is + * already not alive. */ + return NULL; + } -void ecs_async_stage_free( - ecs_world_t *world) -{ - ecs_poly_assert(world, ecs_stage_t); - ecs_stage_t *stage = (ecs_stage_t*)world; - ecs_check(stage->asynchronous == true, ECS_INVALID_PARAMETER, NULL); - flecs_stage_deinit(stage->world, stage); - ecs_os_free(stage); -error: - return; -} + /* Increase generation */ + dense_array[dense] = index | inc_gen(cur_gen); + + int32_t count = sparse->count; + + if (dense == (count - 1)) { + /* If dense is the last used element, simply decrease count */ + sparse->count --; + } else if (dense < count) { + /* If element is alive, move it to unused elements */ + swap_dense(sparse, chunk, dense, count - 1); + sparse->count --; + } else { + /* Element is not alive, nothing to be done */ + return NULL; + } -bool ecs_stage_is_async( - ecs_world_t *stage) -{ - if (!stage) { - return false; - } - - if (!ecs_poly_is(stage, ecs_stage_t)) { - return false; + /* Reset memory to zero on remove */ + return DATA(chunk->data, sparse->size, offset); + } else { + /* Element is not paired and thus not alive, nothing to be done */ + return NULL; } - - return ((ecs_stage_t*)stage)->asynchronous; } -bool ecs_is_deferred( - const ecs_world_t *world) +void flecs_sparse_remove( + ecs_sparse_t *sparse, + uint64_t index) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); - return stage->defer != 0; -error: - return false; + void *ptr = _flecs_sparse_remove_get(sparse, 0, index); + if (ptr) { + ecs_os_memset(ptr, 0, sparse->size); + } } - -struct ecs_vector_t { - int32_t count; - int32_t size; +void flecs_sparse_set_generation( + ecs_sparse_t *sparse, + uint64_t index) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); -#ifndef FLECS_NDEBUG - int64_t elem_size; /* Used in debug mode to validate size */ -#endif -}; + uint64_t index_w_gen = index; + strip_generation(&index); + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; -/** Resize the vector buffer */ -static -ecs_vector_t* resize( - ecs_vector_t *vector, - int16_t offset, - int32_t size) -{ - ecs_vector_t *result = ecs_os_realloc(vector, offset + size); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, 0); - return result; + if (dense) { + /* Increase generation */ + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + dense_array[dense] = index_w_gen; + } else { + /* Element is not paired and thus not alive, nothing to be done */ + } } -/* -- Public functions -- */ - -ecs_vector_t* _ecs_vector_new( - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +bool flecs_sparse_exists( + const ecs_sparse_t *sparse, + uint64_t index) { - ecs_assert(elem_size != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + if (!chunk) { + return false; + } - ecs_vector_t *result = - ecs_os_malloc(offset + elem_size * elem_count); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + strip_generation(&index); + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; - result->count = 0; - result->size = elem_count; -#ifndef FLECS_NDEBUG - result->elem_size = elem_size; -#endif - return result; + return dense != 0; } -ecs_vector_t* _ecs_vector_from_array( - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count, - void *array) +void* _flecs_sparse_get_dense( + const ecs_sparse_t *sparse, + ecs_size_t size, + int32_t dense_index) { - ecs_assert(elem_size != 0, ECS_INTERNAL_ERROR, NULL); - - ecs_vector_t *result = - ecs_os_malloc(offset + elem_size * elem_count); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + ecs_assert(dense_index < sparse->count, ECS_INVALID_PARAMETER, NULL); + (void)size; - ecs_os_memcpy(ECS_OFFSET(result, offset), array, elem_size * elem_count); + dense_index ++; - result->count = elem_count; - result->size = elem_count; -#ifndef FLECS_NDEBUG - result->elem_size = elem_size; -#endif - return result; + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + return get_sparse(sparse, dense_index, dense_array[dense_index]); } -void ecs_vector_free( - ecs_vector_t *vector) +bool flecs_sparse_is_alive( + const ecs_sparse_t *sparse, + uint64_t index) { - ecs_os_free(vector); + return try_sparse(sparse, index) != NULL; } -void ecs_vector_clear( - ecs_vector_t *vector) +uint64_t flecs_sparse_get_alive( + const ecs_sparse_t *sparse, + uint64_t index) { - if (vector) { - vector->count = 0; + chunk_t *chunk = get_chunk(sparse, CHUNK(index)); + if (!chunk) { + return 0; } + + int32_t offset = OFFSET(index); + int32_t dense = chunk->sparse[offset]; + uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); + + /* If dense is 0 (tombstone) this will return 0 */ + return dense_array[dense]; } -void _ecs_vector_zero( - ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset) +void* _flecs_sparse_get( + const ecs_sparse_t *sparse, + ecs_size_t size, + uint64_t index) { - void *array = ECS_OFFSET(vector, offset); - ecs_os_memset(array, 0, elem_size * vector->count); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + (void)size; + return try_sparse(sparse, index); } -void ecs_vector_assert_size( - ecs_vector_t *vector, - ecs_size_t elem_size) +void* _flecs_sparse_get_any( + const ecs_sparse_t *sparse, + ecs_size_t size, + uint64_t index) { - (void)elem_size; - - if (vector) { - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - } + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); + (void)size; + return try_sparse_any(sparse, index); } -void* _ecs_vector_addn( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +int32_t flecs_sparse_count( + const ecs_sparse_t *sparse) { - ecs_assert(array_inout != NULL, ECS_INTERNAL_ERROR, NULL); - - if (elem_count == 1) { - return _ecs_vector_add(array_inout, elem_size, offset); - } - - ecs_vector_t *vector = *array_inout; - if (!vector) { - vector = _ecs_vector_new(elem_size, offset, 1); - *array_inout = vector; + if (!sparse) { + return 0; } - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - - int32_t max_count = vector->size; - int32_t old_count = vector->count; - int32_t new_count = old_count + elem_count; - - if ((new_count - 1) >= max_count) { - if (!max_count) { - max_count = elem_count; - } else { - while (max_count < new_count) { - max_count *= 2; - } - } + return sparse->count - 1; +} - vector = resize(vector, offset, max_count * elem_size); - vector->size = max_count; - *array_inout = vector; +int32_t flecs_sparse_size( + const ecs_sparse_t *sparse) +{ + if (!sparse) { + return 0; } - - vector->count = new_count; - - return ECS_OFFSET(vector, offset + elem_size * old_count); + + return ecs_vector_count(sparse->dense) - 1; } -void* _ecs_vector_add( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset) +const uint64_t* flecs_sparse_ids( + const ecs_sparse_t *sparse) { - ecs_assert(array_inout != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_vector_t *vector = *array_inout; - int32_t count, size; + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + return &(ecs_vector_first(sparse->dense, uint64_t)[1]); +} - if (vector) { - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - count = vector->count; - size = vector->size; +void flecs_sparse_set_size( + ecs_sparse_t *sparse, + int32_t elem_count) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_vector_set_size(&sparse->dense, uint64_t, elem_count); +} - if (count >= size) { - size *= 2; - if (!size) { - size = 2; - } - vector = resize(vector, offset, size * elem_size); - *array_inout = vector; - vector->size = size; - } +static +void sparse_copy( + ecs_sparse_t * dst, + const ecs_sparse_t * src) +{ + flecs_sparse_set_size(dst, flecs_sparse_size(src)); + const uint64_t *indices = flecs_sparse_ids(src); + + ecs_size_t size = src->size; + int32_t i, count = src->count; - vector->count = count + 1; - return ECS_OFFSET(vector, offset + elem_size * count); + for (i = 0; i < count - 1; i ++) { + uint64_t index = indices[i]; + void *src_ptr = _flecs_sparse_get(src, size, index); + void *dst_ptr = _flecs_sparse_ensure(dst, size, index); + flecs_sparse_set_generation(dst, index); + ecs_os_memcpy(dst_ptr, src_ptr, size); } - vector = _ecs_vector_new(elem_size, offset, 2); - *array_inout = vector; - vector->count = 1; - vector->size = 2; - return ECS_OFFSET(vector, offset); + set_id(dst, get_id(src)); + + ecs_assert(src->count == dst->count, ECS_INTERNAL_ERROR, NULL); } -void* _ecs_vector_insert_at( - ecs_vector_t **vec, - ecs_size_t elem_size, - int16_t offset, - int32_t index) +ecs_sparse_t* flecs_sparse_copy( + const ecs_sparse_t *src) { - ecs_assert(vec != NULL, ECS_INTERNAL_ERROR, NULL); - int32_t count = vec[0]->count; - if (index == count) { - return _ecs_vector_add(vec, elem_size, offset); + if (!src) { + return NULL; } - ecs_assert(index < count, ECS_INTERNAL_ERROR, NULL); - ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); - _ecs_vector_add(vec, elem_size, offset); - void *start = _ecs_vector_get(*vec, elem_size, offset, index); - if (index < count) { - ecs_os_memmove(ECS_OFFSET(start, elem_size), start, - (count - index) * elem_size); - } + ecs_sparse_t *dst = _flecs_sparse_new(src->size); + sparse_copy(dst, src); - return start; + return dst; } -int32_t _ecs_vector_move_index( - ecs_vector_t **dst, - ecs_vector_t *src, - ecs_size_t elem_size, - int16_t offset, - int32_t index) +void flecs_sparse_restore( + ecs_sparse_t * dst, + const ecs_sparse_t * src) { - if (dst && *dst) { - ecs_dbg_assert((*dst)->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + ecs_assert(dst != NULL, ECS_INVALID_PARAMETER, NULL); + dst->count = 1; + if (src) { + sparse_copy(dst, src); } - ecs_dbg_assert(src->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); +} - void *dst_elem = _ecs_vector_add(dst, elem_size, offset); - void *src_elem = _ecs_vector_get(src, elem_size, offset, index); +void flecs_sparse_memory( + ecs_sparse_t *sparse, + int32_t *allocd, + int32_t *used) +{ + (void)sparse; + (void)allocd; + (void)used; +} - ecs_os_memcpy(dst_elem, src_elem, elem_size); - return _ecs_vector_remove(src, elem_size, offset, index); +ecs_sparse_t* _ecs_sparse_new( + ecs_size_t elem_size) +{ + return _flecs_sparse_new(elem_size); } -void ecs_vector_remove_last( - ecs_vector_t *vector) +void* _ecs_sparse_add( + ecs_sparse_t *sparse, + ecs_size_t elem_size) { - if (vector && vector->count) vector->count --; + return _flecs_sparse_add(sparse, elem_size); } -bool _ecs_vector_pop( - ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset, - void *value) +uint64_t ecs_sparse_last_id( + const ecs_sparse_t *sparse) { - if (!vector) { - return false; - } + return flecs_sparse_last_id(sparse); +} - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); +int32_t ecs_sparse_count( + const ecs_sparse_t *sparse) +{ + return flecs_sparse_count(sparse); +} - int32_t count = vector->count; - if (!count) { - return false; - } +void* _ecs_sparse_get_dense( + const ecs_sparse_t *sparse, + ecs_size_t elem_size, + int32_t index) +{ + return _flecs_sparse_get_dense(sparse, elem_size, index); +} - void *elem = ECS_OFFSET(vector, offset + (count - 1) * elem_size); +void* _ecs_sparse_get( + const ecs_sparse_t *sparse, + ecs_size_t elem_size, + uint64_t id) +{ + return _flecs_sparse_get(sparse, elem_size, id); +} - if (value) { - ecs_os_memcpy(value, elem, elem_size); - } +ecs_sparse_iter_t _flecs_sparse_iter( + ecs_sparse_t *sparse, + ecs_size_t elem_size) +{ + ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(elem_size == sparse->size, ECS_INVALID_PARAMETER, NULL); + ecs_sparse_iter_t result; + result.sparse = sparse; + result.ids = flecs_sparse_ids(sparse); + result.size = elem_size; + result.i = 0; + result.count = sparse->count - 1; + return result; +} - ecs_vector_remove_last(vector); +#include +#include - return true; -} +/** + * stm32tpl -- STM32 C++ Template Peripheral Library + * Visit https://github.com/antongus/stm32tpl for new versions + * + * Copyright (c) 2011-2020 Anton B. Gusev aka AHTOXA + */ -int32_t _ecs_vector_remove( - ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset, - int32_t index) +#define MAX_PRECISION (10) +#define EXP_THRESHOLD (3) +#define INT64_MAX_F ((double)INT64_MAX) + +static const double rounders[MAX_PRECISION + 1] = { - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - - int32_t count = vector->count; - void *buffer = ECS_OFFSET(vector, offset); - void *elem = ECS_OFFSET(buffer, index * elem_size); + 0.5, // 0 + 0.05, // 1 + 0.005, // 2 + 0.0005, // 3 + 0.00005, // 4 + 0.000005, // 5 + 0.0000005, // 6 + 0.00000005, // 7 + 0.000000005, // 8 + 0.0000000005, // 9 + 0.00000000005 // 10 +}; - ecs_assert(index < count, ECS_INVALID_PARAMETER, NULL); +static +char* strbuf_itoa( + char *buf, + int64_t v) +{ + char *ptr = buf; + char * p1; + char c; - count --; - if (index != count) { - void *last_elem = ECS_OFFSET(buffer, elem_size * count); - ecs_os_memcpy(elem, last_elem, elem_size); - } + if (!v) { + *ptr++ = '0'; + } else { + char *p = ptr; + while (v) { + *p++ = (char)('0' + v % 10); + v /= 10; + } - vector->count = count; + p1 = p; - return count; + while (p > ptr) { + c = *--p; + *p = *ptr; + *ptr++ = c; + } + ptr = p1; + } + return ptr; } -void _ecs_vector_reclaim( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset) +static +int ecs_strbuf_ftoa( + ecs_strbuf_t *out, + double f, + int precision, + char nan_delim) { - ecs_vector_t *vector = *array_inout; + char buf[64]; + char * ptr = buf; + char c; + int64_t intPart; + int64_t exp = 0; - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - - int32_t size = vector->size; - int32_t count = vector->count; + if (isnan(f)) { + if (nan_delim) { + ecs_strbuf_appendch(out, nan_delim); + ecs_strbuf_appendstr(out, "NaN"); + return ecs_strbuf_appendch(out, nan_delim); + } else { + return ecs_strbuf_appendstr(out, "NaN"); + } + } + if (isinf(f)) { + if (nan_delim) { + ecs_strbuf_appendch(out, nan_delim); + ecs_strbuf_appendstr(out, "Inf"); + return ecs_strbuf_appendch(out, nan_delim); + } else { + return ecs_strbuf_appendstr(out, "Inf"); + } + } - if (count < size) { - size = count; - vector = resize(vector, offset, size * elem_size); - vector->size = size; - *array_inout = vector; + if (precision > MAX_PRECISION) { + precision = MAX_PRECISION; } -} -int32_t ecs_vector_count( - const ecs_vector_t *vector) -{ - if (!vector) { - return 0; + if (f < 0) { + f = -f; + *ptr++ = '-'; + } + + if (precision < 0) { + if (f < 1.0) precision = 6; + else if (f < 10.0) precision = 5; + else if (f < 100.0) precision = 4; + else if (f < 1000.0) precision = 3; + else if (f < 10000.0) precision = 2; + else if (f < 100000.0) precision = 1; + else precision = 0; + } + + if (precision) { + f += rounders[precision]; } - return vector->count; -} -int32_t ecs_vector_size( - const ecs_vector_t *vector) -{ - if (!vector) { - return 0; + /* Make sure that number can be represented as 64bit int, increase exp */ + while (f > INT64_MAX_F) { + f /= 1000 * 1000 * 1000; + exp += 9; } - return vector->size; -} -int32_t _ecs_vector_set_size( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) -{ - ecs_vector_t *vector = *array_inout; + intPart = (int64_t)f; + f -= (double)intPart; - if (!vector) { - *array_inout = _ecs_vector_new(elem_size, offset, elem_count); - return elem_count; - } else { - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + ptr = strbuf_itoa(ptr, intPart); - int32_t result = vector->size; + if (precision) { + *ptr++ = '.'; + while (precision--) { + f *= 10.0; + c = (char)f; + *ptr++ = (char)('0' + c); + f -= c; + } + } + *ptr = 0; - if (elem_count < vector->count) { - elem_count = vector->count; + /* Remove trailing 0s */ + while ((&ptr[-1] != buf) && (ptr[-1] == '0')) { + ptr[-1] = '\0'; + ptr --; + } + if (ptr != buf && ptr[-1] == '.') { + ptr[-1] = '\0'; + ptr --; + } + + /* If 0s before . exceed threshold, convert to exponent to save space + * without losing precision. */ + char *cur = ptr; + while ((&cur[-1] != buf) && (cur[-1] == '0')) { + cur --; + } + + if (exp || ((ptr - cur) > EXP_THRESHOLD)) { + cur[0] = '\0'; + exp += (ptr - cur); + ptr = cur; + } + + if (exp) { + char *p1 = &buf[1]; + if (nan_delim) { + ecs_os_memmove(buf + 1, buf, 1 + (ptr - buf)); + buf[0] = nan_delim; + p1 ++; } - if (result < elem_count) { - elem_count = flecs_next_pow_of_2(elem_count); - vector = resize(vector, offset, elem_count * elem_size); - vector->size = elem_count; - *array_inout = vector; - result = elem_count; + /* Make sure that exp starts after first character */ + c = p1[0]; + p1[0] = '.'; + + do { + char t = (++p1)[0]; + p1[0] = c; + c = t; + exp ++; + } while (c); + + ptr = p1 + 1; + + ptr[0] = 'e'; + ptr = strbuf_itoa(ptr + 1, exp); + + if (nan_delim) { + ptr[0] = nan_delim; + ptr ++; } - return result; + ptr[0] = '\0'; } + + return ecs_strbuf_appendstrn(out, buf, (int32_t)(ptr - buf)); } -int32_t _ecs_vector_grow( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +/* Add an extra element to the buffer */ +static +void ecs_strbuf_grow( + ecs_strbuf_t *b) { - int32_t current = ecs_vector_count(*array_inout); - return _ecs_vector_set_size(array_inout, elem_size, offset, current + elem_count); + /* Allocate new element */ + ecs_strbuf_element_embedded *e = ecs_os_malloc_t(ecs_strbuf_element_embedded); + b->size += b->current->pos; + b->current->next = (ecs_strbuf_element*)e; + b->current = (ecs_strbuf_element*)e; + b->elementCount ++; + e->super.buffer_embedded = true; + e->super.buf = e->buf; + e->super.pos = 0; + e->super.next = NULL; } -int32_t _ecs_vector_set_count( - ecs_vector_t **array_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +/* Add an extra dynamic element */ +static +void ecs_strbuf_grow_str( + ecs_strbuf_t *b, + char *str, + char *alloc_str, + int32_t size) { - if (!*array_inout) { - *array_inout = _ecs_vector_new(elem_size, offset, elem_count); - } - - ecs_dbg_assert((*array_inout)->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - - (*array_inout)->count = elem_count; - ecs_size_t size = _ecs_vector_set_size(array_inout, elem_size, offset, elem_count); - return size; + /* Allocate new element */ + ecs_strbuf_element_str *e = ecs_os_malloc_t(ecs_strbuf_element_str); + b->size += b->current->pos; + b->current->next = (ecs_strbuf_element*)e; + b->current = (ecs_strbuf_element*)e; + b->elementCount ++; + e->super.buffer_embedded = false; + e->super.pos = size ? size : (int32_t)ecs_os_strlen(str); + e->super.next = NULL; + e->super.buf = str; + e->alloc_str = alloc_str; } -void* _ecs_vector_first( - const ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset) +static +char* ecs_strbuf_ptr( + ecs_strbuf_t *b) { - (void)elem_size; - - ecs_dbg_assert(!vector || vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - if (vector && vector->size) { - return ECS_OFFSET(vector, offset); + if (b->buf) { + return &b->buf[b->current->pos]; } else { - return NULL; + return &b->current->buf[b->current->pos]; } } -void* _ecs_vector_get( - const ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset, - int32_t index) -{ - ecs_assert(vector != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(index < vector->count, ECS_INTERNAL_ERROR, NULL); - - return ECS_OFFSET(vector, offset + elem_size * index); -} - -void* _ecs_vector_last( - const ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset) +/* Compute the amount of space left in the current element */ +static +int32_t ecs_strbuf_memLeftInCurrentElement( + ecs_strbuf_t *b) { - if (vector) { - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - int32_t count = vector->count; - if (!count) { - return NULL; - } else { - return ECS_OFFSET(vector, offset + elem_size * (count - 1)); - } + if (b->current->buffer_embedded) { + return ECS_STRBUF_ELEMENT_SIZE - b->current->pos; } else { - return NULL; + return 0; } } -int32_t _ecs_vector_set_min_size( - ecs_vector_t **vector_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +/* Compute the amount of space left */ +static +int32_t ecs_strbuf_memLeft( + ecs_strbuf_t *b) { - if (!*vector_inout || (*vector_inout)->size < elem_count) { - return _ecs_vector_set_size(vector_inout, elem_size, offset, elem_count); + if (b->max) { + return b->max - b->size - b->current->pos; } else { - return (*vector_inout)->size; + return INT_MAX; } } -int32_t _ecs_vector_set_min_count( - ecs_vector_t **vector_inout, - ecs_size_t elem_size, - int16_t offset, - int32_t elem_count) +static +void ecs_strbuf_init( + ecs_strbuf_t *b) { - _ecs_vector_set_min_size(vector_inout, elem_size, offset, elem_count); - - ecs_vector_t *v = *vector_inout; - if (v && v->count < elem_count) { - v->count = elem_count; + /* Initialize buffer structure only once */ + if (!b->elementCount) { + b->size = 0; + b->firstElement.super.next = NULL; + b->firstElement.super.pos = 0; + b->firstElement.super.buffer_embedded = true; + b->firstElement.super.buf = b->firstElement.buf; + b->elementCount ++; + b->current = (ecs_strbuf_element*)&b->firstElement; } - - return v->count; } -void _ecs_vector_sort( - ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset, - ecs_comparator_t compare_action) +/* Append a format string to a buffer */ +static +bool vappend( + ecs_strbuf_t *b, + const char* str, + va_list args) { - if (!vector) { - return; + bool result = true; + va_list arg_cpy; + + if (!str) { + return result; } - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_init(b); - int32_t count = vector->count; - void *buffer = ECS_OFFSET(vector, offset); + int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); + int32_t memLeft = ecs_strbuf_memLeft(b); - if (count > 1) { - qsort(buffer, (size_t)count, (size_t)elem_size, compare_action); + if (!memLeft) { + return false; } -} -void _ecs_vector_memory( - const ecs_vector_t *vector, - ecs_size_t elem_size, - int16_t offset, - int32_t *allocd, - int32_t *used) -{ - if (!vector) { - return; - } - - ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - - if (allocd) { - *allocd += vector->size * elem_size + offset; - } - if (used) { - *used += vector->count * elem_size; - } -} + /* Compute the memory required to add the string to the buffer. If user + * provided buffer, use space left in buffer, otherwise use space left in + * current element. */ + int32_t max_copy = b->buf ? memLeft : memLeftInElement; + int32_t memRequired; -ecs_vector_t* _ecs_vector_copy( - const ecs_vector_t *src, - ecs_size_t elem_size, - int16_t offset) -{ - if (!src) { - return NULL; - } + va_copy(arg_cpy, args); + memRequired = vsnprintf( + ecs_strbuf_ptr(b), (size_t)(max_copy + 1), str, args); - ecs_vector_t *dst = _ecs_vector_new(elem_size, offset, src->size); - ecs_os_memcpy(dst, src, offset + elem_size * src->count); - return dst; -} + ecs_assert(memRequired != -1, ECS_INTERNAL_ERROR, NULL); + if (memRequired <= memLeftInElement) { + /* Element was large enough to fit string */ + b->current->pos += memRequired; + } else if ((memRequired - memLeftInElement) < memLeft) { + /* If string is a format string, a new buffer of size memRequired is + * needed to re-evaluate the format string and only use the part that + * wasn't already copied to the previous element */ + if (memRequired <= ECS_STRBUF_ELEMENT_SIZE) { + /* Resulting string fits in standard-size buffer. Note that the + * entire string needs to fit, not just the remainder, as the + * format string cannot be partially evaluated */ + ecs_strbuf_grow(b); -/** The number of elements in a single chunk */ -#define CHUNK_COUNT (4096) + /* Copy entire string to new buffer */ + ecs_os_vsprintf(ecs_strbuf_ptr(b), str, arg_cpy); -/** Compute the chunk index from an id by stripping the first 12 bits */ -#define CHUNK(index) ((int32_t)((uint32_t)index >> 12)) + /* Ignore the part of the string that was copied into the + * previous buffer. The string copied into the new buffer could + * be memmoved so that only the remainder is left, but that is + * most likely more expensive than just keeping the entire + * string. */ -/** This computes the offset of an index inside a chunk */ -#define OFFSET(index) ((int32_t)index & 0xFFF) + /* Update position in buffer */ + b->current->pos += memRequired; + } else { + /* Resulting string does not fit in standard-size buffer. + * Allocate a new buffer that can hold the entire string. */ + char *dst = ecs_os_malloc(memRequired + 1); + ecs_os_vsprintf(dst, str, arg_cpy); + ecs_strbuf_grow_str(b, dst, dst, memRequired); + } + } -/* Utility to get a pointer to the payload */ -#define DATA(array, size, offset) (ECS_OFFSET(array, size * offset)) + va_end(arg_cpy); -typedef struct chunk_t { - int32_t *sparse; /* Sparse array with indices to dense array */ - void *data; /* Store data in sparse array to reduce - * indirection and provide stable pointers. */ -} chunk_t; + return ecs_strbuf_memLeft(b) > 0; +} static -chunk_t* chunk_new( - ecs_sparse_t *sparse, - int32_t chunk_index) +bool appendstr( + ecs_strbuf_t *b, + const char* str, + int n) { - int32_t count = ecs_vector_count(sparse->chunks); - chunk_t *chunks; + ecs_strbuf_init(b); - if (count <= chunk_index) { - ecs_vector_set_count(&sparse->chunks, chunk_t, chunk_index + 1); - chunks = ecs_vector_first(sparse->chunks, chunk_t); - ecs_os_memset(&chunks[count], 0, (1 + chunk_index - count) * ECS_SIZEOF(chunk_t)); - } else { - chunks = ecs_vector_first(sparse->chunks, chunk_t); + int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); + int32_t memLeft = ecs_strbuf_memLeft(b); + if (memLeft <= 0) { + return false; } - ecs_assert(chunks != NULL, ECS_INTERNAL_ERROR, NULL); + /* Never write more than what the buffer can store */ + if (n > memLeft) { + n = memLeft; + } - chunk_t *result = &chunks[chunk_index]; - ecs_assert(result->sparse == NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result->data == NULL, ECS_INTERNAL_ERROR, NULL); + if (n <= memLeftInElement) { + /* Element was large enough to fit string */ + ecs_os_strncpy(ecs_strbuf_ptr(b), str, n); + b->current->pos += n; + } else if ((n - memLeftInElement) < memLeft) { + ecs_os_strncpy(ecs_strbuf_ptr(b), str, memLeftInElement); - /* Initialize sparse array with zero's, as zero is used to indicate that the - * sparse element has not been paired with a dense element. Use zero - * as this means we can take advantage of calloc having a possibly better - * performance than malloc + memset. */ - result->sparse = ecs_os_calloc(ECS_SIZEOF(int32_t) * CHUNK_COUNT); + /* Element was not large enough, but buffer still has space */ + b->current->pos += memLeftInElement; + n -= memLeftInElement; - /* Initialize the data array with zero's to guarantee that data is - * always initialized. When an entry is removed, data is reset back to - * zero. Initialize now, as this can take advantage of calloc. */ - result->data = ecs_os_calloc(sparse->size * CHUNK_COUNT); + /* Current element was too small, copy remainder into new element */ + if (n < ECS_STRBUF_ELEMENT_SIZE) { + /* A standard-size buffer is large enough for the new string */ + ecs_strbuf_grow(b); - ecs_assert(result->sparse != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result->data != NULL, ECS_INTERNAL_ERROR, NULL); + /* Copy the remainder to the new buffer */ + if (n) { + /* If a max number of characters to write is set, only a + * subset of the string should be copied to the buffer */ + ecs_os_strncpy( + ecs_strbuf_ptr(b), + str + memLeftInElement, + (size_t)n); + } else { + ecs_os_strcpy(ecs_strbuf_ptr(b), str + memLeftInElement); + } - return result; -} + /* Update to number of characters copied to new buffer */ + b->current->pos += n; + } else { + /* String doesn't fit in a single element, strdup */ + char *remainder = ecs_os_strdup(str + memLeftInElement); + ecs_strbuf_grow_str(b, remainder, remainder, n); + } + } else { + /* Buffer max has been reached */ + return false; + } -static -void chunk_free( - chunk_t *chunk) -{ - ecs_os_free(chunk->sparse); - ecs_os_free(chunk->data); + return ecs_strbuf_memLeft(b) > 0; } static -chunk_t* get_chunk( - const ecs_sparse_t *sparse, - int32_t chunk_index) +bool appendch( + ecs_strbuf_t *b, + char ch) { - if (!sparse->chunks) { - return NULL; - } - if (chunk_index >= ecs_vector_count(sparse->chunks)) { - return NULL; - } + ecs_strbuf_init(b); - /* If chunk_index is below zero, application used an invalid entity id */ - ecs_assert(chunk_index >= 0, ECS_INVALID_PARAMETER, NULL); - chunk_t *result = ecs_vector_get(sparse->chunks, chunk_t, chunk_index); - if (result && !result->sparse) { - return NULL; + int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); + int32_t memLeft = ecs_strbuf_memLeft(b); + if (memLeft <= 0) { + return false; } - return result; -} - -static -chunk_t* get_or_create_chunk( - ecs_sparse_t *sparse, - int32_t chunk_index) -{ - chunk_t *chunk = get_chunk(sparse, chunk_index); - if (chunk) { - return chunk; + if (memLeftInElement) { + /* Element was large enough to fit string */ + ecs_strbuf_ptr(b)[0] = ch; + b->current->pos ++; + } else { + ecs_strbuf_grow(b); + ecs_strbuf_ptr(b)[0] = ch; + b->current->pos ++; } - return chunk_new(sparse, chunk_index); + return ecs_strbuf_memLeft(b) > 0; } -static -void grow_dense( - ecs_sparse_t *sparse) +bool ecs_strbuf_vappend( + ecs_strbuf_t *b, + const char* fmt, + va_list args) { - ecs_vector_add(&sparse->dense, uint64_t); + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); + return vappend(b, fmt, args); } -static -uint64_t strip_generation( - uint64_t *index_out) +bool ecs_strbuf_append( + ecs_strbuf_t *b, + const char* fmt, + ...) { - uint64_t index = *index_out; - uint64_t gen = index & ECS_GENERATION_MASK; - /* Make sure there's no junk in the id */ - ecs_assert(gen == (index & (0xFFFFFFFFull << 32)), - ECS_INVALID_PARAMETER, NULL); - *index_out -= gen; - return gen; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); + + va_list args; + va_start(args, fmt); + bool result = vappend(b, fmt, args); + va_end(args); + + return result; } -static -void assign_index( - chunk_t * chunk, - uint64_t * dense_array, - uint64_t index, - int32_t dense) +bool ecs_strbuf_appendstrn( + ecs_strbuf_t *b, + const char* str, + int32_t len) { - /* Initialize sparse-dense pair. This assigns the dense index to the sparse - * array, and the sparse index to the dense array .*/ - chunk->sparse[OFFSET(index)] = dense; - dense_array[dense] = index; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); + return appendstr(b, str, len); } -static -uint64_t inc_gen( - uint64_t index) +bool ecs_strbuf_appendch( + ecs_strbuf_t *b, + char ch) { - /* When an index is deleted, its generation is increased so that we can do - * liveliness checking while recycling ids */ - return ECS_GENERATION_INC(index); + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + return appendch(b, ch); } -static -uint64_t inc_id( - ecs_sparse_t *sparse) +bool ecs_strbuf_appendflt( + ecs_strbuf_t *b, + double flt, + char nan_delim) { - /* Generate a new id. The last issued id could be stored in an external - * variable, such as is the case with the last issued entity id, which is - * stored on the world. */ - return ++ (sparse->max_id[0]); + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + return ecs_strbuf_ftoa(b, flt, 10, nan_delim); } -static -uint64_t get_id( - const ecs_sparse_t *sparse) +bool ecs_strbuf_appendstr_zerocpy( + ecs_strbuf_t *b, + char* str) { - return sparse->max_id[0]; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_strbuf_init(b); + ecs_strbuf_grow_str(b, str, str, 0); + return true; } -static -void set_id( - ecs_sparse_t *sparse, - uint64_t value) +bool ecs_strbuf_appendstr_zerocpy_const( + ecs_strbuf_t *b, + const char* str) { - /* Sometimes the max id needs to be assigned directly, which typically - * happens when the API calls get_or_create for an id that hasn't been - * issued before. */ - sparse->max_id[0] = value; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); + /* Removes const modifier, but logic prevents changing / delete string */ + ecs_strbuf_init(b); + ecs_strbuf_grow_str(b, (char*)str, NULL, 0); + return true; } -/* Pair dense id with new sparse id */ -static -uint64_t create_id( - ecs_sparse_t *sparse, - int32_t dense) +bool ecs_strbuf_appendstr( + ecs_strbuf_t *b, + const char* str) { - uint64_t index = inc_id(sparse); - grow_dense(sparse); - - chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); - ecs_assert(chunk->sparse[OFFSET(index)] == 0, ECS_INTERNAL_ERROR, NULL); - - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - assign_index(chunk, dense_array, index, dense); - - return index; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); + return appendstr(b, str, ecs_os_strlen(str)); } -/* Create new id */ -static -uint64_t new_index( - ecs_sparse_t *sparse) +bool ecs_strbuf_mergebuff( + ecs_strbuf_t *dst_buffer, + ecs_strbuf_t *src_buffer) { - ecs_vector_t *dense = sparse->dense; - int32_t dense_count = ecs_vector_count(dense); - int32_t count = sparse->count ++; - - ecs_assert(count <= dense_count, ECS_INTERNAL_ERROR, NULL); - - if (count < dense_count) { - /* If there are unused elements in the dense array, return first */ - uint64_t *dense_array = ecs_vector_first(dense, uint64_t); - return dense_array[count]; - } else { - return create_id(sparse, count); - } -} + if (src_buffer->elementCount) { + if (src_buffer->buf) { + return ecs_strbuf_appendstr(dst_buffer, src_buffer->buf); + } else { + ecs_strbuf_element *e = (ecs_strbuf_element*)&src_buffer->firstElement; -/* Try obtaining a value from the sparse set, don't care about whether the - * provided index matches the current generation count. */ -static -void* try_sparse_any( - const ecs_sparse_t *sparse, - uint64_t index) -{ - strip_generation(&index); + /* Copy first element as it is inlined in the src buffer */ + ecs_strbuf_appendstrn(dst_buffer, e->buf, e->pos); - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - if (!chunk) { - return NULL; - } + while ((e = e->next)) { + dst_buffer->current->next = ecs_os_malloc(sizeof(ecs_strbuf_element)); + *dst_buffer->current->next = *e; + } + } - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - bool in_use = dense && (dense < sparse->count); - if (!in_use) { - return NULL; + *src_buffer = ECS_STRBUF_INIT; } - ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); - return DATA(chunk->data, sparse->size, offset); + return true; } -/* Try obtaining a value from the sparse set, make sure it's alive. */ -static -void* try_sparse( - const ecs_sparse_t *sparse, - uint64_t index) +char* ecs_strbuf_get( + ecs_strbuf_t *b) { - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - if (!chunk) { - return NULL; - } + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - bool in_use = dense && (dense < sparse->count); - if (!in_use) { - return NULL; - } + char* result = NULL; + if (b->elementCount) { + if (b->buf) { + b->buf[b->current->pos] = '\0'; + result = ecs_os_strdup(b->buf); + } else { + void *next = NULL; + int32_t len = b->size + b->current->pos + 1; - uint64_t gen = strip_generation(&index); - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK; + ecs_strbuf_element *e = (ecs_strbuf_element*)&b->firstElement; - if (cur_gen != gen) { - return NULL; + result = ecs_os_malloc(len); + char* ptr = result; + + do { + ecs_os_memcpy(ptr, e->buf, e->pos); + ptr += e->pos; + next = e->next; + if (e != &b->firstElement.super) { + if (!e->buffer_embedded) { + ecs_os_free(((ecs_strbuf_element_str*)e)->alloc_str); + } + ecs_os_free(e); + } + } while ((e = next)); + + result[len - 1] = '\0'; + b->length = len; + } + } else { + result = NULL; } - ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); - return DATA(chunk->data, sparse->size, offset); -} + b->elementCount = 0; -/* Get value from sparse set when it is guaranteed that the value exists. This - * function is used when values are obtained using a dense index */ -static -void* get_sparse( - const ecs_sparse_t *sparse, - int32_t dense, - uint64_t index) -{ - strip_generation(&index); - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - int32_t offset = OFFSET(index); - - ecs_assert(chunk != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(dense == chunk->sparse[offset], ECS_INTERNAL_ERROR, NULL); - (void)dense; + b->content = result; - return DATA(chunk->data, sparse->size, offset); + return result; } -/* Swap dense elements. A swap occurs when an element is removed, or when a - * removed element is recycled. */ -static -void swap_dense( - ecs_sparse_t * sparse, - chunk_t * chunk_a, - int32_t a, - int32_t b) +char *ecs_strbuf_get_small( + ecs_strbuf_t *b) { - ecs_assert(a != b, ECS_INTERNAL_ERROR, NULL); - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - uint64_t index_a = dense_array[a]; - uint64_t index_b = dense_array[b]; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - chunk_t *chunk_b = get_or_create_chunk(sparse, CHUNK(index_b)); - assign_index(chunk_a, dense_array, index_a, b); - assign_index(chunk_b, dense_array, index_b, a); + int32_t written = ecs_strbuf_written(b); + ecs_assert(written <= ECS_STRBUF_ELEMENT_SIZE, ECS_INVALID_OPERATION, NULL); + char *buf = b->firstElement.buf; + buf[written] = '\0'; + return buf; } -void _flecs_sparse_init( - ecs_sparse_t *result, - ecs_size_t size) +void ecs_strbuf_reset( + ecs_strbuf_t *b) { - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - result->size = size; - result->max_id_local = UINT64_MAX; - result->max_id = &result->max_id_local; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - /* Consume first value in dense array as 0 is used in the sparse array to - * indicate that a sparse element hasn't been paired yet. */ - uint64_t *first = ecs_vector_add(&result->dense, uint64_t); - *first = 0; + if (b->elementCount && !b->buf) { + void *next = NULL; + ecs_strbuf_element *e = (ecs_strbuf_element*)&b->firstElement; + do { + next = e->next; + if (e != (ecs_strbuf_element*)&b->firstElement) { + ecs_os_free(e); + } + } while ((e = next)); + } - result->count = 1; + *b = ECS_STRBUF_INIT; } -ecs_sparse_t* _flecs_sparse_new( - ecs_size_t size) +void ecs_strbuf_list_push( + ecs_strbuf_t *b, + const char *list_open, + const char *separator) { - ecs_sparse_t *result = ecs_os_calloc_t(ecs_sparse_t); - - _flecs_sparse_init(result, size); - - return result; -} - -void flecs_sparse_set_id_source( - ecs_sparse_t * sparse, - uint64_t * id_source) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - sparse->max_id = id_source; -} - -void flecs_sparse_clear( - ecs_sparse_t *sparse) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_vector_each(sparse->chunks, chunk_t, chunk, { - chunk_free(chunk); - }); - - ecs_vector_free(sparse->chunks); - ecs_vector_set_count(&sparse->dense, uint64_t, 1); - - sparse->chunks = NULL; - sparse->count = 1; - sparse->max_id_local = 0; -} - -void _flecs_sparse_fini( - ecs_sparse_t *sparse) -{ - ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL); - flecs_sparse_clear(sparse); - ecs_vector_free(sparse->dense); -} - -void flecs_sparse_free( - ecs_sparse_t *sparse) -{ - if (sparse) { - _flecs_sparse_fini(sparse); - ecs_os_free(sparse); - } -} - -uint64_t flecs_sparse_new_id( - ecs_sparse_t *sparse) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - return new_index(sparse); -} - -const uint64_t* flecs_sparse_new_ids( - ecs_sparse_t *sparse, - int32_t new_count) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - int32_t dense_count = ecs_vector_count(sparse->dense); - int32_t count = sparse->count; - int32_t remaining = dense_count - count; - int32_t i, to_create = new_count - remaining; - - if (to_create > 0) { - flecs_sparse_set_size(sparse, dense_count + to_create); - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - - for (i = 0; i < to_create; i ++) { - uint64_t index = create_id(sparse, count + i); - dense_array[dense_count + i] = index; - } - } - - sparse->count += new_count; - - return ecs_vector_get(sparse->dense, uint64_t, count); -} - -void* _flecs_sparse_add( - ecs_sparse_t *sparse, - ecs_size_t size) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - uint64_t index = new_index(sparse); - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - ecs_assert(chunk != NULL, ECS_INTERNAL_ERROR, NULL); - return DATA(chunk->data, size, OFFSET(index)); -} - -uint64_t flecs_sparse_last_id( - const ecs_sparse_t *sparse) -{ - ecs_assert(sparse != NULL, ECS_INTERNAL_ERROR, NULL); - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - return dense_array[sparse->count - 1]; -} - -void* _flecs_sparse_ensure( - ecs_sparse_t *sparse, - ecs_size_t size, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - ecs_assert(ecs_vector_count(sparse->dense) > 0, ECS_INTERNAL_ERROR, NULL); - (void)size; - - uint64_t gen = strip_generation(&index); - chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - - if (dense) { - /* Check if element is alive. If element is not alive, update indices so - * that the first unused dense element points to the sparse element. */ - int32_t count = sparse->count; - if (dense == count) { - /* If dense is the next unused element in the array, simply increase - * the count to make it part of the alive set. */ - sparse->count ++; - } else if (dense > count) { - /* If dense is not alive, swap it with the first unused element. */ - swap_dense(sparse, chunk, dense, count); - - /* First unused element is now last used element */ - sparse->count ++; - } else { - /* Dense is already alive, nothing to be done */ - } - - /* Ensure provided generation matches current. Only allow mismatching - * generations if the provided generation count is 0. This allows for - * using the ensure function in combination with ids that have their - * generation stripped. */ - ecs_vector_t *dense_vector = sparse->dense; - uint64_t *dense_array = ecs_vector_first(dense_vector, uint64_t); - ecs_assert(!gen || dense_array[dense] == (index | gen), ECS_INTERNAL_ERROR, NULL); - (void)dense_vector; - (void)dense_array; - } else { - /* Element is not paired yet. Must add a new element to dense array */ - grow_dense(sparse); - - ecs_vector_t *dense_vector = sparse->dense; - uint64_t *dense_array = ecs_vector_first(dense_vector, uint64_t); - int32_t dense_count = ecs_vector_count(dense_vector) - 1; - int32_t count = sparse->count ++; - - /* If index is larger than max id, update max id */ - if (index >= get_id(sparse)) { - set_id(sparse, index); - } - - if (count < dense_count) { - /* If there are unused elements in the list, move the first unused - * element to the end of the list */ - uint64_t unused = dense_array[count]; - chunk_t *unused_chunk = get_or_create_chunk(sparse, CHUNK(unused)); - assign_index(unused_chunk, dense_array, unused, dense_count); - } - - assign_index(chunk, dense_array, index, count); - dense_array[count] |= gen; - } - - return DATA(chunk->data, sparse->size, offset); -} - -void* _flecs_sparse_set( - ecs_sparse_t * sparse, - ecs_size_t elem_size, - uint64_t index, - void* value) -{ - void *ptr = _flecs_sparse_ensure(sparse, elem_size, index); - ecs_os_memcpy(ptr, value, elem_size); - return ptr; -} - -void* _flecs_sparse_remove_get( - ecs_sparse_t *sparse, - ecs_size_t size, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - (void)size; - - chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); - uint64_t gen = strip_generation(&index); - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - - if (dense) { - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - uint64_t cur_gen = dense_array[dense] & ECS_GENERATION_MASK; - if (gen != cur_gen) { - /* Generation doesn't match which means that the provided entity is - * already not alive. */ - return NULL; - } - - /* Increase generation */ - dense_array[dense] = index | inc_gen(cur_gen); - - int32_t count = sparse->count; - - if (dense == (count - 1)) { - /* If dense is the last used element, simply decrease count */ - sparse->count --; - } else if (dense < count) { - /* If element is alive, move it to unused elements */ - swap_dense(sparse, chunk, dense, count - 1); - sparse->count --; - } else { - /* Element is not alive, nothing to be done */ - return NULL; - } - - /* Reset memory to zero on remove */ - return DATA(chunk->data, sparse->size, offset); - } else { - /* Element is not paired and thus not alive, nothing to be done */ - return NULL; - } -} - -void flecs_sparse_remove( - ecs_sparse_t *sparse, - uint64_t index) -{ - void *ptr = _flecs_sparse_remove_get(sparse, 0, index); - if (ptr) { - ecs_os_memset(ptr, 0, sparse->size); - } -} - -void flecs_sparse_set_generation( - ecs_sparse_t *sparse, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - chunk_t *chunk = get_or_create_chunk(sparse, CHUNK(index)); - - uint64_t index_w_gen = index; - strip_generation(&index); - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - - if (dense) { - /* Increase generation */ - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - dense_array[dense] = index_w_gen; - } else { - /* Element is not paired and thus not alive, nothing to be done */ - } -} - -bool flecs_sparse_exists( - const ecs_sparse_t *sparse, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - if (!chunk) { - return false; - } - - strip_generation(&index); - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - - return dense != 0; -} - -void* _flecs_sparse_get_dense( - const ecs_sparse_t *sparse, - ecs_size_t size, - int32_t dense_index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - ecs_assert(dense_index < sparse->count, ECS_INVALID_PARAMETER, NULL); - (void)size; - - dense_index ++; - - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - return get_sparse(sparse, dense_index, dense_array[dense_index]); -} - -bool flecs_sparse_is_alive( - const ecs_sparse_t *sparse, - uint64_t index) -{ - return try_sparse(sparse, index) != NULL; -} - -uint64_t flecs_sparse_get_alive( - const ecs_sparse_t *sparse, - uint64_t index) -{ - chunk_t *chunk = get_chunk(sparse, CHUNK(index)); - if (!chunk) { - return 0; - } - - int32_t offset = OFFSET(index); - int32_t dense = chunk->sparse[offset]; - uint64_t *dense_array = ecs_vector_first(sparse->dense, uint64_t); - - /* If dense is 0 (tombstone) this will return 0 */ - return dense_array[dense]; -} - -void* _flecs_sparse_get( - const ecs_sparse_t *sparse, - ecs_size_t size, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - (void)size; - return try_sparse(sparse, index); -} - -void* _flecs_sparse_get_any( - const ecs_sparse_t *sparse, - ecs_size_t size, - uint64_t index) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!size || size == sparse->size, ECS_INVALID_PARAMETER, NULL); - (void)size; - return try_sparse_any(sparse, index); -} - -int32_t flecs_sparse_count( - const ecs_sparse_t *sparse) -{ - if (!sparse) { - return 0; - } + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(list_open != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(separator != NULL, ECS_INVALID_PARAMETER, NULL); - return sparse->count - 1; -} + b->list_sp ++; + b->list_stack[b->list_sp].count = 0; + b->list_stack[b->list_sp].separator = separator; -int32_t flecs_sparse_size( - const ecs_sparse_t *sparse) -{ - if (!sparse) { - return 0; + if (list_open) { + ecs_strbuf_appendstr(b, list_open); } - - return ecs_vector_count(sparse->dense) - 1; -} - -const uint64_t* flecs_sparse_ids( - const ecs_sparse_t *sparse) -{ - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - return &(ecs_vector_first(sparse->dense, uint64_t)[1]); } -void flecs_sparse_set_size( - ecs_sparse_t *sparse, - int32_t elem_count) +void ecs_strbuf_list_pop( + ecs_strbuf_t *b, + const char *list_close) { - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_vector_set_size(&sparse->dense, uint64_t, elem_count); -} + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(list_close != NULL, ECS_INVALID_PARAMETER, NULL); -static -void sparse_copy( - ecs_sparse_t * dst, - const ecs_sparse_t * src) -{ - flecs_sparse_set_size(dst, flecs_sparse_size(src)); - const uint64_t *indices = flecs_sparse_ids(src); + b->list_sp --; - ecs_size_t size = src->size; - int32_t i, count = src->count; - - for (i = 0; i < count - 1; i ++) { - uint64_t index = indices[i]; - void *src_ptr = _flecs_sparse_get(src, size, index); - void *dst_ptr = _flecs_sparse_ensure(dst, size, index); - flecs_sparse_set_generation(dst, index); - ecs_os_memcpy(dst_ptr, src_ptr, size); + if (list_close) { + ecs_strbuf_appendstr(b, list_close); } - - set_id(dst, get_id(src)); - - ecs_assert(src->count == dst->count, ECS_INTERNAL_ERROR, NULL); } -ecs_sparse_t* flecs_sparse_copy( - const ecs_sparse_t *src) +void ecs_strbuf_list_next( + ecs_strbuf_t *b) { - if (!src) { - return NULL; - } - - ecs_sparse_t *dst = _flecs_sparse_new(src->size); - sparse_copy(dst, src); - - return dst; -} + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); -void flecs_sparse_restore( - ecs_sparse_t * dst, - const ecs_sparse_t * src) -{ - ecs_assert(dst != NULL, ECS_INVALID_PARAMETER, NULL); - dst->count = 1; - if (src) { - sparse_copy(dst, src); + int32_t list_sp = b->list_sp; + if (b->list_stack[list_sp].count != 0) { + ecs_strbuf_appendstr(b, b->list_stack[list_sp].separator); } + b->list_stack[list_sp].count ++; } -void flecs_sparse_memory( - ecs_sparse_t *sparse, - int32_t *allocd, - int32_t *used) -{ - (void)sparse; - (void)allocd; - (void)used; -} - -ecs_sparse_t* _ecs_sparse_new( - ecs_size_t elem_size) +bool ecs_strbuf_list_append( + ecs_strbuf_t *b, + const char *fmt, + ...) { - return _flecs_sparse_new(elem_size); -} + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); -void* _ecs_sparse_add( - ecs_sparse_t *sparse, - ecs_size_t elem_size) -{ - return _flecs_sparse_add(sparse, elem_size); -} + ecs_strbuf_list_next(b); -uint64_t ecs_sparse_last_id( - const ecs_sparse_t *sparse) -{ - return flecs_sparse_last_id(sparse); -} + va_list args; + va_start(args, fmt); + bool result = vappend(b, fmt, args); + va_end(args); -int32_t ecs_sparse_count( - const ecs_sparse_t *sparse) -{ - return flecs_sparse_count(sparse); + return result; } -void* _ecs_sparse_get_dense( - const ecs_sparse_t *sparse, - ecs_size_t elem_size, - int32_t index) +bool ecs_strbuf_list_appendstr( + ecs_strbuf_t *b, + const char *str) { - return _flecs_sparse_get_dense(sparse, elem_size, index); -} + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); -void* _ecs_sparse_get( - const ecs_sparse_t *sparse, - ecs_size_t elem_size, - uint64_t id) -{ - return _flecs_sparse_get(sparse, elem_size, id); + ecs_strbuf_list_next(b); + return ecs_strbuf_appendstr(b, str); } -ecs_sparse_iter_t _flecs_sparse_iter( - ecs_sparse_t *sparse, - ecs_size_t elem_size) +int32_t ecs_strbuf_written( + const ecs_strbuf_t *b) { - ecs_assert(sparse != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(elem_size == sparse->size, ECS_INVALID_PARAMETER, NULL); - ecs_sparse_iter_t result; - result.sparse = sparse; - result.ids = flecs_sparse_ids(sparse); - result.size = elem_size; - result.i = 0; - result.count = sparse->count - 1; - return result; + ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); + return b->size + b->current->pos; } @@ -11221,1671 +11030,791 @@ int32_t flecs_switch_next( } -static -uint64_t name_index_hash( - const void *ptr) -{ - const ecs_hashed_string_t *str = ptr; - ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL); - return str->hash; -} +struct ecs_vector_t { + int32_t count; + int32_t size; + +#ifndef FLECS_NDEBUG + int64_t elem_size; /* Used in debug mode to validate size */ +#endif +}; +/** Resize the vector buffer */ static -int name_index_compare( - const void *ptr1, - const void *ptr2) +ecs_vector_t* resize( + ecs_vector_t *vector, + int16_t offset, + int32_t size) { - const ecs_hashed_string_t *str1 = ptr1; - const ecs_hashed_string_t *str2 = ptr2; - ecs_size_t len1 = str1->length; - ecs_size_t len2 = str2->length; - if (len1 != len2) { - return (len1 > len2) - (len1 < len2); - } - - return ecs_os_memcmp(str1->value, str2->value, len1); + ecs_vector_t *result = ecs_os_realloc(vector, offset + size); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, 0); + return result; } -void flecs_name_index_init( - ecs_hashmap_t *hm) +/* -- Public functions -- */ + +ecs_vector_t* _ecs_vector_new( + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - _flecs_hashmap_init(hm, - ECS_SIZEOF(ecs_hashed_string_t), ECS_SIZEOF(uint64_t), - name_index_hash, - name_index_compare); + ecs_assert(elem_size != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_vector_t *result = + ecs_os_malloc(offset + elem_size * elem_count); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + + result->count = 0; + result->size = elem_count; +#ifndef FLECS_NDEBUG + result->elem_size = elem_size; +#endif + return result; } -ecs_hashmap_t* flecs_name_index_new(void) +ecs_vector_t* _ecs_vector_from_array( + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count, + void *array) { - ecs_hashmap_t *result = ecs_os_calloc_t(ecs_hashmap_t); - flecs_name_index_init(result); - return result; + ecs_assert(elem_size != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_vector_t *result = + ecs_os_malloc(offset + elem_size * elem_count); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + + ecs_os_memcpy(ECS_OFFSET(result, offset), array, elem_size * elem_count); + + result->count = elem_count; + result->size = elem_count; +#ifndef FLECS_NDEBUG + result->elem_size = elem_size; +#endif + return result; } -void flecs_name_index_fini( - ecs_hashmap_t *map) +void ecs_vector_free( + ecs_vector_t *vector) { - flecs_hashmap_fini(map); + ecs_os_free(vector); } -void flecs_name_index_free( - ecs_hashmap_t *map) +void ecs_vector_clear( + ecs_vector_t *vector) { - if (map) { - flecs_name_index_fini(map); - ecs_os_free(map); + if (vector) { + vector->count = 0; } } -ecs_hashed_string_t flecs_get_hashed_string( - const char *name, - ecs_size_t length, - uint64_t hash) +void _ecs_vector_zero( + ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset) { - if (!length) { - length = ecs_os_strlen(name); - } else { - ecs_assert(length == ecs_os_strlen(name), ECS_INTERNAL_ERROR, NULL); - } + void *array = ECS_OFFSET(vector, offset); + ecs_os_memset(array, 0, elem_size * vector->count); +} - if (!hash) { - hash = flecs_hash(name, length); - } else { - ecs_assert(hash == flecs_hash(name, length), ECS_INTERNAL_ERROR, NULL); +void ecs_vector_assert_size( + ecs_vector_t *vector, + ecs_size_t elem_size) +{ + (void)elem_size; + + if (vector) { + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); } - - return (ecs_hashed_string_t) { - .value = (char*)name, - .length = length, - .hash = hash - }; } -const uint64_t* flecs_name_index_find_ptr( - const ecs_hashmap_t *map, - const char *name, - ecs_size_t length, - uint64_t hash) +void* _ecs_vector_addn( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - ecs_hashed_string_t hs = flecs_get_hashed_string(name, length, hash); - - ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hs.hash); - if (!b) { - return NULL; + ecs_assert(array_inout != NULL, ECS_INTERNAL_ERROR, NULL); + + if (elem_count == 1) { + return _ecs_vector_add(array_inout, elem_size, offset); + } + + ecs_vector_t *vector = *array_inout; + if (!vector) { + vector = _ecs_vector_new(elem_size, offset, 1); + *array_inout = vector; } - ecs_hashed_string_t *keys = ecs_vector_first(b->keys, ecs_hashed_string_t); - int32_t i, count = ecs_vector_count(b->keys); + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < count; i ++) { - ecs_hashed_string_t *key = &keys[i]; - ecs_assert(key->hash == hs.hash, ECS_INTERNAL_ERROR, NULL); + int32_t max_count = vector->size; + int32_t old_count = vector->count; + int32_t new_count = old_count + elem_count; - if (hs.length != key->length) { - continue; + if ((new_count - 1) >= max_count) { + if (!max_count) { + max_count = elem_count; + } else { + while (max_count < new_count) { + max_count *= 2; + } } - if (!ecs_os_strcmp(name, key->value)) { - uint64_t *e = ecs_vector_get(b->values, uint64_t, i); - ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); - return e; - } + vector = resize(vector, offset, max_count * elem_size); + vector->size = max_count; + *array_inout = vector; } - return NULL; -} + vector->count = new_count; -uint64_t flecs_name_index_find( - const ecs_hashmap_t *map, - const char *name, - ecs_size_t length, - uint64_t hash) -{ - const uint64_t *id = flecs_name_index_find_ptr(map, name, length, hash); - if (id) { - return id[0]; - } - return 0; + return ECS_OFFSET(vector, offset + elem_size * old_count); } -void flecs_name_index_remove( - ecs_hashmap_t *map, - uint64_t e, - uint64_t hash) +void* _ecs_vector_add( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset) { - ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash); - if (!b) { - return; - } + ecs_assert(array_inout != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_vector_t *vector = *array_inout; + int32_t count, size; - uint64_t *ids = ecs_vector_first(b->values, uint64_t); - int32_t i, count = ecs_vector_count(b->values); + if (vector) { + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + count = vector->count; + size = vector->size; - for (i = 0; i < count; i ++) { - if (ids[i] == e) { - flecs_hm_bucket_remove(map, b, hash, i); - break; + if (count >= size) { + size *= 2; + if (!size) { + size = 2; + } + vector = resize(vector, offset, size * elem_size); + *array_inout = vector; + vector->size = size; } + + vector->count = count + 1; + return ECS_OFFSET(vector, offset + elem_size * count); } + + vector = _ecs_vector_new(elem_size, offset, 2); + *array_inout = vector; + vector->count = 1; + vector->size = 2; + return ECS_OFFSET(vector, offset); } -void flecs_name_index_update_name( - ecs_hashmap_t *map, - uint64_t e, - uint64_t hash, - const char *name) +void* _ecs_vector_insert_at( + ecs_vector_t **vec, + ecs_size_t elem_size, + int16_t offset, + int32_t index) { - ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash); - if (!b) { - return; + ecs_assert(vec != NULL, ECS_INTERNAL_ERROR, NULL); + int32_t count = vec[0]->count; + if (index == count) { + return _ecs_vector_add(vec, elem_size, offset); } + ecs_assert(index < count, ECS_INTERNAL_ERROR, NULL); + ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); - uint64_t *ids = ecs_vector_first(b->values, uint64_t); - int32_t i, count = ecs_vector_count(b->values); - - for (i = 0; i < count; i ++) { - if (ids[i] == e) { - ecs_hashed_string_t *key = ecs_vector_get( - b->keys, ecs_hashed_string_t, i); - key->value = (char*)name; - ecs_assert(ecs_os_strlen(name) == key->length, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(flecs_hash(name, key->length) == key->hash, - ECS_INTERNAL_ERROR, NULL); - return; - } + _ecs_vector_add(vec, elem_size, offset); + void *start = _ecs_vector_get(*vec, elem_size, offset, index); + if (index < count) { + ecs_os_memmove(ECS_OFFSET(start, elem_size), start, + (count - index) * elem_size); } - /* Record must already have been in the index */ - ecs_abort(ECS_INTERNAL_ERROR, NULL); + return start; } -void flecs_name_index_ensure( - ecs_hashmap_t *map, - uint64_t id, - const char *name, - ecs_size_t length, - uint64_t hash) +int32_t _ecs_vector_move_index( + ecs_vector_t **dst, + ecs_vector_t *src, + ecs_size_t elem_size, + int16_t offset, + int32_t index) { - ecs_check(name != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_hashed_string_t key = flecs_get_hashed_string(name, length, hash); - - uint64_t existing = flecs_name_index_find( - map, name, key.length, key.hash); - if (existing) { - if (existing != id) { - ecs_abort(ECS_ALREADY_DEFINED, - "conflicting id registered with name '%s'", name); - } + if (dst && *dst) { + ecs_dbg_assert((*dst)->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); } + ecs_dbg_assert(src->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - flecs_hashmap_result_t hmr = flecs_hashmap_ensure( - map, &key, uint64_t); + void *dst_elem = _ecs_vector_add(dst, elem_size, offset); + void *src_elem = _ecs_vector_get(src, elem_size, offset, index); - *((uint64_t*)hmr.value) = id; -error: - return; + ecs_os_memcpy(dst_elem, src_elem, elem_size); + return _ecs_vector_remove(src, elem_size, offset, index); } +void ecs_vector_remove_last( + ecs_vector_t *vector) +{ + if (vector && vector->count) vector->count --; +} -#ifdef ECS_TARGET_GNU -#pragma GCC diagnostic ignored "-Wimplicit-fallthrough" -#endif +bool _ecs_vector_pop( + ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset, + void *value) +{ + if (!vector) { + return false; + } -/* See explanation below. The hashing function may read beyond the memory passed - * into the hashing function, but only at word boundaries. This should be safe, - * but trips up address sanitizers and valgrind. - * This ensures clean valgrind logs in debug mode & the best perf in release */ -#if !defined(FLECS_NDEBUG) || defined(ADDRESS_SANITIZER) -#ifndef VALGRIND -#define VALGRIND -#endif -#endif + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); -/* -------------------------------------------------------------------------------- -lookup3.c, by Bob Jenkins, May 2006, Public Domain. - http://burtleburtle.net/bob/c/lookup3.c -------------------------------------------------------------------------------- -*/ + int32_t count = vector->count; + if (!count) { + return false; + } -#ifdef ECS_TARGET_MSVC -//FIXME -#else -#include /* attempt to define endianness */ -#endif -#ifdef ECS_TARGET_LINUX -# include /* attempt to define endianness */ -#endif + void *elem = ECS_OFFSET(vector, offset + (count - 1) * elem_size); -/* - * My best guess at if you are big-endian or little-endian. This may - * need adjustment. - */ -#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \ - __BYTE_ORDER == __LITTLE_ENDIAN) || \ - (defined(i386) || defined(__i386__) || defined(__i486__) || \ - defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL)) -# define HASH_LITTLE_ENDIAN 1 -#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \ - __BYTE_ORDER == __BIG_ENDIAN) || \ - (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel)) -# define HASH_LITTLE_ENDIAN 0 -#else -# define HASH_LITTLE_ENDIAN 0 -#endif + if (value) { + ecs_os_memcpy(value, elem, elem_size); + } -#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k)))) + ecs_vector_remove_last(vector); -/* -------------------------------------------------------------------------------- -mix -- mix 3 32-bit values reversibly. -This is reversible, so any information in (a,b,c) before mix() is -still in (a,b,c) after mix(). -If four pairs of (a,b,c) inputs are run through mix(), or through -mix() in reverse, there are at least 32 bits of the output that -are sometimes the same for one pair and different for another pair. -This was tested for: -* pairs that differed by one bit, by two bits, in any combination - of top bits of (a,b,c), or in any combination of bottom bits of - (a,b,c). -* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed - the output delta to a Gray code (a^(a>>1)) so a string of 1's (as - is commonly produced by subtraction) look like a single 1-bit - difference. -* the base values were pseudorandom, all zero but one bit set, or - all zero plus a counter that starts at zero. -Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that -satisfy this are - 4 6 8 16 19 4 - 9 15 3 18 27 15 - 14 9 3 7 17 3 -Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing -for "differ" defined as + with a one-bit base and a two-bit delta. I -used http://burtleburtle.net/bob/hash/avalanche.html to choose -the operations, constants, and arrangements of the variables. -This does not achieve avalanche. There are input bits of (a,b,c) -that fail to affect some output bits of (a,b,c), especially of a. The -most thoroughly mixed value is c, but it doesn't really even achieve -avalanche in c. -This allows some parallelism. Read-after-writes are good at doubling -the number of bits affected, so the goal of mixing pulls in the opposite -direction as the goal of parallelism. I did what I could. Rotates -seem to cost as much as shifts on every machine I could lay my hands -on, and rotates are much kinder to the top and bottom bits, so I used -rotates. -------------------------------------------------------------------------------- -*/ -#define mix(a,b,c) \ -{ \ - a -= c; a ^= rot(c, 4); c += b; \ - b -= a; b ^= rot(a, 6); a += c; \ - c -= b; c ^= rot(b, 8); b += a; \ - a -= c; a ^= rot(c,16); c += b; \ - b -= a; b ^= rot(a,19); a += c; \ - c -= b; c ^= rot(b, 4); b += a; \ + return true; } -/* -------------------------------------------------------------------------------- -final -- final mixing of 3 32-bit values (a,b,c) into c -Pairs of (a,b,c) values differing in only a few bits will usually -produce values of c that look totally different. This was tested for -* pairs that differed by one bit, by two bits, in any combination - of top bits of (a,b,c), or in any combination of bottom bits of - (a,b,c). -* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed - the output delta to a Gray code (a^(a>>1)) so a string of 1's (as - is commonly produced by subtraction) look like a single 1-bit - difference. -* the base values were pseudorandom, all zero but one bit set, or - all zero plus a counter that starts at zero. -These constants passed: - 14 11 25 16 4 14 24 - 12 14 25 16 4 14 24 -and these came close: - 4 8 15 26 3 22 24 - 10 8 15 26 3 22 24 - 11 8 15 26 3 22 24 -------------------------------------------------------------------------------- -*/ -#define final(a,b,c) \ -{ \ - c ^= b; c -= rot(b,14); \ - a ^= c; a -= rot(c,11); \ - b ^= a; b -= rot(a,25); \ - c ^= b; c -= rot(b,16); \ - a ^= c; a -= rot(c,4); \ - b ^= a; b -= rot(a,14); \ - c ^= b; c -= rot(b,24); \ -} +int32_t _ecs_vector_remove( + ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset, + int32_t index) +{ + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + + int32_t count = vector->count; + void *buffer = ECS_OFFSET(vector, offset); + void *elem = ECS_OFFSET(buffer, index * elem_size); + ecs_assert(index < count, ECS_INVALID_PARAMETER, NULL); -/* - * hashlittle2: return 2 32-bit hash values - * - * This is identical to hashlittle(), except it returns two 32-bit hash - * values instead of just one. This is good enough for hash table - * lookup with 2^^64 buckets, or if you want a second hash if you're not - * happy with the first, or if you want a probably-unique 64-bit ID for - * the key. *pc is better mixed than *pb, so use *pc first. If you want - * a 64-bit value do something like "*pc + (((uint64_t)*pb)<<32)". - */ -static -void hashlittle2( - const void *key, /* the key to hash */ - size_t length, /* length of the key */ - uint32_t *pc, /* IN: primary initval, OUT: primary hash */ - uint32_t *pb) /* IN: secondary initval, OUT: secondary hash */ -{ - uint32_t a,b,c; /* internal state */ - union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ + count --; + if (index != count) { + void *last_elem = ECS_OFFSET(buffer, elem_size * count); + ecs_os_memcpy(elem, last_elem, elem_size); + } - /* Set up the internal state */ - a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc; - c += *pb; + vector->count = count; - u.ptr = key; - if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) { - const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */ - const uint8_t *k8; - (void)k8; + return count; +} - /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */ - while (length > 12) - { - a += k[0]; - b += k[1]; - c += k[2]; - mix(a,b,c); - length -= 12; - k += 3; - } +void _ecs_vector_reclaim( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset) +{ + ecs_vector_t *vector = *array_inout; - /*----------------------------- handle the last (probably partial) block */ - /* - * "k[2]&0xffffff" actually reads beyond the end of the string, but - * then masks off the part it's not allowed to read. Because the - * string is aligned, the masked-off tail is in the same word as the - * rest of the string. Every machine with memory protection I've seen - * does it on word boundaries, so is OK with this. But VALGRIND will - * still catch it and complain. The masking trick does make the hash - * noticably faster for short strings (like English words). - */ -#ifndef VALGRIND + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + + int32_t size = vector->size; + int32_t count = vector->count; - switch(length) - { - case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; - case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break; - case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break; - case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break; - case 8 : b+=k[1]; a+=k[0]; break; - case 7 : b+=k[1]&0xffffff; a+=k[0]; break; - case 6 : b+=k[1]&0xffff; a+=k[0]; break; - case 5 : b+=k[1]&0xff; a+=k[0]; break; - case 4 : a+=k[0]; break; - case 3 : a+=k[0]&0xffffff; break; - case 2 : a+=k[0]&0xffff; break; - case 1 : a+=k[0]&0xff; break; - case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ + if (count < size) { + size = count; + vector = resize(vector, offset, size * elem_size); + vector->size = size; + *array_inout = vector; } +} -#else /* make valgrind happy */ - - k8 = (const uint8_t *)k; - switch(length) - { - case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; - case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ - case 10: c+=((uint32_t)k8[9])<<8; /* fall through */ - case 9 : c+=k8[8]; /* fall through */ - case 8 : b+=k[1]; a+=k[0]; break; - case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ - case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */ - case 5 : b+=k8[4]; /* fall through */ - case 4 : a+=k[0]; break; - case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ - case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */ - case 1 : a+=k8[0]; break; - case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ +int32_t ecs_vector_count( + const ecs_vector_t *vector) +{ + if (!vector) { + return 0; } + return vector->count; +} -#endif /* !valgrind */ +int32_t ecs_vector_size( + const ecs_vector_t *vector) +{ + if (!vector) { + return 0; + } + return vector->size; +} - } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { - const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */ - const uint8_t *k8; +int32_t _ecs_vector_set_size( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) +{ + ecs_vector_t *vector = *array_inout; - /*--------------- all but last block: aligned reads and different mixing */ - while (length > 12) - { - a += k[0] + (((uint32_t)k[1])<<16); - b += k[2] + (((uint32_t)k[3])<<16); - c += k[4] + (((uint32_t)k[5])<<16); - mix(a,b,c); - length -= 12; - k += 6; - } + if (!vector) { + *array_inout = _ecs_vector_new(elem_size, offset, elem_count); + return elem_count; + } else { + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - /*----------------------------- handle the last (probably partial) block */ - k8 = (const uint8_t *)k; - switch(length) - { - case 12: c+=k[4]+(((uint32_t)k[5])<<16); - b+=k[2]+(((uint32_t)k[3])<<16); - a+=k[0]+(((uint32_t)k[1])<<16); - break; - case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ - case 10: c+=k[4]; - b+=k[2]+(((uint32_t)k[3])<<16); - a+=k[0]+(((uint32_t)k[1])<<16); - break; - case 9 : c+=k8[8]; /* fall through */ - case 8 : b+=k[2]+(((uint32_t)k[3])<<16); - a+=k[0]+(((uint32_t)k[1])<<16); - break; - case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ - case 6 : b+=k[2]; - a+=k[0]+(((uint32_t)k[1])<<16); - break; - case 5 : b+=k8[4]; /* fall through */ - case 4 : a+=k[0]+(((uint32_t)k[1])<<16); - break; - case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ - case 2 : a+=k[0]; - break; - case 1 : a+=k8[0]; - break; - case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ - } + int32_t result = vector->size; - } else { /* need to read the key one byte at a time */ - const uint8_t *k = (const uint8_t *)key; + if (elem_count < vector->count) { + elem_count = vector->count; + } - /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ - while (length > 12) - { - a += k[0]; - a += ((uint32_t)k[1])<<8; - a += ((uint32_t)k[2])<<16; - a += ((uint32_t)k[3])<<24; - b += k[4]; - b += ((uint32_t)k[5])<<8; - b += ((uint32_t)k[6])<<16; - b += ((uint32_t)k[7])<<24; - c += k[8]; - c += ((uint32_t)k[9])<<8; - c += ((uint32_t)k[10])<<16; - c += ((uint32_t)k[11])<<24; - mix(a,b,c); - length -= 12; - k += 12; - } + if (result < elem_count) { + elem_count = flecs_next_pow_of_2(elem_count); + vector = resize(vector, offset, elem_count * elem_size); + vector->size = elem_count; + *array_inout = vector; + result = elem_count; + } - /*-------------------------------- last block: affect all 32 bits of (c) */ - switch(length) /* all the case statements fall through */ - { - case 12: c+=((uint32_t)k[11])<<24; - case 11: c+=((uint32_t)k[10])<<16; - case 10: c+=((uint32_t)k[9])<<8; - case 9 : c+=k[8]; - case 8 : b+=((uint32_t)k[7])<<24; - case 7 : b+=((uint32_t)k[6])<<16; - case 6 : b+=((uint32_t)k[5])<<8; - case 5 : b+=k[4]; - case 4 : a+=((uint32_t)k[3])<<24; - case 3 : a+=((uint32_t)k[2])<<16; - case 2 : a+=((uint32_t)k[1])<<8; - case 1 : a+=k[0]; - break; - case 0 : *pc=c; *pb=b; return; /* zero length strings require no mixing */ + return result; } - } - - final(a,b,c); - *pc=c; *pb=b; } -uint64_t flecs_hash( - const void *data, - ecs_size_t length) +int32_t _ecs_vector_grow( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - uint32_t h_1 = 0; - uint32_t h_2 = 0; - - hashlittle2( - data, - flecs_ito(size_t, length), - &h_1, - &h_2); - - return h_1 | ((uint64_t)h_2 << 32); + int32_t current = ecs_vector_count(*array_inout); + return _ecs_vector_set_size(array_inout, elem_size, offset, current + elem_count); } - -void ecs_qsort( - void *base, - ecs_size_t nitems, - ecs_size_t size, - int (*compar)(const void *, const void*)) +int32_t _ecs_vector_set_count( + ecs_vector_t **array_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - void *tmp = ecs_os_alloca(size); /* For swap */ - - #define LESS(i, j) \ - compar(ECS_ELEM(base, size, i), ECS_ELEM(base, size, j)) < 0 + if (!*array_inout) { + *array_inout = _ecs_vector_new(elem_size, offset, elem_count); + } - #define SWAP(i, j) \ - ecs_os_memcpy(tmp, ECS_ELEM(base, size, i), size),\ - ecs_os_memcpy(ECS_ELEM(base, size, i), ECS_ELEM(base, size, j), size),\ - ecs_os_memcpy(ECS_ELEM(base, size, j), tmp, size) + ecs_dbg_assert((*array_inout)->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); - QSORT(nitems, LESS, SWAP); + (*array_inout)->count = elem_count; + ecs_size_t size = _ecs_vector_set_size(array_inout, elem_size, offset, elem_count); + return size; } - - -static -void ensure( - ecs_bitset_t *bs, - ecs_size_t size) +void* _ecs_vector_first( + const ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset) { - if (!bs->size) { - int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); - bs->size = ((size - 1) / 64 + 1) * 64; - bs->data = ecs_os_calloc(new_size); - } else if (size > bs->size) { - int32_t prev_size = ((bs->size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); - bs->size = ((size - 1) / 64 + 1) * 64; - int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); - bs->data = ecs_os_realloc(bs->data, new_size); - ecs_os_memset(ECS_OFFSET(bs->data, prev_size), 0, new_size - prev_size); + (void)elem_size; + + ecs_dbg_assert(!vector || vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + if (vector && vector->size) { + return ECS_OFFSET(vector, offset); + } else { + return NULL; } } -void flecs_bitset_init( - ecs_bitset_t* bs) +void* _ecs_vector_get( + const ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset, + int32_t index) { - bs->size = 0; - bs->count = 0; - bs->data = NULL; + ecs_assert(vector != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + ecs_assert(index >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(index < vector->count, ECS_INTERNAL_ERROR, NULL); + + return ECS_OFFSET(vector, offset + elem_size * index); } -void flecs_bitset_ensure( - ecs_bitset_t *bs, - int32_t count) +void* _ecs_vector_last( + const ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset) { - if (count > bs->count) { - bs->count = count; - ensure(bs, count); + if (vector) { + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + int32_t count = vector->count; + if (!count) { + return NULL; + } else { + return ECS_OFFSET(vector, offset + elem_size * (count - 1)); + } + } else { + return NULL; } } -void flecs_bitset_fini( - ecs_bitset_t *bs) +int32_t _ecs_vector_set_min_size( + ecs_vector_t **vector_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - ecs_os_free(bs->data); - bs->data = NULL; - bs->count = 0; + if (!*vector_inout || (*vector_inout)->size < elem_count) { + return _ecs_vector_set_size(vector_inout, elem_size, offset, elem_count); + } else { + return (*vector_inout)->size; + } } -void flecs_bitset_addn( - ecs_bitset_t *bs, - int32_t count) +int32_t _ecs_vector_set_min_count( + ecs_vector_t **vector_inout, + ecs_size_t elem_size, + int16_t offset, + int32_t elem_count) { - int32_t elem = bs->count += count; - ensure(bs, elem); -} + _ecs_vector_set_min_size(vector_inout, elem_size, offset, elem_count); -void flecs_bitset_set( - ecs_bitset_t *bs, - int32_t elem, - bool value) -{ - ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); - int32_t hi = elem >> 6; - int32_t lo = elem & 0x3F; - uint64_t v = bs->data[hi]; - bs->data[hi] = (v & ~((uint64_t)1 << lo)) | ((uint64_t)value << lo); -error: - return; -} + ecs_vector_t *v = *vector_inout; + if (v && v->count < elem_count) { + v->count = elem_count; + } -bool flecs_bitset_get( - const ecs_bitset_t *bs, - int32_t elem) -{ - ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); - return !!(bs->data[elem >> 6] & ((uint64_t)1 << ((uint64_t)elem & 0x3F))); -error: - return false; + return v->count; } -int32_t flecs_bitset_count( - const ecs_bitset_t *bs) +void _ecs_vector_sort( + ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset, + ecs_comparator_t compare_action) { - return bs->count; + if (!vector) { + return; + } + + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + + int32_t count = vector->count; + void *buffer = ECS_OFFSET(vector, offset); + + if (count > 1) { + qsort(buffer, (size_t)count, (size_t)elem_size, compare_action); + } } -void flecs_bitset_remove( - ecs_bitset_t *bs, - int32_t elem) +void _ecs_vector_memory( + const ecs_vector_t *vector, + ecs_size_t elem_size, + int16_t offset, + int32_t *allocd, + int32_t *used) { - ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); - int32_t last = bs->count - 1; - bool last_value = flecs_bitset_get(bs, last); - flecs_bitset_set(bs, elem, last_value); - bs->count --; -error: - return; + if (!vector) { + return; + } + + ecs_dbg_assert(vector->elem_size == elem_size, ECS_INTERNAL_ERROR, NULL); + + if (allocd) { + *allocd += vector->size * elem_size + offset; + } + if (used) { + *used += vector->count * elem_size; + } } -void flecs_bitset_swap( - ecs_bitset_t *bs, - int32_t elem_a, - int32_t elem_b) +ecs_vector_t* _ecs_vector_copy( + const ecs_vector_t *src, + ecs_size_t elem_size, + int16_t offset) { - ecs_check(elem_a < bs->count, ECS_INVALID_PARAMETER, NULL); - ecs_check(elem_b < bs->count, ECS_INVALID_PARAMETER, NULL); + if (!src) { + return NULL; + } - bool a = flecs_bitset_get(bs, elem_a); - bool b = flecs_bitset_get(bs, elem_b); - flecs_bitset_set(bs, elem_a, b); - flecs_bitset_set(bs, elem_b, a); -error: - return; + ecs_vector_t *dst = _ecs_vector_new(elem_size, offset, src->size); + ecs_os_memcpy(dst, src, offset + elem_size * src->count); + return dst; } -#include #include -/** - * stm32tpl -- STM32 C++ Template Peripheral Library - * Visit https://github.com/antongus/stm32tpl for new versions - * - * Copyright (c) 2011-2020 Anton B. Gusev aka AHTOXA - */ +/* The ratio used to determine whether the map should rehash. If + * (element_count * LOAD_FACTOR) > bucket_count, bucket count is increased. */ +#define LOAD_FACTOR (1.5f) +#define KEY_SIZE (ECS_SIZEOF(ecs_map_key_t)) +#define GET_ELEM(array, elem_size, index) \ + ECS_OFFSET(array, (elem_size) * (index)) -#define MAX_PRECISION (10) -#define EXP_THRESHOLD (3) -#define INT64_MAX_F ((double)INT64_MAX) +static +uint8_t ecs_log2(uint32_t v) { + static const uint8_t log2table[32] = + {0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, + 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31}; -static const double rounders[MAX_PRECISION + 1] = -{ - 0.5, // 0 - 0.05, // 1 - 0.005, // 2 - 0.0005, // 3 - 0.00005, // 4 - 0.000005, // 5 - 0.0000005, // 6 - 0.00000005, // 7 - 0.000000005, // 8 - 0.0000000005, // 9 - 0.00000000005 // 10 -}; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + return log2table[(uint32_t)(v * 0x07C4ACDDU) >> 27]; +} +/* Get bucket count for number of elements */ static -char* strbuf_itoa( - char *buf, - int64_t v) +int32_t get_bucket_count( + int32_t element_count) { - char *ptr = buf; - char * p1; - char c; - - if (!v) { - *ptr++ = '0'; - } else { - char *p = ptr; - while (v) { - *p++ = (char)('0' + v % 10); - v /= 10; - } - - p1 = p; - - while (p > ptr) { - c = *--p; - *p = *ptr; - *ptr++ = c; - } - ptr = p1; - } - return ptr; + return flecs_next_pow_of_2((int32_t)((float)element_count * LOAD_FACTOR)); } +/* Get bucket shift amount for a given bucket count */ static -int ecs_strbuf_ftoa( - ecs_strbuf_t *out, - double f, - int precision, - char nan_delim) +uint8_t get_bucket_shift ( + int32_t bucket_count) { - char buf[64]; - char * ptr = buf; - char c; - int64_t intPart; - int64_t exp = 0; + return (uint8_t)(64u - ecs_log2((uint32_t)bucket_count)); +} - if (isnan(f)) { - if (nan_delim) { - ecs_strbuf_appendch(out, nan_delim); - ecs_strbuf_appendstr(out, "NaN"); - return ecs_strbuf_appendch(out, nan_delim); - } else { - return ecs_strbuf_appendstr(out, "NaN"); - } - } - if (isinf(f)) { - if (nan_delim) { - ecs_strbuf_appendch(out, nan_delim); - ecs_strbuf_appendstr(out, "Inf"); - return ecs_strbuf_appendch(out, nan_delim); - } else { - return ecs_strbuf_appendstr(out, "Inf"); - } - } - - if (precision > MAX_PRECISION) { - precision = MAX_PRECISION; - } - - if (f < 0) { - f = -f; - *ptr++ = '-'; - } - - if (precision < 0) { - if (f < 1.0) precision = 6; - else if (f < 10.0) precision = 5; - else if (f < 100.0) precision = 4; - else if (f < 1000.0) precision = 3; - else if (f < 10000.0) precision = 2; - else if (f < 100000.0) precision = 1; - else precision = 0; - } - - if (precision) { - f += rounders[precision]; - } - - /* Make sure that number can be represented as 64bit int, increase exp */ - while (f > INT64_MAX_F) { - f /= 1000 * 1000 * 1000; - exp += 9; - } - - intPart = (int64_t)f; - f -= (double)intPart; - - ptr = strbuf_itoa(ptr, intPart); - - if (precision) { - *ptr++ = '.'; - while (precision--) { - f *= 10.0; - c = (char)f; - *ptr++ = (char)('0' + c); - f -= c; - } - } - *ptr = 0; - - /* Remove trailing 0s */ - while ((&ptr[-1] != buf) && (ptr[-1] == '0')) { - ptr[-1] = '\0'; - ptr --; - } - if (ptr != buf && ptr[-1] == '.') { - ptr[-1] = '\0'; - ptr --; - } - - /* If 0s before . exceed threshold, convert to exponent to save space - * without losing precision. */ - char *cur = ptr; - while ((&cur[-1] != buf) && (cur[-1] == '0')) { - cur --; - } - - if (exp || ((ptr - cur) > EXP_THRESHOLD)) { - cur[0] = '\0'; - exp += (ptr - cur); - ptr = cur; - } - - if (exp) { - char *p1 = &buf[1]; - if (nan_delim) { - ecs_os_memmove(buf + 1, buf, 1 + (ptr - buf)); - buf[0] = nan_delim; - p1 ++; - } - - /* Make sure that exp starts after first character */ - c = p1[0]; - p1[0] = '.'; - - do { - char t = (++p1)[0]; - p1[0] = c; - c = t; - exp ++; - } while (c); - - ptr = p1 + 1; - - ptr[0] = 'e'; - ptr = strbuf_itoa(ptr + 1, exp); - - if (nan_delim) { - ptr[0] = nan_delim; - ptr ++; - } - - ptr[0] = '\0'; - } - - return ecs_strbuf_appendstrn(out, buf, (int32_t)(ptr - buf)); -} - -/* Add an extra element to the buffer */ +/* Get bucket index for provided map key */ static -void ecs_strbuf_grow( - ecs_strbuf_t *b) +int32_t get_bucket_index( + const ecs_map_t *map, + uint16_t bucket_shift, + ecs_map_key_t key) { - /* Allocate new element */ - ecs_strbuf_element_embedded *e = ecs_os_malloc_t(ecs_strbuf_element_embedded); - b->size += b->current->pos; - b->current->next = (ecs_strbuf_element*)e; - b->current = (ecs_strbuf_element*)e; - b->elementCount ++; - e->super.buffer_embedded = true; - e->super.buf = e->buf; - e->super.pos = 0; - e->super.next = NULL; + ecs_assert(bucket_shift != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(map->bucket_shift == bucket_shift, ECS_INTERNAL_ERROR, NULL); + (void)map; + return (int32_t)((11400714819323198485ull * key) >> bucket_shift); } -/* Add an extra dynamic element */ +/* Get bucket for key */ static -void ecs_strbuf_grow_str( - ecs_strbuf_t *b, - char *str, - char *alloc_str, - int32_t size) +ecs_bucket_t* get_bucket( + const ecs_map_t *map, + ecs_map_key_t key) { - /* Allocate new element */ - ecs_strbuf_element_str *e = ecs_os_malloc_t(ecs_strbuf_element_str); - b->size += b->current->pos; - b->current->next = (ecs_strbuf_element*)e; - b->current = (ecs_strbuf_element*)e; - b->elementCount ++; - e->super.buffer_embedded = false; - e->super.pos = size ? size : (int32_t)ecs_os_strlen(str); - e->super.next = NULL; - e->super.buf = str; - e->alloc_str = alloc_str; + ecs_assert(map->bucket_shift == get_bucket_shift(map->bucket_count), + ECS_INTERNAL_ERROR, NULL); + int32_t bucket_id = get_bucket_index(map, map->bucket_shift, key); + ecs_assert(bucket_id < map->bucket_count, ECS_INTERNAL_ERROR, NULL); + return &map->buckets[bucket_id]; } +/* Ensure that map has at least new_count buckets */ static -char* ecs_strbuf_ptr( - ecs_strbuf_t *b) +void ensure_buckets( + ecs_map_t *map, + int32_t new_count) { - if (b->buf) { - return &b->buf[b->current->pos]; - } else { - return &b->current->buf[b->current->pos]; + int32_t bucket_count = map->bucket_count; + new_count = flecs_next_pow_of_2(new_count); + if (new_count < 2) { + new_count = 2; + } + + if (new_count && new_count > bucket_count) { + map->buckets = ecs_os_realloc(map->buckets, new_count * ECS_SIZEOF(ecs_bucket_t)); + map->bucket_count = new_count; + map->bucket_shift = get_bucket_shift(new_count); + ecs_os_memset( + ECS_OFFSET(map->buckets, bucket_count * ECS_SIZEOF(ecs_bucket_t)), + 0, (new_count - bucket_count) * ECS_SIZEOF(ecs_bucket_t)); } } -/* Compute the amount of space left in the current element */ +/* Free contents of bucket */ static -int32_t ecs_strbuf_memLeftInCurrentElement( - ecs_strbuf_t *b) +void clear_bucket( + ecs_bucket_t *bucket) { - if (b->current->buffer_embedded) { - return ECS_STRBUF_ELEMENT_SIZE - b->current->pos; - } else { - return 0; - } + ecs_os_free(bucket->keys); + ecs_os_free(bucket->payload); + bucket->keys = NULL; + bucket->payload = NULL; + bucket->count = 0; } -/* Compute the amount of space left */ +/* Clear all buckets */ static -int32_t ecs_strbuf_memLeft( - ecs_strbuf_t *b) +void clear_buckets( + ecs_map_t *map) { - if (b->max) { - return b->max - b->size - b->current->pos; - } else { - return INT_MAX; + ecs_bucket_t *buckets = map->buckets; + int32_t i, count = map->bucket_count; + for (i = 0; i < count; i ++) { + clear_bucket(&buckets[i]); } + ecs_os_free(buckets); + map->buckets = NULL; + map->bucket_count = 0; } +/* Find or create bucket for specified key */ static -void ecs_strbuf_init( - ecs_strbuf_t *b) +ecs_bucket_t* ensure_bucket( + ecs_map_t *map, + ecs_map_key_t key) { - /* Initialize buffer structure only once */ - if (!b->elementCount) { - b->size = 0; - b->firstElement.super.next = NULL; - b->firstElement.super.pos = 0; - b->firstElement.super.buffer_embedded = true; - b->firstElement.super.buf = b->firstElement.buf; - b->elementCount ++; - b->current = (ecs_strbuf_element*)&b->firstElement; - } + ecs_assert(map->bucket_count >= 2, ECS_INTERNAL_ERROR, NULL); + int32_t bucket_id = get_bucket_index(map, map->bucket_shift, key); + ecs_assert(bucket_id >= 0, ECS_INTERNAL_ERROR, NULL); + return &map->buckets[bucket_id]; } -/* Append a format string to a buffer */ +/* Add element to bucket */ static -bool vappend( - ecs_strbuf_t *b, - const char* str, - va_list args) +int32_t add_to_bucket( + ecs_bucket_t *bucket, + ecs_size_t elem_size, + ecs_map_key_t key, + const void *payload) { - bool result = true; - va_list arg_cpy; - - if (!str) { - return result; - } - - ecs_strbuf_init(b); + int32_t index = bucket->count ++; + int32_t bucket_count = index + 1; - int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); - int32_t memLeft = ecs_strbuf_memLeft(b); + bucket->keys = ecs_os_realloc(bucket->keys, KEY_SIZE * bucket_count); + bucket->keys[index] = key; - if (!memLeft) { - return false; + if (elem_size) { + bucket->payload = ecs_os_realloc(bucket->payload, elem_size * bucket_count); + if (payload) { + void *elem = GET_ELEM(bucket->payload, elem_size, index); + ecs_os_memcpy(elem, payload, elem_size); + } + } else { + bucket->payload = NULL; } - /* Compute the memory required to add the string to the buffer. If user - * provided buffer, use space left in buffer, otherwise use space left in - * current element. */ - int32_t max_copy = b->buf ? memLeft : memLeftInElement; - int32_t memRequired; - - va_copy(arg_cpy, args); - memRequired = vsnprintf( - ecs_strbuf_ptr(b), (size_t)(max_copy + 1), str, args); + return index; +} - ecs_assert(memRequired != -1, ECS_INTERNAL_ERROR, NULL); +/* Remove element from bucket */ +static +void remove_from_bucket( + ecs_bucket_t *bucket, + ecs_size_t elem_size, + ecs_map_key_t key, + int32_t index) +{ + (void)key; - if (memRequired <= memLeftInElement) { - /* Element was large enough to fit string */ - b->current->pos += memRequired; - } else if ((memRequired - memLeftInElement) < memLeft) { - /* If string is a format string, a new buffer of size memRequired is - * needed to re-evaluate the format string and only use the part that - * wasn't already copied to the previous element */ - if (memRequired <= ECS_STRBUF_ELEMENT_SIZE) { - /* Resulting string fits in standard-size buffer. Note that the - * entire string needs to fit, not just the remainder, as the - * format string cannot be partially evaluated */ - ecs_strbuf_grow(b); + ecs_assert(bucket->count != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(index < bucket->count, ECS_INTERNAL_ERROR, NULL); + + int32_t bucket_count = -- bucket->count; - /* Copy entire string to new buffer */ - ecs_os_vsprintf(ecs_strbuf_ptr(b), str, arg_cpy); + if (index != bucket->count) { + ecs_assert(key == bucket->keys[index], ECS_INTERNAL_ERROR, NULL); + bucket->keys[index] = bucket->keys[bucket_count]; - /* Ignore the part of the string that was copied into the - * previous buffer. The string copied into the new buffer could - * be memmoved so that only the remainder is left, but that is - * most likely more expensive than just keeping the entire - * string. */ + ecs_map_key_t *elem = GET_ELEM(bucket->payload, elem_size, index); + ecs_map_key_t *last_elem = GET_ELEM(bucket->payload, elem_size, bucket->count); - /* Update position in buffer */ - b->current->pos += memRequired; - } else { - /* Resulting string does not fit in standard-size buffer. - * Allocate a new buffer that can hold the entire string. */ - char *dst = ecs_os_malloc(memRequired + 1); - ecs_os_vsprintf(dst, str, arg_cpy); - ecs_strbuf_grow_str(b, dst, dst, memRequired); - } + ecs_os_memcpy(elem, last_elem, elem_size); } +} - va_end(arg_cpy); +/* Get payload pointer for key from bucket */ +static +void* get_from_bucket( + ecs_bucket_t *bucket, + ecs_map_key_t key, + ecs_size_t elem_size) +{ + ecs_map_key_t *keys = bucket->keys; + int32_t i, count = bucket->count; - return ecs_strbuf_memLeft(b) > 0; + for (i = 0; i < count; i ++) { + if (keys[i] == key) { + return GET_ELEM(bucket->payload, elem_size, i); + } + } + return NULL; } +/* Grow number of buckets */ static -bool appendstr( - ecs_strbuf_t *b, - const char* str, - int n) +void rehash( + ecs_map_t *map, + int32_t bucket_count) { - ecs_strbuf_init(b); + ecs_assert(bucket_count != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(bucket_count > map->bucket_count, ECS_INTERNAL_ERROR, NULL); - int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); - int32_t memLeft = ecs_strbuf_memLeft(b); - if (memLeft <= 0) { - return false; - } + ensure_buckets(map, bucket_count); - /* Never write more than what the buffer can store */ - if (n > memLeft) { - n = memLeft; - } + ecs_bucket_t *buckets = map->buckets; + ecs_assert(buckets != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_size_t elem_size = map->elem_size; + uint16_t bucket_shift = map->bucket_shift; + int32_t bucket_id; - if (n <= memLeftInElement) { - /* Element was large enough to fit string */ - ecs_os_strncpy(ecs_strbuf_ptr(b), str, n); - b->current->pos += n; - } else if ((n - memLeftInElement) < memLeft) { - ecs_os_strncpy(ecs_strbuf_ptr(b), str, memLeftInElement); + /* Iterate backwards as elements could otherwise be moved to existing + * buckets which could temporarily cause the number of elements in a + * bucket to exceed BUCKET_COUNT. */ + for (bucket_id = bucket_count - 1; bucket_id >= 0; bucket_id --) { + ecs_bucket_t *bucket = &buckets[bucket_id]; - /* Element was not large enough, but buffer still has space */ - b->current->pos += memLeftInElement; - n -= memLeftInElement; + int i, count = bucket->count; + ecs_map_key_t *key_array = bucket->keys; + void *payload_array = bucket->payload; - /* Current element was too small, copy remainder into new element */ - if (n < ECS_STRBUF_ELEMENT_SIZE) { - /* A standard-size buffer is large enough for the new string */ - ecs_strbuf_grow(b); + for (i = 0; i < count; i ++) { + ecs_map_key_t key = key_array[i]; + void *elem = GET_ELEM(payload_array, elem_size, i); + int32_t new_bucket_id = get_bucket_index(map, bucket_shift, key); - /* Copy the remainder to the new buffer */ - if (n) { - /* If a max number of characters to write is set, only a - * subset of the string should be copied to the buffer */ - ecs_os_strncpy( - ecs_strbuf_ptr(b), - str + memLeftInElement, - (size_t)n); - } else { - ecs_os_strcpy(ecs_strbuf_ptr(b), str + memLeftInElement); + if (new_bucket_id != bucket_id) { + ecs_bucket_t *new_bucket = &buckets[new_bucket_id]; + + add_to_bucket(new_bucket, elem_size, key, elem); + remove_from_bucket(bucket, elem_size, key, i); + + count --; + i --; } + } - /* Update to number of characters copied to new buffer */ - b->current->pos += n; - } else { - /* String doesn't fit in a single element, strdup */ - char *remainder = ecs_os_strdup(str + memLeftInElement); - ecs_strbuf_grow_str(b, remainder, remainder, n); + if (!bucket->count) { + clear_bucket(bucket); } - } else { - /* Buffer max has been reached */ - return false; } - - return ecs_strbuf_memLeft(b) > 0; } -static -bool appendch( - ecs_strbuf_t *b, - char ch) +void _ecs_map_init( + ecs_map_t *result, + ecs_size_t elem_size, + int32_t element_count) { - ecs_strbuf_init(b); - - int32_t memLeftInElement = ecs_strbuf_memLeftInCurrentElement(b); - int32_t memLeft = ecs_strbuf_memLeft(b); - if (memLeft <= 0) { - return false; - } - - if (memLeftInElement) { - /* Element was large enough to fit string */ - ecs_strbuf_ptr(b)[0] = ch; - b->current->pos ++; - } else { - ecs_strbuf_grow(b); - ecs_strbuf_ptr(b)[0] = ch; - b->current->pos ++; - } + ecs_assert(elem_size < INT16_MAX, ECS_INVALID_PARAMETER, NULL); - return ecs_strbuf_memLeft(b) > 0; -} + result->count = 0; + result->elem_size = (int16_t)elem_size; -bool ecs_strbuf_vappend( - ecs_strbuf_t *b, - const char* fmt, - va_list args) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); - return vappend(b, fmt, args); + ensure_buckets(result, get_bucket_count(element_count)); } -bool ecs_strbuf_append( - ecs_strbuf_t *b, - const char* fmt, - ...) +ecs_map_t* _ecs_map_new( + ecs_size_t elem_size, + int32_t element_count) { - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_map_t *result = ecs_os_calloc_t(ecs_map_t); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - va_list args; - va_start(args, fmt); - bool result = vappend(b, fmt, args); - va_end(args); + _ecs_map_init(result, elem_size, element_count); return result; } -bool ecs_strbuf_appendstrn( - ecs_strbuf_t *b, - const char* str, - int32_t len) +bool ecs_map_is_initialized( + const ecs_map_t *result) { - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); - return appendstr(b, str, len); + return result != NULL && result->bucket_count != 0; } -bool ecs_strbuf_appendch( - ecs_strbuf_t *b, - char ch) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - return appendch(b, ch); -} - -bool ecs_strbuf_appendflt( - ecs_strbuf_t *b, - double flt, - char nan_delim) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - return ecs_strbuf_ftoa(b, flt, 10, nan_delim); -} - -bool ecs_strbuf_appendstr_zerocpy( - ecs_strbuf_t *b, - char* str) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_strbuf_init(b); - ecs_strbuf_grow_str(b, str, str, 0); - return true; -} - -bool ecs_strbuf_appendstr_zerocpy_const( - ecs_strbuf_t *b, - const char* str) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); - /* Removes const modifier, but logic prevents changing / delete string */ - ecs_strbuf_init(b); - ecs_strbuf_grow_str(b, (char*)str, NULL, 0); - return true; -} - -bool ecs_strbuf_appendstr( - ecs_strbuf_t *b, - const char* str) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); - return appendstr(b, str, ecs_os_strlen(str)); -} - -bool ecs_strbuf_mergebuff( - ecs_strbuf_t *dst_buffer, - ecs_strbuf_t *src_buffer) -{ - if (src_buffer->elementCount) { - if (src_buffer->buf) { - return ecs_strbuf_appendstr(dst_buffer, src_buffer->buf); - } else { - ecs_strbuf_element *e = (ecs_strbuf_element*)&src_buffer->firstElement; - - /* Copy first element as it is inlined in the src buffer */ - ecs_strbuf_appendstrn(dst_buffer, e->buf, e->pos); - - while ((e = e->next)) { - dst_buffer->current->next = ecs_os_malloc(sizeof(ecs_strbuf_element)); - *dst_buffer->current->next = *e; - } - } - - *src_buffer = ECS_STRBUF_INIT; - } - - return true; -} - -char* ecs_strbuf_get( - ecs_strbuf_t *b) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - - char* result = NULL; - if (b->elementCount) { - if (b->buf) { - b->buf[b->current->pos] = '\0'; - result = ecs_os_strdup(b->buf); - } else { - void *next = NULL; - int32_t len = b->size + b->current->pos + 1; - - ecs_strbuf_element *e = (ecs_strbuf_element*)&b->firstElement; - - result = ecs_os_malloc(len); - char* ptr = result; - - do { - ecs_os_memcpy(ptr, e->buf, e->pos); - ptr += e->pos; - next = e->next; - if (e != &b->firstElement.super) { - if (!e->buffer_embedded) { - ecs_os_free(((ecs_strbuf_element_str*)e)->alloc_str); - } - ecs_os_free(e); - } - } while ((e = next)); - - result[len - 1] = '\0'; - b->length = len; - } - } else { - result = NULL; - } - - b->elementCount = 0; - - b->content = result; - - return result; -} - -char *ecs_strbuf_get_small( - ecs_strbuf_t *b) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - - int32_t written = ecs_strbuf_written(b); - ecs_assert(written <= ECS_STRBUF_ELEMENT_SIZE, ECS_INVALID_OPERATION, NULL); - char *buf = b->firstElement.buf; - buf[written] = '\0'; - return buf; -} - -void ecs_strbuf_reset( - ecs_strbuf_t *b) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - - if (b->elementCount && !b->buf) { - void *next = NULL; - ecs_strbuf_element *e = (ecs_strbuf_element*)&b->firstElement; - do { - next = e->next; - if (e != (ecs_strbuf_element*)&b->firstElement) { - ecs_os_free(e); - } - } while ((e = next)); - } - - *b = ECS_STRBUF_INIT; -} - -void ecs_strbuf_list_push( - ecs_strbuf_t *b, - const char *list_open, - const char *separator) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(list_open != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(separator != NULL, ECS_INVALID_PARAMETER, NULL); - - b->list_sp ++; - b->list_stack[b->list_sp].count = 0; - b->list_stack[b->list_sp].separator = separator; - - if (list_open) { - ecs_strbuf_appendstr(b, list_open); - } -} - -void ecs_strbuf_list_pop( - ecs_strbuf_t *b, - const char *list_close) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(list_close != NULL, ECS_INVALID_PARAMETER, NULL); - - b->list_sp --; - - if (list_close) { - ecs_strbuf_appendstr(b, list_close); - } -} - -void ecs_strbuf_list_next( - ecs_strbuf_t *b) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - - int32_t list_sp = b->list_sp; - if (b->list_stack[list_sp].count != 0) { - ecs_strbuf_appendstr(b, b->list_stack[list_sp].separator); - } - b->list_stack[list_sp].count ++; -} - -bool ecs_strbuf_list_append( - ecs_strbuf_t *b, - const char *fmt, - ...) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(fmt != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_strbuf_list_next(b); - - va_list args; - va_start(args, fmt); - bool result = vappend(b, fmt, args); - va_end(args); - - return result; -} - -bool ecs_strbuf_list_appendstr( - ecs_strbuf_t *b, - const char *str) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(str != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_strbuf_list_next(b); - return ecs_strbuf_appendstr(b, str); -} - -int32_t ecs_strbuf_written( - const ecs_strbuf_t *b) -{ - ecs_assert(b != NULL, ECS_INVALID_PARAMETER, NULL); - return b->size + b->current->pos; -} - -#include - -/* The ratio used to determine whether the map should rehash. If - * (element_count * LOAD_FACTOR) > bucket_count, bucket count is increased. */ -#define LOAD_FACTOR (1.5f) -#define KEY_SIZE (ECS_SIZEOF(ecs_map_key_t)) -#define GET_ELEM(array, elem_size, index) \ - ECS_OFFSET(array, (elem_size) * (index)) - -static -uint8_t ecs_log2(uint32_t v) { - static const uint8_t log2table[32] = - {0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, - 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31}; - - v |= v >> 1; - v |= v >> 2; - v |= v >> 4; - v |= v >> 8; - v |= v >> 16; - return log2table[(uint32_t)(v * 0x07C4ACDDU) >> 27]; -} - -/* Get bucket count for number of elements */ -static -int32_t get_bucket_count( - int32_t element_count) -{ - return flecs_next_pow_of_2((int32_t)((float)element_count * LOAD_FACTOR)); -} - -/* Get bucket shift amount for a given bucket count */ -static -uint8_t get_bucket_shift ( - int32_t bucket_count) -{ - return (uint8_t)(64u - ecs_log2((uint32_t)bucket_count)); -} - -/* Get bucket index for provided map key */ -static -int32_t get_bucket_index( - const ecs_map_t *map, - uint16_t bucket_shift, - ecs_map_key_t key) -{ - ecs_assert(bucket_shift != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(map->bucket_shift == bucket_shift, ECS_INTERNAL_ERROR, NULL); - (void)map; - return (int32_t)((11400714819323198485ull * key) >> bucket_shift); -} - -/* Get bucket for key */ -static -ecs_bucket_t* get_bucket( - const ecs_map_t *map, - ecs_map_key_t key) -{ - ecs_assert(map->bucket_shift == get_bucket_shift(map->bucket_count), - ECS_INTERNAL_ERROR, NULL); - int32_t bucket_id = get_bucket_index(map, map->bucket_shift, key); - ecs_assert(bucket_id < map->bucket_count, ECS_INTERNAL_ERROR, NULL); - return &map->buckets[bucket_id]; -} - -/* Ensure that map has at least new_count buckets */ -static -void ensure_buckets( - ecs_map_t *map, - int32_t new_count) -{ - int32_t bucket_count = map->bucket_count; - new_count = flecs_next_pow_of_2(new_count); - if (new_count < 2) { - new_count = 2; - } - - if (new_count && new_count > bucket_count) { - map->buckets = ecs_os_realloc(map->buckets, new_count * ECS_SIZEOF(ecs_bucket_t)); - map->bucket_count = new_count; - map->bucket_shift = get_bucket_shift(new_count); - ecs_os_memset( - ECS_OFFSET(map->buckets, bucket_count * ECS_SIZEOF(ecs_bucket_t)), - 0, (new_count - bucket_count) * ECS_SIZEOF(ecs_bucket_t)); - } -} - -/* Free contents of bucket */ -static -void clear_bucket( - ecs_bucket_t *bucket) -{ - ecs_os_free(bucket->keys); - ecs_os_free(bucket->payload); - bucket->keys = NULL; - bucket->payload = NULL; - bucket->count = 0; -} - -/* Clear all buckets */ -static -void clear_buckets( - ecs_map_t *map) -{ - ecs_bucket_t *buckets = map->buckets; - int32_t i, count = map->bucket_count; - for (i = 0; i < count; i ++) { - clear_bucket(&buckets[i]); - } - ecs_os_free(buckets); - map->buckets = NULL; - map->bucket_count = 0; -} - -/* Find or create bucket for specified key */ -static -ecs_bucket_t* ensure_bucket( - ecs_map_t *map, - ecs_map_key_t key) -{ - ecs_assert(map->bucket_count >= 2, ECS_INTERNAL_ERROR, NULL); - int32_t bucket_id = get_bucket_index(map, map->bucket_shift, key); - ecs_assert(bucket_id >= 0, ECS_INTERNAL_ERROR, NULL); - return &map->buckets[bucket_id]; -} - -/* Add element to bucket */ -static -int32_t add_to_bucket( - ecs_bucket_t *bucket, - ecs_size_t elem_size, - ecs_map_key_t key, - const void *payload) -{ - int32_t index = bucket->count ++; - int32_t bucket_count = index + 1; - - bucket->keys = ecs_os_realloc(bucket->keys, KEY_SIZE * bucket_count); - bucket->keys[index] = key; - - if (elem_size) { - bucket->payload = ecs_os_realloc(bucket->payload, elem_size * bucket_count); - if (payload) { - void *elem = GET_ELEM(bucket->payload, elem_size, index); - ecs_os_memcpy(elem, payload, elem_size); - } - } else { - bucket->payload = NULL; - } - - return index; -} - -/* Remove element from bucket */ -static -void remove_from_bucket( - ecs_bucket_t *bucket, - ecs_size_t elem_size, - ecs_map_key_t key, - int32_t index) -{ - (void)key; - - ecs_assert(bucket->count != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(index < bucket->count, ECS_INTERNAL_ERROR, NULL); - - int32_t bucket_count = -- bucket->count; - - if (index != bucket->count) { - ecs_assert(key == bucket->keys[index], ECS_INTERNAL_ERROR, NULL); - bucket->keys[index] = bucket->keys[bucket_count]; - - ecs_map_key_t *elem = GET_ELEM(bucket->payload, elem_size, index); - ecs_map_key_t *last_elem = GET_ELEM(bucket->payload, elem_size, bucket->count); - - ecs_os_memcpy(elem, last_elem, elem_size); - } -} - -/* Get payload pointer for key from bucket */ -static -void* get_from_bucket( - ecs_bucket_t *bucket, - ecs_map_key_t key, - ecs_size_t elem_size) -{ - ecs_map_key_t *keys = bucket->keys; - int32_t i, count = bucket->count; - - for (i = 0; i < count; i ++) { - if (keys[i] == key) { - return GET_ELEM(bucket->payload, elem_size, i); - } - } - return NULL; -} - -/* Grow number of buckets */ -static -void rehash( - ecs_map_t *map, - int32_t bucket_count) -{ - ecs_assert(bucket_count != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(bucket_count > map->bucket_count, ECS_INTERNAL_ERROR, NULL); - - ensure_buckets(map, bucket_count); - - ecs_bucket_t *buckets = map->buckets; - ecs_assert(buckets != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_size_t elem_size = map->elem_size; - uint16_t bucket_shift = map->bucket_shift; - int32_t bucket_id; - - /* Iterate backwards as elements could otherwise be moved to existing - * buckets which could temporarily cause the number of elements in a - * bucket to exceed BUCKET_COUNT. */ - for (bucket_id = bucket_count - 1; bucket_id >= 0; bucket_id --) { - ecs_bucket_t *bucket = &buckets[bucket_id]; - - int i, count = bucket->count; - ecs_map_key_t *key_array = bucket->keys; - void *payload_array = bucket->payload; - - for (i = 0; i < count; i ++) { - ecs_map_key_t key = key_array[i]; - void *elem = GET_ELEM(payload_array, elem_size, i); - int32_t new_bucket_id = get_bucket_index(map, bucket_shift, key); - - if (new_bucket_id != bucket_id) { - ecs_bucket_t *new_bucket = &buckets[new_bucket_id]; - - add_to_bucket(new_bucket, elem_size, key, elem); - remove_from_bucket(bucket, elem_size, key, i); - - count --; - i --; - } - } - - if (!bucket->count) { - clear_bucket(bucket); - } - } -} - -void _ecs_map_init( - ecs_map_t *result, - ecs_size_t elem_size, - int32_t element_count) -{ - ecs_assert(elem_size < INT16_MAX, ECS_INVALID_PARAMETER, NULL); - - result->count = 0; - result->elem_size = (int16_t)elem_size; - - ensure_buckets(result, get_bucket_count(element_count)); -} - -ecs_map_t* _ecs_map_new( - ecs_size_t elem_size, - int32_t element_count) -{ - ecs_map_t *result = ecs_os_calloc_t(ecs_map_t); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - - _ecs_map_init(result, elem_size, element_count); - - return result; -} - -bool ecs_map_is_initialized( - const ecs_map_t *result) -{ - return result != NULL && result->bucket_count != 0; -} - -void ecs_map_fini( - ecs_map_t *map) +void ecs_map_fini( + ecs_map_t *map) { ecs_assert(map != NULL, ECS_INTERNAL_ERROR, NULL); clear_buckets(map); @@ -13186,14 +12115,335 @@ void ecs_map_memory( } + static -int32_t find_key( - const ecs_hashmap_t *map, - ecs_vector_t *keys, - ecs_size_t key_size, - const void *key) -{ - int32_t i, count = ecs_vector_count(keys); +void ensure( + ecs_bitset_t *bs, + ecs_size_t size) +{ + if (!bs->size) { + int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); + bs->size = ((size - 1) / 64 + 1) * 64; + bs->data = ecs_os_calloc(new_size); + } else if (size > bs->size) { + int32_t prev_size = ((bs->size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); + bs->size = ((size - 1) / 64 + 1) * 64; + int32_t new_size = ((size - 1) / 64 + 1) * ECS_SIZEOF(uint64_t); + bs->data = ecs_os_realloc(bs->data, new_size); + ecs_os_memset(ECS_OFFSET(bs->data, prev_size), 0, new_size - prev_size); + } +} + +void flecs_bitset_init( + ecs_bitset_t* bs) +{ + bs->size = 0; + bs->count = 0; + bs->data = NULL; +} + +void flecs_bitset_ensure( + ecs_bitset_t *bs, + int32_t count) +{ + if (count > bs->count) { + bs->count = count; + ensure(bs, count); + } +} + +void flecs_bitset_fini( + ecs_bitset_t *bs) +{ + ecs_os_free(bs->data); + bs->data = NULL; + bs->count = 0; +} + +void flecs_bitset_addn( + ecs_bitset_t *bs, + int32_t count) +{ + int32_t elem = bs->count += count; + ensure(bs, elem); +} + +void flecs_bitset_set( + ecs_bitset_t *bs, + int32_t elem, + bool value) +{ + ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); + int32_t hi = elem >> 6; + int32_t lo = elem & 0x3F; + uint64_t v = bs->data[hi]; + bs->data[hi] = (v & ~((uint64_t)1 << lo)) | ((uint64_t)value << lo); +error: + return; +} + +bool flecs_bitset_get( + const ecs_bitset_t *bs, + int32_t elem) +{ + ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); + return !!(bs->data[elem >> 6] & ((uint64_t)1 << ((uint64_t)elem & 0x3F))); +error: + return false; +} + +int32_t flecs_bitset_count( + const ecs_bitset_t *bs) +{ + return bs->count; +} + +void flecs_bitset_remove( + ecs_bitset_t *bs, + int32_t elem) +{ + ecs_check(elem < bs->count, ECS_INVALID_PARAMETER, NULL); + int32_t last = bs->count - 1; + bool last_value = flecs_bitset_get(bs, last); + flecs_bitset_set(bs, elem, last_value); + bs->count --; +error: + return; +} + +void flecs_bitset_swap( + ecs_bitset_t *bs, + int32_t elem_a, + int32_t elem_b) +{ + ecs_check(elem_a < bs->count, ECS_INVALID_PARAMETER, NULL); + ecs_check(elem_b < bs->count, ECS_INVALID_PARAMETER, NULL); + + bool a = flecs_bitset_get(bs, elem_a); + bool b = flecs_bitset_get(bs, elem_b); + flecs_bitset_set(bs, elem_a, b); + flecs_bitset_set(bs, elem_b, a); +error: + return; +} + + +static +uint64_t name_index_hash( + const void *ptr) +{ + const ecs_hashed_string_t *str = ptr; + ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL); + return str->hash; +} + +static +int name_index_compare( + const void *ptr1, + const void *ptr2) +{ + const ecs_hashed_string_t *str1 = ptr1; + const ecs_hashed_string_t *str2 = ptr2; + ecs_size_t len1 = str1->length; + ecs_size_t len2 = str2->length; + if (len1 != len2) { + return (len1 > len2) - (len1 < len2); + } + + return ecs_os_memcmp(str1->value, str2->value, len1); +} + +void flecs_name_index_init( + ecs_hashmap_t *hm) +{ + _flecs_hashmap_init(hm, + ECS_SIZEOF(ecs_hashed_string_t), ECS_SIZEOF(uint64_t), + name_index_hash, + name_index_compare); +} + +ecs_hashmap_t* flecs_name_index_new(void) +{ + ecs_hashmap_t *result = ecs_os_calloc_t(ecs_hashmap_t); + flecs_name_index_init(result); + return result; +} + +void flecs_name_index_fini( + ecs_hashmap_t *map) +{ + flecs_hashmap_fini(map); +} + +void flecs_name_index_free( + ecs_hashmap_t *map) +{ + if (map) { + flecs_name_index_fini(map); + ecs_os_free(map); + } +} + +ecs_hashed_string_t flecs_get_hashed_string( + const char *name, + ecs_size_t length, + uint64_t hash) +{ + if (!length) { + length = ecs_os_strlen(name); + } else { + ecs_assert(length == ecs_os_strlen(name), ECS_INTERNAL_ERROR, NULL); + } + + if (!hash) { + hash = flecs_hash(name, length); + } else { + ecs_assert(hash == flecs_hash(name, length), ECS_INTERNAL_ERROR, NULL); + } + + return (ecs_hashed_string_t) { + .value = (char*)name, + .length = length, + .hash = hash + }; +} + +const uint64_t* flecs_name_index_find_ptr( + const ecs_hashmap_t *map, + const char *name, + ecs_size_t length, + uint64_t hash) +{ + ecs_hashed_string_t hs = flecs_get_hashed_string(name, length, hash); + + ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hs.hash); + if (!b) { + return NULL; + } + + ecs_hashed_string_t *keys = ecs_vector_first(b->keys, ecs_hashed_string_t); + int32_t i, count = ecs_vector_count(b->keys); + + for (i = 0; i < count; i ++) { + ecs_hashed_string_t *key = &keys[i]; + ecs_assert(key->hash == hs.hash, ECS_INTERNAL_ERROR, NULL); + + if (hs.length != key->length) { + continue; + } + + if (!ecs_os_strcmp(name, key->value)) { + uint64_t *e = ecs_vector_get(b->values, uint64_t, i); + ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); + return e; + } + } + + return NULL; +} + +uint64_t flecs_name_index_find( + const ecs_hashmap_t *map, + const char *name, + ecs_size_t length, + uint64_t hash) +{ + const uint64_t *id = flecs_name_index_find_ptr(map, name, length, hash); + if (id) { + return id[0]; + } + return 0; +} + +void flecs_name_index_remove( + ecs_hashmap_t *map, + uint64_t e, + uint64_t hash) +{ + ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash); + if (!b) { + return; + } + + uint64_t *ids = ecs_vector_first(b->values, uint64_t); + int32_t i, count = ecs_vector_count(b->values); + + for (i = 0; i < count; i ++) { + if (ids[i] == e) { + flecs_hm_bucket_remove(map, b, hash, i); + break; + } + } +} + +void flecs_name_index_update_name( + ecs_hashmap_t *map, + uint64_t e, + uint64_t hash, + const char *name) +{ + ecs_hm_bucket_t *b = flecs_hashmap_get_bucket(map, hash); + if (!b) { + return; + } + + uint64_t *ids = ecs_vector_first(b->values, uint64_t); + int32_t i, count = ecs_vector_count(b->values); + + for (i = 0; i < count; i ++) { + if (ids[i] == e) { + ecs_hashed_string_t *key = ecs_vector_get( + b->keys, ecs_hashed_string_t, i); + key->value = (char*)name; + ecs_assert(ecs_os_strlen(name) == key->length, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(flecs_hash(name, key->length) == key->hash, + ECS_INTERNAL_ERROR, NULL); + return; + } + } + + /* Record must already have been in the index */ + ecs_abort(ECS_INTERNAL_ERROR, NULL); +} + +void flecs_name_index_ensure( + ecs_hashmap_t *map, + uint64_t id, + const char *name, + ecs_size_t length, + uint64_t hash) +{ + ecs_check(name != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_hashed_string_t key = flecs_get_hashed_string(name, length, hash); + + uint64_t existing = flecs_name_index_find( + map, name, key.length, key.hash); + if (existing) { + if (existing != id) { + ecs_abort(ECS_ALREADY_DEFINED, + "conflicting id registered with name '%s'", name); + } + } + + flecs_hashmap_result_t hmr = flecs_hashmap_ensure( + map, &key, uint64_t); + + *((uint64_t*)hmr.value) = id; +error: + return; +} + + +static +int32_t find_key( + const ecs_hashmap_t *map, + ecs_vector_t *keys, + ecs_size_t key_size, + const void *key) +{ + int32_t i, count = ecs_vector_count(keys); void *key_array = ecs_vector_first_t(keys, key_size, 8); for (i = 0; i < count; i ++) { void *key_ptr = ECS_OFFSET(key_array, key_size * i); @@ -13423,15371 +12673,15191 @@ void* _flecs_hashmap_next( } -#ifdef FLECS_LOG +void ecs_qsort( + void *base, + ecs_size_t nitems, + ecs_size_t size, + int (*compar)(const void *, const void*)) +{ + void *tmp = ecs_os_alloca(size); /* For swap */ -#include -#include + #define LESS(i, j) \ + compar(ECS_ELEM(base, size, i), ECS_ELEM(base, size, j)) < 0 -static -char *ecs_vasprintf( - const char *fmt, - va_list args) -{ - ecs_size_t size = 0; - char *result = NULL; - va_list tmpa; + #define SWAP(i, j) \ + ecs_os_memcpy(tmp, ECS_ELEM(base, size, i), size),\ + ecs_os_memcpy(ECS_ELEM(base, size, i), ECS_ELEM(base, size, j), size),\ + ecs_os_memcpy(ECS_ELEM(base, size, j), tmp, size) - va_copy(tmpa, args); + QSORT(nitems, LESS, SWAP); +} - size = vsnprintf(result, 0, fmt, tmpa); - va_end(tmpa); +/* Roles */ +const ecs_id_t ECS_CASE = (ECS_ROLE | (0x7Cull << 56)); +const ecs_id_t ECS_SWITCH = (ECS_ROLE | (0x7Bull << 56)); +const ecs_id_t ECS_PAIR = (ECS_ROLE | (0x7Aull << 56)); +const ecs_id_t ECS_OVERRIDE = (ECS_ROLE | (0x75ull << 56)); +const ecs_id_t ECS_DISABLED = (ECS_ROLE | (0x74ull << 56)); - if ((int32_t)size < 0) { - return NULL; - } +/** Builtin component ids */ +const ecs_entity_t ecs_id(EcsComponent) = 1; +const ecs_entity_t ecs_id(EcsComponentLifecycle) = 2; +const ecs_entity_t ecs_id(EcsType) = 3; +const ecs_entity_t ecs_id(EcsIdentifier) = 4; +const ecs_entity_t ecs_id(EcsTrigger) = 5; +const ecs_entity_t ecs_id(EcsQuery) = 6; +const ecs_entity_t ecs_id(EcsObserver) = 7; +const ecs_entity_t ecs_id(EcsIterable) = 8; - result = (char *) ecs_os_malloc(size + 1); +/* System module component ids */ +const ecs_entity_t ecs_id(EcsSystem) = 10; +const ecs_entity_t ecs_id(EcsTickSource) = 11; - if (!result) { - return NULL; - } +/** Pipeline module component ids */ +const ecs_entity_t ecs_id(EcsPipelineQuery) = 12; - ecs_os_vsprintf(result, fmt, args); +/** Timer module component ids */ +const ecs_entity_t ecs_id(EcsTimer) = 13; +const ecs_entity_t ecs_id(EcsRateFilter) = 14; - return result; -} +/** Meta module component ids */ +const ecs_entity_t ecs_id(EcsMetaType) = 15; +const ecs_entity_t ecs_id(EcsMetaTypeSerialized) = 16; +const ecs_entity_t ecs_id(EcsPrimitive) = 17; +const ecs_entity_t ecs_id(EcsEnum) = 18; +const ecs_entity_t ecs_id(EcsBitmask) = 19; +const ecs_entity_t ecs_id(EcsMember) = 20; +const ecs_entity_t ecs_id(EcsStruct) = 21; +const ecs_entity_t ecs_id(EcsArray) = 22; +const ecs_entity_t ecs_id(EcsVector) = 23; +const ecs_entity_t ecs_id(EcsUnit) = 24; +const ecs_entity_t ecs_id(EcsUnitPrefix) = 25; -static -void ecs_colorize_buf( - char *msg, - bool enable_colors, - ecs_strbuf_t *buf) -{ - char *ptr, ch, prev = '\0'; - bool isNum = false; - char isStr = '\0'; - bool isVar = false; - bool overrideColor = false; - bool autoColor = true; - bool dontAppend = false; +/* Core scopes & entities */ +const ecs_entity_t EcsWorld = ECS_HI_COMPONENT_ID + 0; +const ecs_entity_t EcsFlecs = ECS_HI_COMPONENT_ID + 1; +const ecs_entity_t EcsFlecsCore = ECS_HI_COMPONENT_ID + 2; +const ecs_entity_t EcsFlecsHidden = ECS_HI_COMPONENT_ID + 3; +const ecs_entity_t EcsModule = ECS_HI_COMPONENT_ID + 4; +const ecs_entity_t EcsPrivate = ECS_HI_COMPONENT_ID + 5; +const ecs_entity_t EcsPrefab = ECS_HI_COMPONENT_ID + 6; +const ecs_entity_t EcsDisabled = ECS_HI_COMPONENT_ID + 7; - for (ptr = msg; (ch = *ptr); ptr++) { - dontAppend = false; +/* Relation properties */ +const ecs_entity_t EcsWildcard = ECS_HI_COMPONENT_ID + 10; +const ecs_entity_t EcsAny = ECS_HI_COMPONENT_ID + 11; +const ecs_entity_t EcsThis = ECS_HI_COMPONENT_ID + 12; +const ecs_entity_t EcsTransitive = ECS_HI_COMPONENT_ID + 13; +const ecs_entity_t EcsReflexive = ECS_HI_COMPONENT_ID + 14; +const ecs_entity_t EcsSymmetric = ECS_HI_COMPONENT_ID + 15; +const ecs_entity_t EcsFinal = ECS_HI_COMPONENT_ID + 16; +const ecs_entity_t EcsDontInherit = ECS_HI_COMPONENT_ID + 17; +const ecs_entity_t EcsTag = ECS_HI_COMPONENT_ID + 18; +const ecs_entity_t EcsExclusive = ECS_HI_COMPONENT_ID + 19; +const ecs_entity_t EcsAcyclic = ECS_HI_COMPONENT_ID + 20; +const ecs_entity_t EcsWith = ECS_HI_COMPONENT_ID + 21; - if (!overrideColor) { - if (isNum && !isdigit(ch) && !isalpha(ch) && (ch != '.') && (ch != '%')) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - isNum = false; - } - if (isStr && (isStr == ch) && prev != '\\') { - isStr = '\0'; - } else if (((ch == '\'') || (ch == '"')) && !isStr && - !isalpha(prev) && (prev != '\\')) - { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); - isStr = ch; - } +/* Builtin relations */ +const ecs_entity_t EcsChildOf = ECS_HI_COMPONENT_ID + 25; +const ecs_entity_t EcsIsA = ECS_HI_COMPONENT_ID + 26; - if ((isdigit(ch) || (ch == '%' && isdigit(prev)) || - (ch == '-' && isdigit(ptr[1]))) && !isNum && !isStr && !isVar && - !isalpha(prev) && !isdigit(prev) && (prev != '_') && - (prev != '.')) - { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREEN); - isNum = true; - } +/* Identifier tags */ +const ecs_entity_t EcsName = ECS_HI_COMPONENT_ID + 27; +const ecs_entity_t EcsSymbol = ECS_HI_COMPONENT_ID + 28; +const ecs_entity_t EcsAlias = ECS_HI_COMPONENT_ID + 29; - if (isVar && !isalpha(ch) && !isdigit(ch) && ch != '_') { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - isVar = false; - } +/* Events */ +const ecs_entity_t EcsOnAdd = ECS_HI_COMPONENT_ID + 30; +const ecs_entity_t EcsOnRemove = ECS_HI_COMPONENT_ID + 31; +const ecs_entity_t EcsOnSet = ECS_HI_COMPONENT_ID + 32; +const ecs_entity_t EcsUnSet = ECS_HI_COMPONENT_ID + 33; +const ecs_entity_t EcsOnDelete = ECS_HI_COMPONENT_ID + 34; +const ecs_entity_t EcsOnCreateTable = ECS_HI_COMPONENT_ID + 35; +const ecs_entity_t EcsOnDeleteTable = ECS_HI_COMPONENT_ID + 36; +const ecs_entity_t EcsOnTableEmpty = ECS_HI_COMPONENT_ID + 37; +const ecs_entity_t EcsOnTableFill = ECS_HI_COMPONENT_ID + 38; +const ecs_entity_t EcsOnCreateTrigger = ECS_HI_COMPONENT_ID + 39; +const ecs_entity_t EcsOnDeleteTrigger = ECS_HI_COMPONENT_ID + 40; +const ecs_entity_t EcsOnDeleteObservable = ECS_HI_COMPONENT_ID + 41; +const ecs_entity_t EcsOnComponentLifecycle = ECS_HI_COMPONENT_ID + 42; +const ecs_entity_t EcsOnDeleteObject = ECS_HI_COMPONENT_ID + 43; - if (!isStr && !isVar && ch == '$' && isalpha(ptr[1])) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); - isVar = true; - } - } +/* Actions */ +const ecs_entity_t EcsRemove = ECS_HI_COMPONENT_ID + 50; +const ecs_entity_t EcsDelete = ECS_HI_COMPONENT_ID + 51; +const ecs_entity_t EcsThrow = ECS_HI_COMPONENT_ID + 52; - if (!isVar && !isStr && !isNum && ch == '#' && ptr[1] == '[') { - bool isColor = true; - overrideColor = true; +/* Misc */ +const ecs_entity_t EcsDefaultChildComponent = ECS_HI_COMPONENT_ID + 55; - /* Custom colors */ - if (!ecs_os_strncmp(&ptr[2], "]", ecs_os_strlen("]"))) { - autoColor = false; - } else if (!ecs_os_strncmp(&ptr[2], "green]", ecs_os_strlen("green]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREEN); - } else if (!ecs_os_strncmp(&ptr[2], "red]", ecs_os_strlen("red]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_RED); - } else if (!ecs_os_strncmp(&ptr[2], "blue]", ecs_os_strlen("red]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_BLUE); - } else if (!ecs_os_strncmp(&ptr[2], "magenta]", ecs_os_strlen("magenta]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_MAGENTA); - } else if (!ecs_os_strncmp(&ptr[2], "cyan]", ecs_os_strlen("cyan]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); - } else if (!ecs_os_strncmp(&ptr[2], "yellow]", ecs_os_strlen("yellow]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_YELLOW); - } else if (!ecs_os_strncmp(&ptr[2], "grey]", ecs_os_strlen("grey]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREY); - } else if (!ecs_os_strncmp(&ptr[2], "white]", ecs_os_strlen("white]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - } else if (!ecs_os_strncmp(&ptr[2], "bold]", ecs_os_strlen("bold]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_BOLD); - } else if (!ecs_os_strncmp(&ptr[2], "normal]", ecs_os_strlen("normal]"))) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - } else if (!ecs_os_strncmp(&ptr[2], "reset]", ecs_os_strlen("reset]"))) { - overrideColor = false; - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - } else { - isColor = false; - overrideColor = false; - } +/* Systems */ +const ecs_entity_t EcsMonitor = ECS_HI_COMPONENT_ID + 61; +const ecs_entity_t EcsInactive = ECS_HI_COMPONENT_ID + 63; +const ecs_entity_t EcsPipeline = ECS_HI_COMPONENT_ID + 64; +const ecs_entity_t EcsPreFrame = ECS_HI_COMPONENT_ID + 65; +const ecs_entity_t EcsOnLoad = ECS_HI_COMPONENT_ID + 66; +const ecs_entity_t EcsPostLoad = ECS_HI_COMPONENT_ID + 67; +const ecs_entity_t EcsPreUpdate = ECS_HI_COMPONENT_ID + 68; +const ecs_entity_t EcsOnUpdate = ECS_HI_COMPONENT_ID + 69; +const ecs_entity_t EcsOnValidate = ECS_HI_COMPONENT_ID + 70; +const ecs_entity_t EcsPostUpdate = ECS_HI_COMPONENT_ID + 71; +const ecs_entity_t EcsPreStore = ECS_HI_COMPONENT_ID + 72; +const ecs_entity_t EcsOnStore = ECS_HI_COMPONENT_ID + 73; +const ecs_entity_t EcsPostFrame = ECS_HI_COMPONENT_ID + 74; - if (isColor) { - ptr += 2; - while ((ch = *ptr) != ']') ptr ++; - dontAppend = true; - } - if (!autoColor) { - overrideColor = true; - } - } +/* Meta primitive components (don't use low ids to save id space) */ +const ecs_entity_t ecs_id(ecs_bool_t) = ECS_HI_COMPONENT_ID + 80; +const ecs_entity_t ecs_id(ecs_char_t) = ECS_HI_COMPONENT_ID + 81; +const ecs_entity_t ecs_id(ecs_byte_t) = ECS_HI_COMPONENT_ID + 82; +const ecs_entity_t ecs_id(ecs_u8_t) = ECS_HI_COMPONENT_ID + 83; +const ecs_entity_t ecs_id(ecs_u16_t) = ECS_HI_COMPONENT_ID + 84; +const ecs_entity_t ecs_id(ecs_u32_t) = ECS_HI_COMPONENT_ID + 85; +const ecs_entity_t ecs_id(ecs_u64_t) = ECS_HI_COMPONENT_ID + 86; +const ecs_entity_t ecs_id(ecs_uptr_t) = ECS_HI_COMPONENT_ID + 87; +const ecs_entity_t ecs_id(ecs_i8_t) = ECS_HI_COMPONENT_ID + 88; +const ecs_entity_t ecs_id(ecs_i16_t) = ECS_HI_COMPONENT_ID + 89; +const ecs_entity_t ecs_id(ecs_i32_t) = ECS_HI_COMPONENT_ID + 90; +const ecs_entity_t ecs_id(ecs_i64_t) = ECS_HI_COMPONENT_ID + 91; +const ecs_entity_t ecs_id(ecs_iptr_t) = ECS_HI_COMPONENT_ID + 92; +const ecs_entity_t ecs_id(ecs_f32_t) = ECS_HI_COMPONENT_ID + 93; +const ecs_entity_t ecs_id(ecs_f64_t) = ECS_HI_COMPONENT_ID + 94; +const ecs_entity_t ecs_id(ecs_string_t) = ECS_HI_COMPONENT_ID + 95; +const ecs_entity_t ecs_id(ecs_entity_t) = ECS_HI_COMPONENT_ID + 96; +const ecs_entity_t EcsConstant = ECS_HI_COMPONENT_ID + 97; +const ecs_entity_t EcsQuantity = ECS_HI_COMPONENT_ID + 98; - if (ch == '\n') { - if (isNum || isStr || isVar || overrideColor) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - overrideColor = false; - isNum = false; - isStr = false; - isVar = false; - } - } +/* Doc module components */ +const ecs_entity_t ecs_id(EcsDocDescription) =ECS_HI_COMPONENT_ID + 100; +const ecs_entity_t EcsDocBrief = ECS_HI_COMPONENT_ID + 101; +const ecs_entity_t EcsDocDetail = ECS_HI_COMPONENT_ID + 102; +const ecs_entity_t EcsDocLink = ECS_HI_COMPONENT_ID + 103; - if (!dontAppend) { - ecs_strbuf_appendstrn(buf, ptr, 1); - } +/* REST module components */ +const ecs_entity_t ecs_id(EcsRest) = ECS_HI_COMPONENT_ID + 105; - if (!overrideColor) { - if (((ch == '\'') || (ch == '"')) && !isStr) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); - } - } +/* Default lookup path */ +static ecs_entity_t ecs_default_lookup_path[2] = { 0, 0 }; - prev = ch; - } +/* -- Private functions -- */ - if (isNum || isStr || isVar || overrideColor) { - if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); +const ecs_stage_t* flecs_stage_from_readonly_world( + const ecs_world_t *world) +{ + ecs_assert(ecs_poly_is(world, ecs_world_t) || + ecs_poly_is(world, ecs_stage_t), + ECS_INTERNAL_ERROR, + NULL); + + if (ecs_poly_is(world, ecs_world_t)) { + return &world->stage; + + } else if (ecs_poly_is(world, ecs_stage_t)) { + return (ecs_stage_t*)world; } + + return NULL; } -void _ecs_logv( - int level, - const char *file, - int32_t line, - const char *fmt, - va_list args) +ecs_stage_t *flecs_stage_from_world( + ecs_world_t **world_ptr) { - (void)level; - (void)line; + ecs_world_t *world = *world_ptr; - ecs_strbuf_t msg_buf = ECS_STRBUF_INIT; + ecs_assert(ecs_poly_is(world, ecs_world_t) || + ecs_poly_is(world, ecs_stage_t), + ECS_INTERNAL_ERROR, + NULL); - if (level > ecs_os_api.log_level_) { - return; - } + if (ecs_poly_is(world, ecs_world_t)) { + ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); + return &world->stage; - /* Apply color. Even if we don't want color, we still need to call the - * colorize function to get rid of the color tags (e.g. #[green]) */ - char *msg_nocolor = ecs_vasprintf(fmt, args); - ecs_colorize_buf(msg_nocolor, ecs_os_api.log_with_color_, &msg_buf); - ecs_os_free(msg_nocolor); + } else if (ecs_poly_is(world, ecs_stage_t)) { + ecs_stage_t *stage = (ecs_stage_t*)world; + *world_ptr = stage->world; + return stage; + } - char *msg = ecs_strbuf_get(&msg_buf); - ecs_os_api.log_(level, file, line, msg); - ecs_os_free(msg); + return NULL; } -void _ecs_log( - int level, - const char *file, - int32_t line, - const char *fmt, - ...) +ecs_world_t* flecs_suspend_readonly( + const ecs_world_t *stage_world, + ecs_suspend_readonly_state_t *state) { - va_list args; - va_start(args, fmt); - _ecs_logv(level, file, line, fmt, args); - va_end(args); -} + ecs_assert(stage_world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL); -void _ecs_log_push( - int32_t level) -{ - if (level <= ecs_os_api.log_level_) { - ecs_os_api.log_indent_ ++; + ecs_world_t *world = (ecs_world_t*)ecs_get_world(stage_world); + ecs_poly_assert(world, ecs_world_t); + + bool is_readonly = world->is_readonly; + bool is_deferred = ecs_is_deferred(world); + + if (!world->is_readonly && !is_deferred) { + state->is_readonly = false; + state->is_deferred = false; + return world; + } + + ecs_dbg_3("suspending readonly mode"); + + /* Cannot suspend when running with multiple threads */ + ecs_assert(ecs_get_stage_count(world) <= 1, + ECS_INVALID_WHILE_ITERATING, NULL); + + state->is_readonly = is_readonly; + state->is_deferred = is_deferred; + + /* Silence readonly checks */ + world->is_readonly = false; + + /* Hack around safety checks (this ought to look ugly) */ + ecs_world_t *temp_world = world; + ecs_stage_t *stage = flecs_stage_from_world(&temp_world); + state->defer_count = stage->defer; + state->defer_queue = stage->defer_queue; + state->scope = world->stage.scope; + state->with = world->stage.with; + stage->defer = 0; + stage->defer_queue = NULL; + + if (&world->stage != (ecs_stage_t*)stage_world) { + world->stage.scope = stage->scope; + world->stage.with = stage->with; } + + return world; } -void _ecs_log_pop( - int32_t level) +void flecs_resume_readonly( + ecs_world_t *world, + ecs_suspend_readonly_state_t *state) { - if (level <= ecs_os_api.log_level_) { - ecs_os_api.log_indent_ --; + ecs_poly_assert(world, ecs_world_t); + ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_world_t *temp_world = world; + ecs_stage_t *stage = flecs_stage_from_world(&temp_world); + + if (state->is_readonly || state->is_deferred) { + ecs_dbg_3("resuming readonly mode"); + + ecs_force_aperiodic(world); + + /* Restore readonly state / defer count */ + world->is_readonly = state->is_readonly; + stage->defer = state->defer_count; + stage->defer_queue = state->defer_queue; + world->stage.scope = state->scope; + world->stage.with = state->with; } } -void _ecs_parser_errorv( - const char *name, - const char *expr, - int64_t column_arg, - const char *fmt, - va_list args) +/* Evaluate component monitor. If a monitored entity changed it will have set a + * flag in one of the world's component monitors. Queries can register + * themselves with component monitors to determine whether they need to rematch + * with tables. */ +static +void eval_component_monitor( + ecs_world_t *world) { - int32_t column = flecs_itoi32(column_arg); - - if (ecs_os_api.log_level_ >= -2) { - ecs_strbuf_t msg_buf = ECS_STRBUF_INIT; + ecs_poly_assert(world, ecs_world_t); - ecs_strbuf_vappend(&msg_buf, fmt, args); + ecs_relation_monitor_t *rm = &world->monitors; - if (expr) { - ecs_strbuf_appendstr(&msg_buf, "\n"); + if (!rm->is_dirty) { + return; + } - /* Find start of line by taking column and looking for the - * last occurring newline */ - if (column != -1) { - const char *ptr = &expr[column]; - while (ptr[0] != '\n' && ptr > expr) { - ptr --; - } + ecs_map_iter_t it = ecs_map_iter(&rm->monitor_sets); + ecs_monitor_set_t *ms; - if (ptr == expr) { - /* ptr is already at start of line */ - } else { - column -= (int32_t)(ptr - expr + 1); - expr = ptr + 1; - } - } + while ((ms = ecs_map_next(&it, ecs_monitor_set_t, NULL))) { + if (!ms->is_dirty) { + continue; + } - /* Strip newlines from current statement, if any */ - char *newline_ptr = strchr(expr, '\n'); - if (newline_ptr) { - /* Strip newline from expr */ - ecs_strbuf_appendstrn(&msg_buf, expr, - (int32_t)(newline_ptr - expr)); - } else { - ecs_strbuf_appendstr(&msg_buf, expr); + ecs_map_iter_t mit = ecs_map_iter(&ms->monitors); + ecs_monitor_t *m; + while ((m = ecs_map_next(&mit, ecs_monitor_t, NULL))) { + if (!m->is_dirty) { + continue; } - ecs_strbuf_appendstr(&msg_buf, "\n"); + ecs_vector_each(m->queries, ecs_query_t*, q_ptr, { + flecs_query_notify(world, *q_ptr, &(ecs_query_event_t) { + .kind = EcsQueryTableRematch + }); + }); - if (column != -1) { - ecs_strbuf_append(&msg_buf, "%*s^", column, ""); - } + m->is_dirty = false; } - char *msg = ecs_strbuf_get(&msg_buf); - ecs_os_err(name, 0, msg); - ecs_os_free(msg); + ms->is_dirty = false; } -} -void _ecs_parser_error( - const char *name, - const char *expr, - int64_t column, - const char *fmt, - ...) -{ - if (ecs_os_api.log_level_ >= -2) { - va_list args; - va_start(args, fmt); - _ecs_parser_errorv(name, expr, column, fmt, args); - va_end(args); - } + rm->is_dirty = false; } -void _ecs_abort( - int32_t err, - const char *file, - int32_t line, - const char *fmt, - ...) +void flecs_monitor_mark_dirty( + ecs_world_t *world, + ecs_entity_t relation, + ecs_entity_t id) { - if (fmt) { - va_list args; - va_start(args, fmt); - char *msg = ecs_vasprintf(fmt, args); - va_end(args); - _ecs_fatal(file, line, "%s (%s)", msg, ecs_strerror(err)); - ecs_os_free(msg); - } else { - _ecs_fatal(file, line, "%s", ecs_strerror(err)); + /* Only flag if there are actually monitors registered, so that we + * don't waste cycles evaluating monitors if there's no interest */ + ecs_monitor_set_t *ms = ecs_map_get(&world->monitors.monitor_sets, + ecs_monitor_set_t, relation); + if (ms && ecs_map_is_initialized(&ms->monitors)) { + ecs_monitor_t *m = ecs_map_get(&ms->monitors, + ecs_monitor_t, id); + if (m) { + m->is_dirty = true; + ms->is_dirty = true; + world->monitors.is_dirty = true; + } } - ecs_os_api.log_last_error_ = err; } -bool _ecs_assert( - bool condition, - int32_t err, - const char *cond_str, - const char *file, - int32_t line, - const char *fmt, - ...) +void flecs_monitor_register( + ecs_world_t *world, + ecs_entity_t relation, + ecs_entity_t id, + ecs_query_t *query) { - if (!condition) { - if (fmt) { - va_list args; - va_start(args, fmt); - char *msg = ecs_vasprintf(fmt, args); - va_end(args); - _ecs_fatal(file, line, "assert: %s %s (%s)", - cond_str, msg, ecs_strerror(err)); - ecs_os_free(msg); - } else { - _ecs_fatal(file, line, "assert: %s %s", - cond_str, ecs_strerror(err)); - } - ecs_os_api.log_last_error_ = err; + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_monitor_set_t *ms = ecs_map_ensure( + &world->monitors.monitor_sets, ecs_monitor_set_t, relation); + ecs_assert(ms != NULL, ECS_INTERNAL_ERROR, NULL); + + if (!ecs_map_is_initialized(&ms->monitors)) { + ecs_map_init(&ms->monitors, ecs_monitor_t, 1); } - return condition; + ecs_monitor_t *m = ecs_map_ensure(&ms->monitors, ecs_monitor_t, id); + ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_query_t **q = ecs_vector_add(&m->queries, ecs_query_t*); + *q = query; } -void _ecs_deprecated( - const char *file, - int32_t line, - const char *msg) +void flecs_monitor_unregister( + ecs_world_t *world, + ecs_entity_t relation, + ecs_entity_t id, + ecs_query_t *query) { - _ecs_err(file, line, "%s", msg); -} + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); -bool ecs_should_log(int32_t level) { -# if !defined(ECS_TRACE_3) - if (level == 3) { - return false; + ecs_monitor_set_t *ms = ecs_map_get( + &world->monitors.monitor_sets, ecs_monitor_set_t, relation); + if (!ms) { + return; } -# endif -# if !defined(ECS_TRACE_2) - if (level == 2) { - return false; + + if (!ecs_map_is_initialized(&ms->monitors)) { + return; } -# endif -# if !defined(ECS_TRACE_1) - if (level == 1) { - return false; + + ecs_monitor_t *m = ecs_map_get(&ms->monitors, ecs_monitor_t, id); + if (!m) { + return; } -# endif - return level <= ecs_os_api.log_level_; -} + int32_t i, count = ecs_vector_count(m->queries); + ecs_query_t **queries = ecs_vector_first(m->queries, ecs_query_t*); + for (i = 0; i < count; i ++) { + if (queries[i] == query) { + ecs_vector_remove(m->queries, ecs_query_t*, i); + count --; + break; + } + } -#define ECS_ERR_STR(code) case code: return &(#code[4]) + if (!count) { + ecs_vector_free(m->queries); + ecs_map_remove(&ms->monitors, id); + } -const char* ecs_strerror( - int32_t error_code) -{ - switch (error_code) { - ECS_ERR_STR(ECS_INVALID_PARAMETER); - ECS_ERR_STR(ECS_NOT_A_COMPONENT); - ECS_ERR_STR(ECS_INTERNAL_ERROR); - ECS_ERR_STR(ECS_ALREADY_DEFINED); - ECS_ERR_STR(ECS_INVALID_COMPONENT_SIZE); - ECS_ERR_STR(ECS_INVALID_COMPONENT_ALIGNMENT); - ECS_ERR_STR(ECS_NAME_IN_USE); - ECS_ERR_STR(ECS_OUT_OF_MEMORY); - ECS_ERR_STR(ECS_OPERATION_FAILED); - ECS_ERR_STR(ECS_INVALID_CONVERSION); - ECS_ERR_STR(ECS_MODULE_UNDEFINED); - ECS_ERR_STR(ECS_MISSING_SYMBOL); - ECS_ERR_STR(ECS_ALREADY_IN_USE); - ECS_ERR_STR(ECS_COLUMN_INDEX_OUT_OF_RANGE); - ECS_ERR_STR(ECS_COLUMN_IS_NOT_SHARED); - ECS_ERR_STR(ECS_COLUMN_IS_SHARED); - ECS_ERR_STR(ECS_COLUMN_TYPE_MISMATCH); - ECS_ERR_STR(ECS_INVALID_WHILE_ITERATING); - ECS_ERR_STR(ECS_INVALID_FROM_WORKER); - ECS_ERR_STR(ECS_OUT_OF_RANGE); - ECS_ERR_STR(ECS_MISSING_OS_API); - ECS_ERR_STR(ECS_UNSUPPORTED); - ECS_ERR_STR(ECS_COLUMN_ACCESS_VIOLATION); - ECS_ERR_STR(ECS_COMPONENT_NOT_REGISTERED); - ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ID); - ECS_ERR_STR(ECS_TYPE_INVALID_CASE); - ECS_ERR_STR(ECS_INCONSISTENT_NAME); - ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ACTION); - ECS_ERR_STR(ECS_INVALID_OPERATION); - ECS_ERR_STR(ECS_CONSTRAINT_VIOLATED); - ECS_ERR_STR(ECS_LOCKED_STORAGE); - ECS_ERR_STR(ECS_ID_IN_USE); + if (!ecs_map_count(&ms->monitors)) { + ecs_map_fini(&ms->monitors); + ecs_map_remove(&world->monitors.monitor_sets, relation); } - return "unknown error code"; + if (!ecs_map_count(&world->monitors.monitor_sets)) { + ecs_map_fini(&world->monitors.monitor_sets); + } } -#else - -/* Empty bodies for when logging is disabled */ - -void _ecs_log( - int32_t level, - const char *file, - int32_t line, - const char *fmt, - ...) +static +void monitors_init( + ecs_relation_monitor_t *rm) { - (void)level; - (void)file; - (void)line; - (void)fmt; + ecs_map_init(&rm->monitor_sets, ecs_monitor_set_t, 0); + rm->is_dirty = false; } -void _ecs_parser_error( - const char *name, - const char *expr, - int64_t column, - const char *fmt, - ...) -{ - (void)name; - (void)expr; - (void)column; - (void)fmt; -} - -void _ecs_parser_errorv( - const char *name, - const char *expr, - int64_t column, - const char *fmt, - va_list args) +static +void monitors_fini( + ecs_relation_monitor_t *rm) { - (void)name; - (void)expr; - (void)column; - (void)fmt; - (void)args; + ecs_map_iter_t it = ecs_map_iter(&rm->monitor_sets); + ecs_monitor_set_t *ms; + + while ((ms = ecs_map_next(&it, ecs_monitor_set_t, NULL))) { + ecs_map_iter_t mit = ecs_map_iter(&ms->monitors); + ecs_monitor_t *m; + while ((m = ecs_map_next(&mit, ecs_monitor_t, NULL))) { + ecs_vector_free(m->queries); + } + + ecs_map_fini(&ms->monitors); + } + + ecs_map_fini(&rm->monitor_sets); } -void _ecs_abort( - int32_t error_code, - const char *file, - int32_t line, - const char *fmt, - ...) +static +void init_store( + ecs_world_t *world) { - (void)error_code; - (void)file; - (void)line; - (void)fmt; + ecs_os_memset(&world->store, 0, ECS_SIZEOF(ecs_store_t)); + + /* Initialize entity index */ + flecs_sparse_init(&world->store.entity_index, ecs_record_t); + flecs_sparse_set_id_source(&world->store.entity_index, + &world->stats.last_id); + + /* Initialize root table */ + flecs_sparse_init(&world->store.tables, ecs_table_t); + + /* Initialize table map */ + flecs_table_hashmap_init(&world->store.table_map); + + /* Initialize one root table per stage */ + flecs_init_root_table(world); } -bool _ecs_assert( - bool condition, - int32_t error_code, - const char *condition_str, - const char *file, - int32_t line, - const char *fmt, - ...) +static +void clean_tables( + ecs_world_t *world) { - (void)condition; - (void)error_code; - (void)condition_str; - (void)file; - (void)line; - (void)fmt; - return true; -} + int32_t i, count = flecs_sparse_count(&world->store.tables); -#endif + /* Ensure that first table in sparse set has id 0. This is a dummy table + * that only exists so that there is no table with id 0 */ + ecs_table_t *first = flecs_sparse_get_dense(&world->store.tables, + ecs_table_t, 0); + ecs_assert(first->id == 0, ECS_INTERNAL_ERROR, NULL); + (void)first; -int ecs_log_set_level( - int level) -{ - int prev = level; - ecs_os_api.log_level_ = level; - return prev; + for (i = 1; i < count; i ++) { + ecs_table_t *t = flecs_sparse_get_dense(&world->store.tables, + ecs_table_t, i); + flecs_table_release(world, t); + } + + /* Free table types separately so that if application destructors rely on + * a type it's still valid. */ + for (i = 1; i < count; i ++) { + ecs_table_t *t = flecs_sparse_get_dense(&world->store.tables, + ecs_table_t, i); + flecs_table_free_type(t); + } + + /* Clear the root table */ + if (count) { + flecs_table_reset(world, &world->store.root); + } } -bool ecs_log_enable_colors( - bool enabled) -{ - bool prev = ecs_os_api.log_with_color_; - ecs_os_api.log_with_color_ = enabled; - return prev; +static +void fini_store(ecs_world_t *world) { + clean_tables(world); + flecs_sparse_fini(&world->store.tables); + flecs_table_release(world, &world->store.root); + flecs_sparse_clear(&world->store.entity_index); + flecs_hashmap_fini(&world->store.table_map); + + ecs_graph_edge_hdr_t *cur, *next = world->store.first_free; + while ((cur = next)) { + next = cur->next; + ecs_os_free(cur); + } } -int ecs_log_last_error(void) +/* Implementation for iterable mixin */ +static +bool world_iter_next( + ecs_iter_t *it) { - int result = ecs_os_api.log_last_error_; - ecs_os_api.log_last_error_ = 0; - return result; + if (it->is_valid) { + return it->is_valid = false; + } + + ecs_world_t *world = it->real_world; + ecs_sparse_t *entity_index = &world->store.entity_index; + it->entities = (ecs_entity_t*)flecs_sparse_ids(entity_index); + it->count = flecs_sparse_count(entity_index); + return it->is_valid = true; } -#ifndef FLECS_SYSTEM_PRIVATE_H -#define FLECS_SYSTEM_PRIVATE_H +static +void world_iter_init( + const ecs_world_t *world, + const ecs_poly_t *poly, + ecs_iter_t *iter, + ecs_term_t *filter) +{ + ecs_poly_assert(poly, ecs_world_t); + (void)poly; -#ifdef FLECS_SYSTEM + if (filter) { + iter[0] = ecs_term_iter(world, filter); + } else { + iter[0] = (ecs_iter_t){ + .world = (ecs_world_t*)world, + .real_world = (ecs_world_t*)ecs_get_world(world), + .next = world_iter_next + }; + } +} +static +void log_addons(void) { + ecs_trace("addons included in build:"); + ecs_log_push(); + #ifdef FLECS_CPP + ecs_trace("FLECS_CPP"); + #endif + #ifdef FLECS_MODULE + ecs_trace("FLECS_MODULE"); + #endif + #ifdef FLECS_PARSER + ecs_trace("FLECS_PARSER"); + #endif + #ifdef FLECS_PLECS + ecs_trace("FLECS_PLECS"); + #endif + #ifdef FLECS_RULES + ecs_trace("FLECS_RULES"); + #endif + #ifdef FLECS_SNAPSHOT + ecs_trace("FLECS_SNAPSHOT"); + #endif + #ifdef FLECS_STATS + ecs_trace("FLECS_STATS"); + #endif + #ifdef FLECS_SYSTEM + ecs_trace("FLECS_SYSTEM"); + #endif + #ifdef FLECS_PIPELINE + ecs_trace("FLECS_PIPELINE"); + #endif + #ifdef FLECS_TIMER + ecs_trace("FLECS_TIMER"); + #endif + #ifdef FLECS_META + ecs_trace("FLECS_META"); + #endif + #ifdef FLECS_META_C + ecs_trace("FLECS_META_C"); + #endif + #ifdef FLECS_UNITS + ecs_trace("FLECS_UNITS"); + #endif + #ifdef FLECS_EXPR + ecs_trace("FLECS_EXPR"); + #endif + #ifdef FLECS_JSON + ecs_trace("FLECS_JSON"); + #endif + #ifdef FLECS_DOC + ecs_trace("FLECS_DOC"); + #endif + #ifdef FLECS_COREDOC + ecs_trace("FLECS_COREDOC"); + #endif + #ifdef FLECS_LOG + ecs_trace("FLECS_LOG"); + #endif + #ifdef FLECS_APP + ecs_trace("FLECS_APP"); + #endif + #ifdef FLECS_OS_API_IMPL + ecs_trace("FLECS_OS_API_IMPL"); + #endif + #ifdef FLECS_HTTP + ecs_trace("FLECS_HTTP"); + #endif + #ifdef FLECS_REST + ecs_trace("FLECS_REST"); + #endif + ecs_log_pop(); +} -typedef struct EcsSystem { - ecs_run_action_t run; /* See ecs_system_desc_t */ - ecs_iter_action_t action; /* See ecs_system_desc_t */ +/* -- Public functions -- */ - ecs_entity_t entity; /* Entity id of system, used for ordering */ - ecs_query_t *query; /* System query */ - ecs_system_status_action_t status_action; /* Status action */ - ecs_entity_t tick_source; /* Tick source associated with system */ - - /* Schedule parameters */ - bool multi_threaded; - bool no_staging; +ecs_world_t *ecs_mini(void) { +#ifdef FLECS_OS_API_IMPL + ecs_set_os_api_impl(); +#endif + ecs_os_init(); - int32_t invoke_count; /* Number of times system is invoked */ - float time_spent; /* Time spent on running system */ - FLECS_FLOAT time_passed; /* Time passed since last invocation */ - int32_t last_frame; /* Last frame for which the system was considered */ + ecs_trace("#[bold]bootstrapping world"); + ecs_log_push(); - ecs_entity_t self; /* Entity associated with system */ + ecs_trace("tracing enabled, call ecs_log_set_level(-1) to disable"); - void *ctx; /* Userdata for system */ - void *status_ctx; /* User data for status action */ - void *binding_ctx; /* Optional language binding context */ + if (!ecs_os_has_heap()) { + ecs_abort(ECS_MISSING_OS_API, NULL); + } - ecs_ctx_free_t ctx_free; - ecs_ctx_free_t status_ctx_free; - ecs_ctx_free_t binding_ctx_free; -} EcsSystem; + if (!ecs_os_has_threading()) { + ecs_trace("threading unavailable, to use threads set OS API first (see examples)"); + } -/* Invoked when system becomes active / inactive */ -void ecs_system_activate( - ecs_world_t *world, - ecs_entity_t system, - bool activate, - const EcsSystem *system_data); + if (!ecs_os_has_time()) { + ecs_trace("time management not available"); + } -/* Internal function to run a system */ -ecs_entity_t ecs_run_intern( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t system, - EcsSystem *system_data, - int32_t stage_current, - int32_t stage_count, - FLECS_FLOAT delta_time, - int32_t offset, - int32_t limit, - void *param); + log_addons(); +#ifdef FLECS_SANITIZE + ecs_trace("sanitize build, rebuild witohut FLECS_SANITIZE for (much) " + "improved performance"); +#elif defined(FLECS_DEBUG) + ecs_trace("debug build, rebuild with NDEBUG or FLECS_NDEBUG for improved " + "performance"); +#else + ecs_trace("#[green]release#[reset] build"); #endif +#ifdef __clang__ + ecs_trace("compiled with clang %s", __clang_version__); +#elif defined(__GNUC__) + ecs_trace("compiled with gcc %d.%d", __GNUC__, __GNUC_MINOR__); +#elif defined (_MSC_VER) + ecs_trace("compiled with msvc %d", _MSC_VER); #endif + ecs_world_t *world = ecs_os_calloc_t(ecs_world_t); + ecs_assert(world != NULL, ECS_OUT_OF_MEMORY, NULL); + ecs_poly_init(world, ecs_world_t); -#ifdef FLECS_PIPELINE -#ifndef FLECS_PIPELINE_PRIVATE_H -#define FLECS_PIPELINE_PRIVATE_H + world->self = world; + world->type_info = flecs_sparse_new(ecs_type_info_t); + ecs_map_init(&world->id_index, ecs_id_record_t*, ECS_HI_COMPONENT_ID); + flecs_observable_init(&world->observable); + world->iterable.init = world_iter_init; + world->queries = flecs_sparse_new(ecs_query_t); + world->triggers = flecs_sparse_new(ecs_trigger_t); + world->observers = flecs_sparse_new(ecs_observer_t); + + world->pending_tables = flecs_sparse_new(ecs_table_t*); + world->pending_buffer = flecs_sparse_new(ecs_table_t*); -/** Instruction data for pipeline. - * This type is the element type in the "ops" vector of a pipeline and contains - * information about the set of systems that need to be ran before a merge. */ -typedef struct ecs_pipeline_op_t { - int32_t count; /* Number of systems to run before merge */ - bool multi_threaded; /* Whether systems can be ran multi threaded */ - bool no_staging; /* Whether systems are staged or not */ -} ecs_pipeline_op_t; + world->fini_tasks = ecs_vector_new(ecs_entity_t, 0); + flecs_name_index_init(&world->aliases); + flecs_name_index_init(&world->symbols); + ecs_map_init(&world->type_handles, ecs_entity_t, 0); -typedef struct EcsPipelineQuery { - ecs_query_t *query; - ecs_query_t *build_query; - ecs_vector_t *ops; - int32_t match_count; - int32_t rebuild_count; - ecs_entity_t last_system; -} EcsPipelineQuery; + world->stats.time_scale = 1.0; + + monitors_init(&world->monitors); -//////////////////////////////////////////////////////////////////////////////// -//// Pipeline API -//////////////////////////////////////////////////////////////////////////////// + if (ecs_os_has_time()) { + ecs_os_get_time(&world->world_start_time); + } -/** Update a pipeline (internal function). - * Before running a pipeline, it must be updated. During this update phase - * all systems in the pipeline are collected, ordered and sync points are - * inserted where necessary. This operation may only be called when staging is - * disabled. - * - * Because multiple threads may run a pipeline, preparing the pipeline must - * happen synchronously, which is why this function is separate from - * ecs_run_pipeline. Not running the prepare step may cause systems to not get - * ran, or ran in the wrong order. - * - * If 0 is provided for the pipeline id, the default pipeline will be ran (this - * is either the builtin pipeline or the pipeline set with set_pipeline()). - * - * @param world The world. - * @param pipeline The pipeline to run. - * @return The number of elements in the pipeline. - */ -bool ecs_pipeline_update( - ecs_world_t *world, - ecs_entity_t pipeline, - bool start_of_frame); + flecs_stage_init(world, &world->stage); + ecs_set_stages(world, 1); -int32_t ecs_pipeline_reset_iter( - ecs_world_t *world, - const EcsPipelineQuery *pq, - ecs_iter_t *iter_out, - ecs_pipeline_op_t **op_out, - ecs_pipeline_op_t **last_op_out); + ecs_default_lookup_path[0] = EcsFlecsCore; + ecs_set_lookup_path(world, ecs_default_lookup_path); -//////////////////////////////////////////////////////////////////////////////// -//// Worker API -//////////////////////////////////////////////////////////////////////////////// + init_store(world); + ecs_trace("table store initialized"); -void ecs_worker_begin( - ecs_world_t *world); + flecs_bootstrap(world); -int32_t ecs_worker_sync( - ecs_world_t *world, - const EcsPipelineQuery *pq, - ecs_iter_t *it, - int32_t i, - ecs_pipeline_op_t **op_out, - ecs_pipeline_op_t **last_op_out); + ecs_trace("world ready!"); + ecs_log_pop(); -void ecs_worker_end( - ecs_world_t *world); + return world; +} -void ecs_workers_progress( - ecs_world_t *world, - ecs_entity_t pipeline, - FLECS_FLOAT delta_time); +ecs_world_t *ecs_init(void) { + ecs_world_t *world = ecs_mini(); +#ifdef FLECS_MODULE_H + ecs_trace("#[bold]import addons"); + ecs_log_push(); + ecs_trace("use ecs_mini to create world without importing addons"); +#ifdef FLECS_SYSTEM + ECS_IMPORT(world, FlecsSystem); #endif +#ifdef FLECS_PIPELINE + ECS_IMPORT(world, FlecsPipeline); +#endif +#ifdef FLECS_TIMER + ECS_IMPORT(world, FlecsTimer); +#endif +#ifdef FLECS_META + ECS_IMPORT(world, FlecsMeta); +#endif +#ifdef FLECS_DOC + ECS_IMPORT(world, FlecsDoc); +#endif +#ifdef FLECS_COREDOC + ECS_IMPORT(world, FlecsCoreDoc); +#endif +#ifdef FLECS_REST + ECS_IMPORT(world, FlecsRest); +#endif +#ifdef FLECS_UNITS + ecs_trace("#[green]module#[reset] flecs.units is not automatically imported"); +#endif + ecs_trace("addons imported!"); + ecs_log_pop(); +#endif + return world; +} - -/* Worker thread */ -static -void* worker(void *arg) { - ecs_stage_t *stage = arg; - ecs_world_t *world = stage->world; - - /* Start worker thread, increase counter so main thread knows how many - * workers are ready */ - ecs_os_mutex_lock(world->sync_mutex); - world->workers_running ++; - - if (!world->quit_workers) { - ecs_os_cond_wait(world->worker_cond, world->sync_mutex); +#define ARG(short, long, action)\ + if (i < argc) {\ + if (argv[i][0] == '-') {\ + if (argv[i][1] == '-') {\ + if (long && !strcmp(&argv[i][2], long ? long : "")) {\ + action;\ + parsed = true;\ + }\ + } else {\ + if (short && argv[i][1] == short) {\ + action;\ + parsed = true;\ + }\ + }\ + }\ } - ecs_os_mutex_unlock(world->sync_mutex); +ecs_world_t* ecs_init_w_args( + int argc, + char *argv[]) +{ + ecs_world_t *world = ecs_init(); - while (!world->quit_workers) { - ecs_entity_t old_scope = ecs_set_scope((ecs_world_t*)stage, 0); - - ecs_run_pipeline( - (ecs_world_t*)stage, - world->pipeline, - world->stats.delta_time); + (void)argc; + (void) argv; - ecs_set_scope((ecs_world_t*)stage, old_scope); +#ifdef FLECS_DOC + if (argc) { + char *app = argv[0]; + char *last_elem = strrchr(app, '/'); + if (!last_elem) { + last_elem = strrchr(app, '\\'); + } + if (last_elem) { + app = last_elem + 1; + } + ecs_set_pair(world, EcsWorld, EcsDocDescription, EcsName, {app}); } +#endif - ecs_os_mutex_lock(world->sync_mutex); - world->workers_running --; - ecs_os_mutex_unlock(world->sync_mutex); + return world; +} - return NULL; +void ecs_quit( + ecs_world_t *world) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + flecs_stage_from_world(&world); + world->should_quit = true; +error: + return; } -/* Start threads */ -static -void start_workers( +bool ecs_should_quit( + const ecs_world_t *world) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + world = ecs_get_world(world); + return world->should_quit; +error: + return true; +} + +void flecs_notify_tables( ecs_world_t *world, - int32_t threads) + ecs_id_t id, + ecs_table_event_t *event) { - ecs_set_stages(world, threads); + ecs_poly_assert(world, ecs_world_t); - ecs_assert(ecs_get_stage_count(world) == threads, ECS_INTERNAL_ERROR, NULL); + /* If no id is specified, broadcast to all tables */ + if (!id) { + ecs_sparse_t *tables = &world->store.tables; + int32_t i, count = flecs_sparse_count(tables); + for (i = 0; i < count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); + flecs_table_notify(world, table, event); + } - int32_t i; - for (i = 0; i < threads; i ++) { - ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); - ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_poly_assert(stage, ecs_stage_t); + /* If id is specified, only broadcast to tables with id */ + } else { + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { + return; + } - ecs_vector_get(world->worker_stages, ecs_stage_t, i); - stage->thread = ecs_os_thread_new(worker, stage); - ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED, NULL); + ecs_table_cache_iter_t it; + const ecs_table_record_t *tr; + + flecs_table_cache_iter(&idr->cache, &it); + while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) { + flecs_table_notify(world, tr->hdr.table, event); + } + + flecs_table_cache_empty_iter(&idr->cache, &it); + while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) { + flecs_table_notify(world, tr->hdr.table, event); + } } } -/* Wait until all workers are running */ -static -void wait_for_workers( - ecs_world_t *world) +void ecs_default_ctor( + ecs_world_t *world, + const ecs_entity_t *entity_ptr, + void *ptr, + int32_t count, + const ecs_type_info_t *ti) { - int32_t stage_count = ecs_get_stage_count(world); - bool wait = true; + (void)world; (void)entity_ptr; + ecs_os_memset(ptr, 0, ti->size * count); +} - do { - ecs_os_mutex_lock(world->sync_mutex); - if (world->workers_running == stage_count) { - wait = false; - } - ecs_os_mutex_unlock(world->sync_mutex); - } while (wait); +static +void default_copy_ctor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, const void *src_ptr, + int32_t count, const ecs_type_info_t *ti) +{ + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->ctor(world, dst_entity, dst_ptr, count, ti); + cl->copy(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); } -/* Synchronize worker threads */ static -void sync_worker( - ecs_world_t *world) +void default_move_ctor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) { - int32_t stage_count = ecs_get_stage_count(world); + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->ctor(world, dst_entity, dst_ptr, count, ti); + cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); +} - /* Signal that thread is waiting */ - ecs_os_mutex_lock(world->sync_mutex); - if (++ world->workers_waiting == stage_count) { - /* Only signal main thread when all threads are waiting */ - ecs_os_cond_signal(world->sync_cond); - } +static +void default_ctor_w_move_w_dtor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) +{ + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->ctor(world, dst_entity, dst_ptr, count, ti); + cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); + cl->dtor(world, src_entity, src_ptr, count, ti); +} - /* Wait until main thread signals that thread can continue */ - ecs_os_cond_wait(world->worker_cond, world->sync_mutex); - ecs_os_mutex_unlock(world->sync_mutex); +static +void default_move_ctor_w_dtor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) +{ + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->move_ctor(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); + cl->dtor(world, src_entity, src_ptr, count, ti); } -/* Wait until all threads are waiting on sync point */ static -void wait_for_sync( - ecs_world_t *world) +void default_move( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) { - int32_t stage_count = ecs_get_stage_count(world); + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); +} - ecs_os_mutex_lock(world->sync_mutex); - if (world->workers_waiting != stage_count) { - ecs_os_cond_wait(world->sync_cond, world->sync_mutex); - } - - /* We should have been signalled unless all workers are waiting on sync */ - ecs_assert(world->workers_waiting == stage_count, - ECS_INTERNAL_ERROR, NULL); +static +void default_dtor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) +{ + (void)src_entity; - ecs_os_mutex_unlock(world->sync_mutex); + /* When there is no move, destruct the destination component & memcpy the + * component to dst. The src component does not have to be destructed when + * a component has a trivial move. */ + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->dtor(world, dst_entity, dst_ptr, count, ti); + ecs_os_memcpy(dst_ptr, src_ptr, flecs_uto(ecs_size_t, ti->size) * count); } -/* Signal workers that they can start/resume work */ static -void signal_workers( - ecs_world_t *world) +void default_move_w_dtor( + ecs_world_t *world, const ecs_entity_t *dst_entity, + const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, + int32_t count, const ecs_type_info_t *ti) { - ecs_os_mutex_lock(world->sync_mutex); - ecs_os_cond_broadcast(world->worker_cond); - ecs_os_mutex_unlock(world->sync_mutex); + /* If a component has a move, the move will take care of memcpying the data + * and destroying any data in dst. Because this is not a trivial move, the + * src component must also be destructed. */ + const EcsComponentLifecycle *cl = &ti->lifecycle; + cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); + cl->dtor(world, src_entity, src_ptr, count, ti); } -/** Stop worker threads */ -static -bool ecs_stop_threads( - ecs_world_t *world) +void ecs_set_component_actions_w_id( + ecs_world_t *world, + ecs_entity_t component, + EcsComponentLifecycle *lifecycle) { - bool threads_active = false; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + flecs_stage_from_world(&world); - /* Test if threads are created. Cannot use workers_running, since this is - * a potential race if threads haven't spun up yet. */ - ecs_vector_each(world->worker_stages, ecs_stage_t, stage, { - if (stage->thread) { - threads_active = true; - break; - } - stage->thread = 0; - }); + ecs_type_info_t *ti = flecs_ensure_type_info(world, component); + ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); - /* If no threads are active, just return */ - if (!threads_active) { - return false; - } + ecs_size_t size = ti->size; + ecs_size_t alignment = ti->alignment; - /* Make sure all threads are running, to ensure they catch the signal */ - wait_for_workers(world); + if (!size) { + const EcsComponent *component_ptr = ecs_get( + world, component, EcsComponent); - /* Signal threads should quit */ - world->quit_workers = true; - signal_workers(world); + /* Cannot register lifecycle actions for things that aren't a component */ + ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, NULL); + /* Cannot register lifecycle actions for components with size 0 */ + ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER, NULL); - /* Join all threads with main */ - ecs_stage_t *stages = ecs_vector_first(world->worker_stages, ecs_stage_t); - int32_t i, count = ecs_vector_count(world->worker_stages); - for (i = 0; i < count; i ++) { - ecs_os_thread_join(stages[i].thread); - stages[i].thread = 0; + size = component_ptr->size; + alignment = component_ptr->alignment; } - world->quit_workers = false; - ecs_assert(world->workers_running == 0, ECS_INTERNAL_ERROR, NULL); + if (ti->lifecycle_set) { + ecs_assert(ti->component == component, ECS_INTERNAL_ERROR, NULL); + ecs_check(!lifecycle->ctor || ti->lifecycle.ctor == lifecycle->ctor, + ECS_INCONSISTENT_COMPONENT_ACTION, NULL); + ecs_check(!lifecycle->dtor || ti->lifecycle.dtor == lifecycle->dtor, + ECS_INCONSISTENT_COMPONENT_ACTION, NULL); + ecs_check(!lifecycle->copy || ti->lifecycle.copy == lifecycle->copy, + ECS_INCONSISTENT_COMPONENT_ACTION, NULL); + ecs_check(!lifecycle->move || ti->lifecycle.move == lifecycle->move, + ECS_INCONSISTENT_COMPONENT_ACTION, NULL); - /* Deinitialize stages */ - ecs_set_stages(world, 0); + if (!ti->lifecycle.on_set) { + ti->lifecycle.on_set = lifecycle->on_set; + } + if (!ti->lifecycle.on_remove) { + ti->lifecycle.on_remove = lifecycle->on_remove; + } + } else { + ti->component = component; + ti->lifecycle = *lifecycle; + ti->lifecycle_set = true; + ti->size = size; + ti->alignment = alignment; - return true; -} + /* If no constructor is set, invoking any of the other lifecycle actions + * is not safe as they will potentially access uninitialized memory. For + * ease of use, if no constructor is specified, set a default one that + * initializes the component to 0. */ + if (!lifecycle->ctor && + (lifecycle->dtor || lifecycle->copy || lifecycle->move)) + { + ti->lifecycle.ctor = ecs_default_ctor; + } -/* -- Private functions -- */ + /* Set default copy ctor, move ctor and merge */ + if (lifecycle->copy && !lifecycle->copy_ctor) { + ti->lifecycle.copy_ctor = default_copy_ctor; + } -void ecs_worker_begin( - ecs_world_t *world) -{ - flecs_stage_from_world(&world); - int32_t stage_count = ecs_get_stage_count(world); - ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); - - if (stage_count == 1) { - ecs_entity_t pipeline = world->pipeline; - const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); - ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); + if (lifecycle->move && !lifecycle->move_ctor) { + ti->lifecycle.move_ctor = default_move_ctor; + } - ecs_pipeline_op_t *op = ecs_vector_first(pq->ops, ecs_pipeline_op_t); - if (!op || !op->no_staging) { - ecs_staging_begin(world); + if (!lifecycle->ctor_move_dtor) { + if (lifecycle->move) { + if (lifecycle->dtor) { + if (lifecycle->move_ctor) { + /* If an explicit move ctor has been set, use callback + * that uses the move ctor vs. using a ctor+move */ + ti->lifecycle.ctor_move_dtor = + default_move_ctor_w_dtor; + } else { + /* If no explicit move_ctor has been set, use + * combination of ctor + move + dtor */ + ti->lifecycle.ctor_move_dtor = + default_ctor_w_move_w_dtor; + } + } else { + /* If no dtor has been set, this is just a move ctor */ + ti->lifecycle.ctor_move_dtor = + ti->lifecycle.move_ctor; + } + } + } + + if (!lifecycle->move_dtor) { + if (lifecycle->move) { + if (lifecycle->dtor) { + ti->lifecycle.move_dtor = default_move_w_dtor; + } else { + ti->lifecycle.move_dtor = default_move; + } + } else { + if (lifecycle->dtor) { + ti->lifecycle.move_dtor = default_dtor; + } + } } + + /* Ensure that no tables have yet been created for the component */ + ecs_assert( flecs_id_existst(world, component) == false, + ECS_ALREADY_IN_USE, ecs_get_name(world, component)); + ecs_assert( flecs_id_existst(world, + ecs_pair(component, EcsWildcard)) == false, + ECS_ALREADY_IN_USE, ecs_get_name(world, component)); } +error: + return; } -int32_t ecs_worker_sync( +bool ecs_component_has_actions( + const ecs_world_t *world, + ecs_entity_t component) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(component != 0, ECS_INVALID_PARAMETER, NULL); + + world = ecs_get_world(world); + const ecs_type_info_t *ti = flecs_get_type_info(world, component); + return (ti != NULL) && ti->lifecycle_set; +error: + return false; +} + +void ecs_atfini( ecs_world_t *world, - const EcsPipelineQuery *pq, - ecs_iter_t *it, - int32_t i, - ecs_pipeline_op_t **op_out, - ecs_pipeline_op_t **last_op_out) + ecs_fini_action_t action, + void *ctx) { - int32_t stage_count = ecs_get_stage_count(world); - ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); - int32_t build_count = world->stats.pipeline_build_count_total; + ecs_poly_assert(world, ecs_world_t); + ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL); - /* If there are no threads, merge in place */ - if (stage_count == 1) { - if (!op_out[0]->no_staging) { - ecs_staging_end(world); - } + ecs_action_elem_t *elem = ecs_vector_add(&world->fini_actions, + ecs_action_elem_t); + ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_pipeline_update(world, world->pipeline, false); + elem->action = action; + elem->ctx = ctx; +error: + return; +} - /* Synchronize all workers. The last worker to reach the sync point will - * signal the main thread, which will perform the merge. */ - } else { - sync_worker(world); - } +void ecs_run_post_frame( + ecs_world_t *world, + ecs_fini_action_t action, + void *ctx) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_stage_t *stage = flecs_stage_from_world(&world); + ecs_action_elem_t *elem = ecs_vector_add(&stage->post_frame_actions, + ecs_action_elem_t); + ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - if (build_count != world->stats.pipeline_build_count_total) { - i = ecs_pipeline_reset_iter(world, pq, it, op_out, last_op_out); - } else { - op_out[0] ++; - } + elem->action = action; + elem->ctx = ctx; +error: + return; +} - if (stage_count == 1) { - if (!op_out[0]->no_staging) { - ecs_staging_begin(world); - } - } +/* Unset data in tables */ +static +void fini_unset_tables( + ecs_world_t *world) +{ + ecs_sparse_t *tables = &world->store.tables; + int32_t i, count = flecs_sparse_count(tables); - return i; + for (i = 0; i < count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); + flecs_table_remove_actions(world, table); + } } -void ecs_worker_end( +/* Invoke fini actions */ +static +void fini_actions( ecs_world_t *world) { - flecs_stage_from_world(&world); + ecs_vector_each(world->fini_actions, ecs_action_elem_t, elem, { + elem->action(world, elem->ctx); + }); - int32_t stage_count = ecs_get_stage_count(world); - ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); + ecs_vector_free(world->fini_actions); +} - /* If there are no threads, merge in place */ - if (stage_count == 1) { - if (ecs_stage_is_readonly(world)) { - ecs_staging_end(world); - } +/* Cleanup component lifecycle callbacks & systems */ +static +void fini_component_lifecycle( + ecs_world_t *world) +{ + flecs_sparse_free(world->type_info); +} - /* Synchronize all workers. The last worker to reach the sync point will - * signal the main thread, which will perform the merge. */ - } else { - sync_worker(world); +/* Cleanup queries */ +static +void fini_queries( + ecs_world_t *world) +{ + monitors_fini(&world->monitors); + + int32_t i, count = flecs_sparse_count(world->queries); + for (i = 0; i < count; i ++) { + ecs_query_t *query = flecs_sparse_get_dense(world->queries, ecs_query_t, 0); + ecs_query_fini(query); } + flecs_sparse_free(world->queries); } -void ecs_workers_progress( - ecs_world_t *world, - ecs_entity_t pipeline, - FLECS_FLOAT delta_time) +static +void fini_observers( + ecs_world_t *world) { - ecs_poly_assert(world, ecs_world_t); - int32_t stage_count = ecs_get_stage_count(world); - - ecs_time_t start = {0}; - if (world->measure_frame_time) { - ecs_time_measure(&start); - } + flecs_sparse_free(world->observers); +} - if (stage_count == 1) { - ecs_pipeline_update(world, pipeline, true); - ecs_entity_t old_scope = ecs_set_scope(world, 0); - ecs_world_t *stage = ecs_get_stage(world, 0); - ecs_run_pipeline(stage, pipeline, delta_time); - ecs_set_scope(world, old_scope); - } else { - ecs_pipeline_update(world, pipeline, true); +/* Cleanup stages */ +static +void fini_stages( + ecs_world_t *world) +{ + flecs_stage_deinit(world, &world->stage); + ecs_set_stages(world, 0); +} - const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); - ecs_vector_t *ops = pq->ops; - ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); - ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); +static +ecs_id_record_t* new_id_record( + ecs_world_t *world, + ecs_id_t id) +{ + ecs_id_record_t *idr = ecs_os_calloc_t(ecs_id_record_t); + ecs_table_cache_init(&idr->cache); - /* Make sure workers are running and ready */ - wait_for_workers(world); + ecs_entity_t rel = 0, obj = 0; + if (ECS_HAS_ROLE(id, PAIR)) { + rel = ecs_pair_first(world, id); + ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL); - /* Synchronize n times for each op in the pipeline */ - for (; op <= op_last; op ++) { - if (!op->no_staging) { - ecs_staging_begin(world); - } - - /* Signal workers that they should start running systems */ - world->workers_waiting = 0; - signal_workers(world); - - /* Wait until all workers are waiting on sync point */ - wait_for_sync(world); - - /* Merge */ - if (!op->no_staging) { - ecs_staging_end(world); - } + /* Relation object can be 0, as tables without a ChildOf relation are + * added to the (ChildOf, 0) id record */ + obj = ECS_PAIR_SECOND(id); + if (obj) { + obj = ecs_get_alive(world, obj); + ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); + } + + /* If id is a pair, inherit flags from relation id record */ + ecs_id_record_t *idr_r = flecs_get_id_record( + world, ECS_PAIR_FIRST(id)); + if (idr_r) { + idr->flags = idr_r->flags; + } + } else { + rel = id & ECS_COMPONENT_MASK; + rel = ecs_get_alive(world, rel); + ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL); + } - if (ecs_pipeline_update(world, pipeline, false)) { - /* Refetch, in case pipeline itself has moved */ - pq = ecs_get(world, pipeline, EcsPipelineQuery); + /* Mark entities that are used as component/pair ids. When a tracked + * entity is deleted, cleanup policies are applied so that the store + * won't contain any tables with deleted ids. */ - /* Pipeline has changed, reset position in pipeline */ - ecs_iter_t it; - ecs_pipeline_reset_iter(world, pq, &it, &op, &op_last); - op --; - } + /* Flag for OnDelete policies */ + flecs_add_flag(world, rel, ECS_FLAG_OBSERVED_ID); + if (obj) { + /* Flag for OnDeleteObject policies */ + flecs_add_flag(world, obj, ECS_FLAG_OBSERVED_OBJECT); + if (ecs_has_id(world, rel, EcsAcyclic)) { + /* Flag used to determine if object should be traversed when + * propagating events or with super/subset queries */ + flecs_add_flag(world, obj, ECS_FLAG_OBSERVED_ACYCLIC); } } - if (world->measure_frame_time) { - world->stats.system_time_total += (float)ecs_time_measure(&start); - } + if (ecs_should_log_1()) { + char *id_str = ecs_id_str(world, id); + ecs_dbg_1("#[green]id#[normal] %s #[green]created", id_str); + ecs_os_free(id_str); + } + + return idr; } -/* -- Public functions -- */ -void ecs_set_threads( +/* Cleanup id index */ +static +bool free_id_record( ecs_world_t *world, - int32_t threads) + ecs_id_t id, + ecs_id_record_t *idr) { - ecs_assert(threads <= 1 || ecs_os_has_threading(), ECS_MISSING_OS_API, NULL); + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_poly_assert(world, ecs_world_t); + (void)id; - int32_t stage_count = ecs_get_stage_count(world); + /* Force the empty table administration to be consistent if the non-empty + * list of the id record has elements */ + if (ecs_table_cache_count(&idr->cache)) { + ecs_force_aperiodic(world); + } - if (stage_count != threads) { - /* Stop existing threads */ - if (stage_count > 1) { - if (ecs_stop_threads(world)) { - ecs_os_cond_free(world->worker_cond); - ecs_os_cond_free(world->sync_cond); - ecs_os_mutex_free(world->sync_mutex); - } - } + /* If there are still tables in the non-empty list they're really not empty. + * We can't free the record yet. */ + if (ecs_table_cache_count(&idr->cache)) { + return false; + } - /* Start threads if number of threads > 1 */ - if (threads > 1) { - world->worker_cond = ecs_os_cond_new(); - world->sync_cond = ecs_os_cond_new(); - world->sync_mutex = ecs_os_mutex_new(); - start_workers(world, threads); + /* If id record contains no more empty tables, free it */ + if (ecs_table_cache_empty_count(&idr->cache) == 0) { + if (ecs_should_log_1()) { + char *id_str = ecs_id_str(world, id); + ecs_dbg_1("#[green]id#[normal] %s #[red]deleted", id_str); + ecs_os_free(id_str); } + + ecs_table_cache_fini(&idr->cache); + flecs_name_index_free(idr->name_index); + ecs_os_free(idr); + return true; } -} -#endif + /* Delete empty tables */ + ecs_table_cache_iter_t cache_it; + flecs_table_cache_empty_iter(&idr->cache, &cache_it); + const ecs_table_record_t *tr; + while ((tr = flecs_table_cache_next(&cache_it, ecs_table_record_t))) { + if (!flecs_table_release(world, tr->hdr.table)) { + /* Releasing the table did not free it, which means that something + * is keeping the table alive. Cleanup of the id record will happen + * when the last reference(s) to the table are released */ + return false; + } + } -#ifdef FLECS_PIPELINE + /* If all tables were deleted for this id record, the last deleted table + * should have removed the record from the world. */ + ecs_assert(flecs_get_id_record(world, id) == NULL, + ECS_INTERNAL_ERROR, NULL); -static ECS_DTOR(EcsPipelineQuery, ptr, { - ecs_vector_free(ptr->ops); -}) + return true; +} static -int compare_entity( - ecs_entity_t e1, - const void *ptr1, - ecs_entity_t e2, - const void *ptr2) +void fini_id_index( + ecs_world_t *world) { - (void)ptr1; - (void)ptr2; - return (e1 > e2) - (e1 < e2); + ecs_map_iter_t it = ecs_map_iter(&world->id_index); + ecs_id_record_t *idr; + ecs_map_key_t key; + while ((idr = ecs_map_next_ptr(&it, ecs_id_record_t*, &key))) { + free_id_record(world, key, idr); + } + + ecs_map_fini(&world->id_index); + flecs_sparse_free(world->pending_tables); + flecs_sparse_free(world->pending_buffer); } +/* Cleanup misc structures */ static -uint64_t group_by_phase( - ecs_world_t *world, - ecs_type_t type, - ecs_entity_t pipeline, - void *ctx) +void fini_misc( + ecs_world_t *world) { - (void)ctx; + ecs_map_fini(&world->type_handles); + ecs_vector_free(world->fini_tasks); +} + +/* The destroyer of worlds */ +int ecs_fini( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); + ecs_assert(!world->is_fini, ECS_INVALID_OPERATION, NULL); + + ecs_trace("#[bold]shutting down world"); + ecs_log_push(); + + world->is_fini = true; + + /* Operations invoked during UnSet/OnRemove/destructors are deferred and + * will be discarded after world cleanup */ + ecs_defer_begin(world); + + /* Run UnSet/OnRemove actions for components while the store is still + * unmodified by cleanup. */ + fini_unset_tables(world); - const EcsType *pt = ecs_get(world, pipeline, EcsType); - ecs_assert(pt != NULL, ECS_INTERNAL_ERROR, NULL); + /* Run fini actions (simple callbacks ran when world is deleted) before + * destroying the storage */ + fini_actions(world); - /* Find tag in system that belongs to pipeline */ - ecs_entity_t *sys_comps = ecs_vector_first(type, ecs_entity_t); - int32_t c, t, count = ecs_vector_count(type); + /* This will destroy all entities and components. After this point no more + * user code is executed. */ + fini_store(world); + + /* Purge deferred operations from the queue. This discards operations but + * makes sure that any resources in the queue are freed */ + flecs_defer_purge(world, &world->stage); + + /* Entity index is kept alive until this point so that user code can do + * validity checks on entity ids, even though after store cleanup the index + * will be empty, so all entity ids are invalid. */ + flecs_sparse_fini(&world->store.entity_index); - ecs_type_t pipeline_type = NULL; - if (pt->normalized) { - pipeline_type = pt->normalized->type; + if (world->locking_enabled) { + ecs_os_mutex_free(world->mutex); } - if (!pipeline_type) { - return 0; - } + ecs_trace("table store deinitialized"); - ecs_entity_t *tags = ecs_vector_first(pipeline_type, ecs_entity_t); - int32_t tag_count = ecs_vector_count(pipeline_type); + fini_stages(world); - ecs_entity_t result = 0; + fini_component_lifecycle(world); - for (c = 0; c < count; c ++) { - ecs_entity_t comp = sys_comps[c]; - for (t = 0; t < tag_count; t ++) { - if (comp == tags[t]) { - result = comp; - break; - } - } - if (result) { - break; - } - } + fini_queries(world); - ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result < INT_MAX, ECS_INTERNAL_ERROR, NULL); + fini_observers(world); - return result; -} + fini_id_index(world); -typedef enum ComponentWriteState { - NotWritten = 0, - WriteToMain, - WriteToStage -} ComponentWriteState; + flecs_observable_fini(&world->observable); -typedef struct write_state_t { - ecs_map_t *components; - bool wildcard; -} write_state_t; + flecs_sparse_free(world->triggers); -static -int32_t get_write_state( - ecs_map_t *write_state, - ecs_entity_t component) + flecs_name_index_fini(&world->aliases); + flecs_name_index_fini(&world->symbols); + + fini_misc(world); + + ecs_os_enable_high_timer_resolution(false); + + /* End of the world */ + ecs_poly_free(world, ecs_world_t); + + ecs_os_fini(); + + ecs_trace("world destroyed, bye!"); + ecs_log_pop(); + + return 0; +} + +bool ecs_is_fini( + const ecs_world_t *world) { - int32_t *ptr = ecs_map_get(write_state, int32_t, component); - if (ptr) { - return *ptr; - } else { - return 0; - } + ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL); + world = ecs_get_world(world); + return world->is_fini; } -static -void set_write_state( - write_state_t *write_state, - ecs_entity_t component, - int32_t value) +void ecs_dim( + ecs_world_t *world, + int32_t entity_count) { - if (component == EcsWildcard) { - ecs_assert(value == WriteToStage, ECS_INTERNAL_ERROR, NULL); - write_state->wildcard = true; - } else { - ecs_map_set(write_state->components, component, &value); - } + ecs_poly_assert(world, ecs_world_t); + ecs_eis_set_size(world, entity_count + ECS_HI_COMPONENT_ID); } -static -void reset_write_state( - write_state_t *write_state) +void flecs_eval_component_monitors( + ecs_world_t *world) { - ecs_map_clear(write_state->components); - write_state->wildcard = false; + ecs_poly_assert(world, ecs_world_t); + flecs_process_pending_tables(world); + eval_component_monitor(world); } -static -int32_t get_any_write_state( - write_state_t *write_state) +void ecs_measure_frame_time( + ecs_world_t *world, + bool enable) { - if (write_state->wildcard) { - return WriteToStage; - } + ecs_poly_assert(world, ecs_world_t); + ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); - ecs_map_iter_t it = ecs_map_iter(write_state->components); - int32_t *elem; - while ((elem = ecs_map_next(&it, int32_t, NULL))) { - if (*elem == WriteToStage) { - return WriteToStage; - } + if (world->stats.target_fps == 0.0f || enable) { + world->measure_frame_time = enable; } - - return 0; +error: + return; } -static -bool check_term_component( - ecs_term_t *term, - bool is_active, - ecs_entity_t component, - write_state_t *write_state) +void ecs_measure_system_time( + ecs_world_t *world, + bool enable) { - int32_t state = get_write_state(write_state->components, component); - - ecs_term_id_t *subj = &term->subj; - - if ((subj->set.mask & EcsSelf) && subj->entity == EcsThis && term->oper != EcsNot) { - switch(term->inout) { - case EcsInOutFilter: - /* Ignore terms that aren't read/written */ - break; - case EcsInOutDefault: - case EcsInOut: - case EcsIn: - if (state == WriteToStage || write_state->wildcard) { - return true; - } - // fall through - case EcsOut: - if (is_active && term->inout != EcsIn) { - set_write_state(write_state, component, WriteToMain); - } - }; - - } else if (!subj->entity || term->oper == EcsNot) { - bool needs_merge = false; - - switch(term->inout) { - case EcsInOutDefault: - case EcsIn: - case EcsInOut: - if (state == WriteToStage) { - needs_merge = true; - } - if (component == EcsWildcard) { - if (get_any_write_state(write_state) == WriteToStage) { - needs_merge = true; - } - } - break; - default: - break; - }; - - switch(term->inout) { - case EcsInOutDefault: - if ((!(subj->set.mask & EcsSelf) || (subj->entity != EcsThis)) && (subj->set.mask != EcsNothing)) { - /* Default inout behavior is [inout] for This terms, and [in] - * for terms that match other entities */ - break; - } - // fall through - case EcsInOut: - case EcsOut: - if (is_active) { - set_write_state(write_state, component, WriteToStage); - } - break; - default: - break; - }; + ecs_poly_assert(world, ecs_world_t); + ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); + world->measure_system_time = enable; +error: + return; +} - if (needs_merge) { - return true; - } - } +void ecs_set_target_fps( + ecs_world_t *world, + FLECS_FLOAT fps) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); - return false; + ecs_measure_frame_time(world, true); + world->stats.target_fps = fps; + ecs_os_enable_high_timer_resolution(fps >= 60.0f); +error: + return; } -static -bool check_term( - ecs_term_t *term, - bool is_active, - write_state_t *write_state) +void* ecs_get_context( + const ecs_world_t *world) { - if (term->oper != EcsOr) { - return check_term_component( - term, is_active, term->id, write_state); - } - - return false; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + world = ecs_get_world(world); + return world->context; +error: + return NULL; } -static -bool check_terms( - ecs_filter_t *filter, - bool is_active, - write_state_t *ws) +void ecs_set_context( + ecs_world_t *world, + void *context) { - bool needs_merge = false; - ecs_term_t *terms = filter->terms; - int32_t t, term_count = filter->term_count; + ecs_poly_assert(world, ecs_world_t); + world->context = context; +} - /* Check This terms first. This way if a term indicating writing to a stage - * was added before the term, it won't cause merging. */ - for (t = 0; t < term_count; t ++) { - ecs_term_t *term = &terms[t]; - if (term->subj.entity == EcsThis) { - needs_merge |= check_term(term, is_active, ws); - } - } +void ecs_set_entity_range( + ecs_world_t *world, + ecs_entity_t id_start, + ecs_entity_t id_end) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_check(!id_end || id_end > id_start, ECS_INVALID_PARAMETER, NULL); + ecs_check(!id_end || id_end > world->stats.last_id, + ECS_INVALID_PARAMETER, NULL); - /* Now check staged terms */ - for (t = 0; t < term_count; t ++) { - ecs_term_t *term = &terms[t]; - if (term->subj.entity != EcsThis) { - needs_merge |= check_term(term, is_active, ws); - } + if (world->stats.last_id < id_start) { + world->stats.last_id = id_start - 1; } - return needs_merge; + world->stats.min_id = id_start; + world->stats.max_id = id_end; +error: + return; } -static -bool build_pipeline( +bool ecs_enable_range_check( ecs_world_t *world, - ecs_entity_t pipeline, - EcsPipelineQuery *pq) + bool enable) { - (void)pipeline; + ecs_poly_assert(world, ecs_world_t); + bool old_value = world->range_check_enabled; + world->range_check_enabled = enable; + return old_value; +} - ecs_query_iter(world, pq->query); +void ecs_set_entity_generation( + ecs_world_t *world, + ecs_entity_t entity_with_generation) +{ + flecs_sparse_set_generation( + &world->store.entity_index, entity_with_generation); +} - if (pq->match_count == pq->query->match_count) { - /* No need to rebuild the pipeline */ - return false; - } - - world->stats.pipeline_build_count_total ++; - pq->rebuild_count ++; - - write_state_t ws = { - .components = ecs_map_new(int32_t, ECS_HI_COMPONENT_ID), - .wildcard = false - }; +int32_t ecs_get_threads( + ecs_world_t *world) +{ + return ecs_vector_count(world->worker_stages); +} - ecs_pipeline_op_t *op = NULL; - ecs_vector_t *ops = NULL; - ecs_query_t *query = pq->build_query; +bool ecs_enable_locking( + ecs_world_t *world, + bool enable) +{ + ecs_poly_assert(world, ecs_world_t); - if (pq->ops) { - ecs_vector_free(pq->ops); + if (enable) { + if (!world->locking_enabled) { + world->mutex = ecs_os_mutex_new(); + world->thr_sync = ecs_os_mutex_new(); + world->thr_cond = ecs_os_cond_new(); + } + } else { + if (world->locking_enabled) { + ecs_os_mutex_free(world->mutex); + ecs_os_mutex_free(world->thr_sync); + ecs_os_cond_free(world->thr_cond); + } } - bool multi_threaded = false; - bool no_staging = false; - bool first = true; - - /* Iterate systems in pipeline, add ops for running / merging */ - ecs_iter_t it = ecs_query_iter(world, query); - while (ecs_query_next(&it)) { - EcsSystem *sys = ecs_term(&it, EcsSystem, 1); + bool old = world->locking_enabled; + world->locking_enabled = enable; + return old; +} - int i; - for (i = 0; i < it.count; i ++) { - ecs_query_t *q = sys[i].query; - if (!q) { - continue; - } +void ecs_lock( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); + ecs_os_mutex_lock(world->mutex); +} - bool needs_merge = false; - bool is_active = !ecs_has_id( - world, it.entities[i], EcsInactive); - needs_merge = check_terms(&q->filter, is_active, &ws); +void ecs_unlock( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); + ecs_os_mutex_unlock(world->mutex); +} - if (is_active) { - if (first) { - multi_threaded = sys[i].multi_threaded; - no_staging = sys[i].no_staging; - first = false; - } +void ecs_begin_wait( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); + ecs_os_mutex_lock(world->thr_sync); + ecs_os_cond_wait(world->thr_cond, world->thr_sync); +} - if (sys[i].multi_threaded != multi_threaded) { - needs_merge = true; - multi_threaded = sys[i].multi_threaded; - } - if (sys[i].no_staging != no_staging) { - needs_merge = true; - no_staging = sys[i].no_staging; - } - } +void ecs_end_wait( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); + ecs_os_mutex_unlock(world->thr_sync); +} - if (needs_merge) { - /* After merge all components will be merged, so reset state */ - reset_write_state(&ws); - op = NULL; +const ecs_type_info_t* flecs_get_type_info( + const ecs_world_t *world, + ecs_entity_t component) +{ + ecs_poly_assert(world, ecs_world_t); - /* Re-evaluate columns to set write flags if system is active. - * If system is inactive, it can't write anything and so it - * should not insert unnecessary merges. */ - needs_merge = false; - if (is_active) { - needs_merge = check_terms(&q->filter, true, &ws); - } + ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!(component & ECS_ROLE_MASK), ECS_INTERNAL_ERROR, NULL); - /* The component states were just reset, so if we conclude that - * another merge is needed something is wrong. */ - ecs_assert(needs_merge == false, ECS_INTERNAL_ERROR, NULL); - } + return flecs_sparse_get(world->type_info, ecs_type_info_t, component); +} - if (!op) { - op = ecs_vector_add(&ops, ecs_pipeline_op_t); - op->count = 0; - op->multi_threaded = false; - op->no_staging = false; - } +ecs_type_info_t* flecs_ensure_type_info( + ecs_world_t *world, + ecs_entity_t component) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL); - /* Don't increase count for inactive systems, as they are ignored by - * the query used to run the pipeline. */ - if (is_active) { - if (!op->count) { - op->multi_threaded = multi_threaded; - op->no_staging = no_staging; - } - op->count ++; - } - } + const ecs_type_info_t *ti = flecs_get_type_info(world, component); + ecs_type_info_t *ti_mut = NULL; + if (!ti) { + ti_mut = flecs_sparse_ensure( + world->type_info, ecs_type_info_t, component); + ecs_assert(ti_mut != NULL, ECS_INTERNAL_ERROR, NULL); + } else { + ti_mut = (ecs_type_info_t*)ti; } - ecs_map_free(ws.components); + return ti_mut; +} - /* Find the system ran last this frame (helps workers reset iter) */ - ecs_entity_t last_system = 0; - op = ecs_vector_first(ops, ecs_pipeline_op_t); - int32_t i, ran_since_merge = 0, op_index = 0; +void flecs_init_type_info( + ecs_world_t *world, + ecs_entity_t component, + ecs_size_t size, + ecs_size_t alignment) +{ + ecs_type_info_t *ti = flecs_ensure_type_info(world, component); + ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ti->size == 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ti->alignment == 0, ECS_INTERNAL_ERROR, NULL); + ti->size = size; + ti->alignment = alignment; +} - ecs_assert(op != NULL, ECS_INTERNAL_ERROR, NULL); +static +FLECS_FLOAT insert_sleep( + ecs_world_t *world, + ecs_time_t *stop) +{ + ecs_poly_assert(world, ecs_world_t); - /* Add schedule to debug tracing */ - ecs_dbg("#[green]pipeline#[reset] rebuild:"); - ecs_log_push_1(); + ecs_time_t start = *stop; + FLECS_FLOAT delta_time = (FLECS_FLOAT)ecs_time_measure(stop); - ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", - op->multi_threaded, !op->no_staging); - ecs_log_push_1(); - - it = ecs_query_iter(world, pq->query); - while (ecs_query_next(&it)) { - EcsSystem *sys = ecs_term(&it, EcsSystem, 1); - for (i = 0; i < it.count; i ++) { - if (ecs_should_log_1()) { - char *path = ecs_get_fullpath(world, it.entities[i]); - ecs_dbg("#[green]system#[reset] %s", path); - ecs_os_free(path); - } + if (world->stats.target_fps == (FLECS_FLOAT)0.0) { + return delta_time; + } - ran_since_merge ++; - if (ran_since_merge == op[op_index].count) { - ecs_dbg("#[magenta]merge#[reset]"); - ecs_log_pop_1(); - ran_since_merge = 0; - op_index ++; - if (op_index < ecs_vector_count(ops)) { - ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", - op[op_index].multi_threaded, !op[op_index].no_staging); - } - ecs_log_push_1(); - } + FLECS_FLOAT target_delta_time = + ((FLECS_FLOAT)1.0 / (FLECS_FLOAT)world->stats.target_fps); - if (sys[i].last_frame == (world->stats.frame_count_total + 1)) { - last_system = it.entities[i]; + /* Calculate the time we need to sleep by taking the measured delta from the + * previous frame, and subtracting it from target_delta_time. */ + FLECS_FLOAT sleep = target_delta_time - delta_time; - /* Can't break from loop yet. It's possible that previously - * inactive systems that ran before the last ran system are now - * active. */ - } - } - } + /* Pick a sleep interval that is 4 times smaller than the time one frame + * should take. */ + FLECS_FLOAT sleep_time = sleep / (FLECS_FLOAT)4.0; - ecs_log_pop_1(); - ecs_log_pop_1(); + do { + /* Only call sleep when sleep_time is not 0. On some platforms, even + * a sleep with a timeout of 0 can cause stutter. */ + if (sleep_time != 0) { + ecs_sleepf((double)sleep_time); + } - /* Force sort of query as this could increase the match_count */ - pq->match_count = pq->query->match_count; - pq->ops = ops; - pq->last_system = last_system; + ecs_time_t now = start; + delta_time = (FLECS_FLOAT)ecs_time_measure(&now); + } while ((target_delta_time - delta_time) > + (sleep_time / (FLECS_FLOAT)2.0)); - return true; + return delta_time; } -int32_t ecs_pipeline_reset_iter( +static +FLECS_FLOAT start_measure_frame( ecs_world_t *world, - const EcsPipelineQuery *pq, - ecs_iter_t *iter_out, - ecs_pipeline_op_t **op_out, - ecs_pipeline_op_t **last_op_out) + FLECS_FLOAT user_delta_time) { - ecs_pipeline_op_t *op = ecs_vector_first(pq->ops, ecs_pipeline_op_t); - int32_t i, ran_since_merge = 0, op_index = 0; + ecs_poly_assert(world, ecs_world_t); - if (!pq->last_system) { - /* It's possible that all systems that were ran were removed entirely - * from the pipeline (they could have been deleted or disabled). In that - * case (which should be very rare) the pipeline can't make assumptions - * about where to continue, so end frame. */ - return -1; - } + FLECS_FLOAT delta_time = 0; - /* Move iterator to last ran system */ - *iter_out = ecs_query_iter(world, pq->query); - while (ecs_query_next(iter_out)) { - for (i = 0; i < iter_out->count; i ++) { - ran_since_merge ++; - if (ran_since_merge == op[op_index].count) { - ran_since_merge = 0; - op_index ++; - } + if (world->measure_frame_time || (user_delta_time == 0)) { + ecs_time_t t = world->frame_start_time; + do { + if (world->frame_start_time.nanosec || world->frame_start_time.sec){ + delta_time = insert_sleep(world, &t); - if (iter_out->entities[i] == pq->last_system) { - *op_out = &op[op_index]; - *last_op_out = ecs_vector_last(pq->ops, ecs_pipeline_op_t); - return i; + ecs_time_measure(&t); + } else { + ecs_time_measure(&t); + if (world->stats.target_fps != 0) { + delta_time = (FLECS_FLOAT)1.0 / world->stats.target_fps; + } else { + /* Best guess */ + delta_time = (FLECS_FLOAT)1.0 / (FLECS_FLOAT)60.0; + } } - } - } + + /* Keep trying while delta_time is zero */ + } while (delta_time == 0); - ecs_abort(ECS_INTERNAL_ERROR, NULL); + world->frame_start_time = t; - return -1; + /* Keep track of total time passed in world */ + world->stats.world_time_total_raw += (FLECS_FLOAT)delta_time; + } + + return (FLECS_FLOAT)delta_time; } -bool ecs_pipeline_update( - ecs_world_t *world, - ecs_entity_t pipeline, - bool start_of_frame) +static +void stop_measure_frame( + ecs_world_t* world) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); - ecs_assert(pipeline != 0, ECS_INTERNAL_ERROR, NULL); + ecs_poly_assert(world, ecs_world_t); - /* If any entity mutations happened that could have affected query matching - * notify appropriate queries so caches are up to date. This includes the - * pipeline query. */ - if (start_of_frame) { - ecs_force_aperiodic(world); + if (world->measure_frame_time) { + ecs_time_t t = world->frame_start_time; + world->stats.frame_time_total += (FLECS_FLOAT)ecs_time_measure(&t); } - - bool added = false; - EcsPipelineQuery *pq = ecs_get_mut(world, pipeline, EcsPipelineQuery, &added); - ecs_assert(added == false, ECS_INTERNAL_ERROR, NULL); - ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL); - - return build_pipeline(world, pipeline, pq); } -void ecs_run_pipeline( +FLECS_FLOAT ecs_frame_begin( ecs_world_t *world, - ecs_entity_t pipeline, - FLECS_FLOAT delta_time) + FLECS_FLOAT user_delta_time) { - ecs_assert(world != NULL, ECS_INVALID_OPERATION, NULL); - - if (!pipeline) { - pipeline = world->pipeline; - } - - ecs_assert(pipeline != 0, ECS_INVALID_PARAMETER, NULL); - - /* If the world is passed to ecs_run_pipeline, the function will take care - * of staging, so the world should not be in staged mode when called. */ - if (ecs_poly_is(world, ecs_world_t)) { - ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); - - /* Forward to worker_progress. This function handles staging, threading - * and synchronization across workers. */ - ecs_workers_progress(world, pipeline, delta_time); - return; + ecs_poly_assert(world, ecs_world_t); + ecs_check(world->is_readonly == false, ECS_INVALID_OPERATION, NULL); + ecs_check(user_delta_time != 0 || ecs_os_has_time(), + ECS_MISSING_OS_API, "get_time"); - /* If a stage is passed, the function could be ran from a worker thread. In - * that case the main thread should manage staging, and staging should be - * enabled. */ - } else { - ecs_poly_assert(world, ecs_stage_t); + if (world->locking_enabled) { + ecs_lock(world); } - ecs_stage_t *stage = flecs_stage_from_world(&world); - - const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); - ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_vector_t *ops = pq->ops; - ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); - ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); - int32_t ran_since_merge = 0; - - int32_t stage_index = ecs_get_stage_id(stage->thread_ctx); - int32_t stage_count = ecs_get_stage_count(world); - - ecs_worker_begin(stage->thread_ctx); - - ecs_iter_t it = ecs_query_iter(world, pq->query); - while (ecs_query_next(&it)) { - EcsSystem *sys = ecs_term(&it, EcsSystem, 1); + /* Start measuring total frame time */ + FLECS_FLOAT delta_time = start_measure_frame(world, user_delta_time); + if (user_delta_time == 0) { + user_delta_time = delta_time; + } - int32_t i; - for(i = 0; i < it.count; i ++) { - ecs_entity_t e = it.entities[i]; + world->stats.delta_time_raw = user_delta_time; + world->stats.delta_time = user_delta_time * world->stats.time_scale; - if (!stage_index) { - ecs_dbg_3("pipeline: run system %s", ecs_get_name(world, e)); - } + /* Keep track of total scaled time passed in world */ + world->stats.world_time_total += world->stats.delta_time; - if (!stage_index || op->multi_threaded) { - ecs_stage_t *s = NULL; - if (!op->no_staging) { - s = stage; - } + ecs_force_aperiodic(world); - ecs_run_intern(world, s, e, &sys[i], stage_index, - stage_count, delta_time, 0, 0, NULL); - } + return world->stats.delta_time; +error: + return (FLECS_FLOAT)0; +} - sys[i].last_frame = world->stats.frame_count_total + 1; +void ecs_frame_end( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_check(world->is_readonly == false, ECS_INVALID_OPERATION, NULL); - ran_since_merge ++; - world->stats.systems_ran_frame ++; + world->stats.frame_count_total ++; - if (op != op_last && ran_since_merge == op->count) { - ran_since_merge = 0; + ecs_vector_each(world->worker_stages, ecs_stage_t, stage, { + flecs_stage_merge_post_frame(world, stage); + }); - if (!stage_index) { - ecs_dbg_3("merge"); - } + if (world->locking_enabled) { + ecs_unlock(world); - /* If the set of matched systems changed as a result of the - * merge, we have to reset the iterator and move it to our - * current position (system). If there are a lot of systems - * in the pipeline this can be an expensive operation, but - * should happen infrequently. */ - i = ecs_worker_sync(world, pq, &it, i, &op, &op_last); - sys = ecs_term(&it, EcsSystem, 1); - } - } + ecs_os_mutex_lock(world->thr_sync); + ecs_os_cond_broadcast(world->thr_cond); + ecs_os_mutex_unlock(world->thr_sync); } - ecs_worker_end(stage->thread_ctx); + stop_measure_frame(world); +error: + return; } -static -void add_pipeline_tags_to_sig( +const ecs_world_info_t* ecs_get_world_info( + const ecs_world_t *world) +{ + world = ecs_get_world(world); + return &world->stats; +} + +void flecs_notify_queries( ecs_world_t *world, - ecs_term_t *terms, - ecs_type_t type) + ecs_query_event_t *event) { - (void)world; - - int32_t i, count = ecs_vector_count(type); - ecs_entity_t *entities = ecs_vector_first(type, ecs_entity_t); + ecs_poly_assert(world, ecs_world_t); + int32_t i, count = flecs_sparse_count(world->queries); for (i = 0; i < count; i ++) { - terms[i] = (ecs_term_t){ - .inout = EcsIn, - .oper = EcsOr, - .pred.entity = entities[i], - .subj = { - .entity = EcsThis, - .set.mask = EcsSelf | EcsSuperSet - } - }; - } + ecs_query_t *query = flecs_sparse_get_dense( + world->queries, ecs_query_t, i); + if (query->flags & EcsQueryIsSubquery) { + continue; + } + + flecs_query_notify(world, query, event); + } } -static -ecs_query_t* build_pipeline_query( +void flecs_delete_table( ecs_world_t *world, - ecs_entity_t pipeline, - const char *name, - bool not_inactive) + ecs_table_t *table) { - const EcsType *type_ptr = ecs_get(world, pipeline, EcsType); - ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_type_t type = NULL; - if (type_ptr->normalized) { - type = type_ptr->normalized->type; - } - - int32_t type_count = ecs_vector_count(type); - int32_t term_count = 1; + ecs_poly_assert(world, ecs_world_t); + flecs_table_release(world, table); +} - if (not_inactive) { - term_count ++; - } +/** Walk over tables that had a state change which requires bookkeeping */ +void flecs_process_pending_tables( + const ecs_world_t *world_r) +{ + ecs_poly_assert(world_r, ecs_world_t); - ecs_term_t *terms = ecs_os_malloc( - (type_count + term_count) * ECS_SIZEOF(ecs_term_t)); + /* We can't update the administration while in readonly mode, but we can + * ensure that when this function is called there are no pending events. */ + if (world_r->is_readonly) { + ecs_assert(flecs_sparse_count(world_r->pending_tables) == 0, + ECS_INTERNAL_ERROR, NULL); + return; + } - terms[0] = (ecs_term_t){ - .inout = EcsIn, - .oper = EcsAnd, - .pred.entity = ecs_id(EcsSystem), - .subj = { - .entity = EcsThis, - .set.mask = EcsSelf | EcsSuperSet - } - }; + /* Safe to cast, world is not readonly */ + ecs_world_t *world = (ecs_world_t*)world_r; + + /* If pending buffer is NULL there already is a stackframe that's iterating + * the table list. This can happen when a trigger for a table event results + * in a mutation that causes another table to change state. A typical + * example of this is a system that becomes active/inactive as the result of + * a query (and as a result, its matched tables) becoming empty/non empty */ + if (!world->pending_buffer) { + return; + } - if (not_inactive) { - terms[1] = (ecs_term_t){ - .inout = EcsIn, - .oper = EcsNot, - .pred.entity = EcsInactive, - .subj = { - .entity = EcsThis, - .set.mask = EcsSelf | EcsSuperSet - } - }; + /* Swap buffer. The logic could in theory have been implemented with a + * single sparse set, but that would've complicated (and slowed down) the + * iteration. Additionally, by using a double buffer approach we can still + * keep most of the original ordering of events intact, which is desirable + * as it means that the ordering of tables in the internal datastructures is + * more predictable. */ + int32_t i, count = flecs_sparse_count(world->pending_tables); + if (!count) { + return; } - add_pipeline_tags_to_sig(world, &terms[term_count], type); + do { + ecs_sparse_t *pending_tables = world->pending_tables; + world->pending_tables = world->pending_buffer; + world->pending_buffer = NULL; - ecs_query_t *result = ecs_query_init(world, &(ecs_query_desc_t){ - .filter = { - .name = name, - .terms_buffer = terms, - .terms_buffer_count = term_count + type_count - }, - .order_by = compare_entity, - .group_by = group_by_phase, - .group_by_id = pipeline - }); + for (i = 0; i < count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense( + pending_tables, ecs_table_t*, i)[0]; + if (!table->id) { + /* Table is being deleted, ignore empty events */ + continue; + } - ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); + /* For each id in the table, add it to the empty/non empty list + * based on its current state */ + if (flecs_table_records_update_empty(table)) { + /* Only emit an event when there was a change in the + * administration. It is possible that a table ended up in the + * pending_tables list by going from empty->non-empty, but then + * became empty again. By the time we run this code, no changes + * in the administration would actually be made. */ + ecs_ids_t ids = { + .array = ecs_vector_first(table->type, ecs_id_t), + .count = ecs_vector_count(table->type) + }; - ecs_os_free(terms); + ecs_emit(world, &(ecs_event_desc_t) { + .event = ecs_table_count(table) + ? EcsOnTableFill + : EcsOnTableEmpty + , + .table = table, + .ids = &ids, + .observable = world, + .table_event = true + }); + } + } + flecs_sparse_clear(pending_tables); - return result; + world->pending_buffer = pending_tables; + } while ((count = flecs_sparse_count(world->pending_tables))); } -static -void OnUpdatePipeline( - ecs_iter_t *it) +void flecs_table_set_empty( + ecs_world_t *world, + ecs_table_t *table) { - ecs_world_t *world = it->world; - ecs_entity_t *entities = it->entities; - - int32_t i; - for (i = it->count - 1; i >= 0; i --) { - ecs_entity_t pipeline = entities[i]; - - ecs_trace("#[green]pipeline#[reset] %s created", - ecs_get_name(world, pipeline)); - ecs_log_push(); - - /* Build signature for pipeline query that matches EcsSystems, has the - * pipeline phases as OR columns, and ignores systems with EcsInactive. - * Note that EcsDisabled is automatically ignored - * by the regular query matching */ - ecs_query_t *query = build_pipeline_query( - world, pipeline, "BuiltinPipelineQuery", true); - ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); - - /* Build signature for pipeline build query. The build query includes - * systems that are inactive, as an inactive system may become active as - * a result of another system, and as a result the correct merge - * operations need to be put in place. */ - ecs_query_t *build_query = build_pipeline_query( - world, pipeline, "BuiltinPipelineBuildQuery", false); - ecs_assert(build_query != NULL, ECS_INTERNAL_ERROR, NULL); - - bool added = false; - EcsPipelineQuery *pq = ecs_get_mut( - world, pipeline, EcsPipelineQuery, &added); - ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - - if (added) { - /* Should not modify pipeline after it has been used */ - ecs_assert(pq->ops == NULL, ECS_INVALID_OPERATION, NULL); - - if (pq->query) { - ecs_query_fini(pq->query); - } - if (pq->build_query) { - ecs_query_fini(pq->build_query); - } - } + ecs_poly_assert(world, ecs_world_t); + ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); - pq->query = query; - pq->build_query = build_query; - pq->match_count = -1; - pq->ops = NULL; - pq->last_system = 0; + flecs_sparse_set_generation(world->pending_tables, (uint32_t)table->id); + flecs_sparse_ensure(world->pending_tables, ecs_table_t*, + (uint32_t)table->id)[0] = table; +} - ecs_log_pop(); +ecs_id_record_t* flecs_ensure_id_record( + ecs_world_t *world, + ecs_id_t id) +{ + ecs_id_record_t **idr_ptr = ecs_map_ensure(&world->id_index, + ecs_id_record_t*, ecs_strip_generation(id)); + ecs_id_record_t *idr = idr_ptr[0]; + if (!idr) { + idr_ptr[0] = idr = new_id_record(world, id); } + + return idr; } -/* -- Public API -- */ +ecs_id_record_t* flecs_get_id_record( + const ecs_world_t *world, + ecs_id_t id) +{ + return ecs_map_get_ptr(&world->id_index, ecs_id_record_t*, + ecs_strip_generation(id)); +} -bool ecs_progress( +ecs_hashmap_t* flecs_ensure_id_name_index( ecs_world_t *world, - FLECS_FLOAT user_delta_time) + ecs_id_t id) { - float delta_time = ecs_frame_begin(world, user_delta_time); - - ecs_dbg_3("#[normal]begin progress(dt = %.2f)", (double)delta_time); + ecs_id_record_t *idr = flecs_get_id_record(world, id); + ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_run_pipeline(world, 0, delta_time); + ecs_hashmap_t *map = idr->name_index; + if (!map) { + map = idr->name_index = flecs_name_index_new(); + } - ecs_dbg_3("#[normal]end progress"); + return map; +} - ecs_frame_end(world); +ecs_hashmap_t* flecs_get_id_name_index( + const ecs_world_t *world, + ecs_id_t id) +{ + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { + return NULL; + } - return !world->should_quit; + return idr->name_index; } -void ecs_set_time_scale( - ecs_world_t *world, - FLECS_FLOAT scale) +ecs_table_record_t* flecs_get_table_record( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_id_t id) { - world->stats.time_scale = scale; + ecs_id_record_t* idr = flecs_get_id_record(world, id); + if (!idr) { + return NULL; + } + + return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table); } -void ecs_reset_clock( - ecs_world_t *world) +void flecs_remove_id_record( + ecs_world_t *world, + ecs_id_t id, + ecs_id_record_t *idr) { - world->stats.world_time_total = 0; - world->stats.world_time_total_raw = 0; + /* Free id record resources */ + if (free_id_record(world, id, idr)) { + /* Remove record from world index */ + ecs_map_remove(&world->id_index, ecs_strip_generation(id)); + } } -void ecs_deactivate_systems( - ecs_world_t *world) +void flecs_clear_id_record( + ecs_world_t *world, + ecs_id_t id, + ecs_id_record_t *idr) { - ecs_assert(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); - - ecs_entity_t pipeline = world->pipeline; - const EcsPipelineQuery *pq = ecs_get( world, pipeline, EcsPipelineQuery); - ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - - /* Iterate over all systems, add EcsInvalid tag if queries aren't matched - * with any tables */ - ecs_iter_t it = ecs_query_iter(world, pq->build_query); + if (world->is_fini) { + return; + } - /* Make sure that we defer adding the inactive tags until after iterating - * the query */ - flecs_defer_none(world, &world->stage); + ecs_table_cache_fini_delete_all(world, &idr->cache); - while( ecs_query_next(&it)) { - EcsSystem *sys = ecs_term(&it, EcsSystem, 1); + flecs_remove_id_record(world, id, idr); +} - int32_t i; - for (i = 0; i < it.count; i ++) { - ecs_query_t *query = sys[i].query; - if (query) { - if (!ecs_query_table_count(query)) { - ecs_add_id(world, it.entities[i], EcsInactive); - } - } - } +bool flecs_id_existst( + ecs_world_t *world, + ecs_id_t id) +{ + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { + return false; } + return (ecs_table_cache_count(&idr->cache) != 0) || + (ecs_table_cache_empty_count(&idr->cache) != 0); +} - flecs_defer_flush(world, &world->stage); +const ecs_table_record_t* flecs_id_record_table( + ecs_id_record_t *idr, + ecs_table_t *table) +{ + if (!idr) { + return NULL; + } + return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table); } -void ecs_set_pipeline( +ecs_id_record_t* flecs_table_iter( ecs_world_t *world, - ecs_entity_t pipeline) + ecs_id_t id, + ecs_table_cache_iter_t *out) { - ecs_poly_assert(world, ecs_world_t); - ecs_check( ecs_get(world, pipeline, EcsPipelineQuery) != NULL, - ECS_INVALID_PARAMETER, "not a pipeline"); + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { + return NULL; + } - world->pipeline = pipeline; -error: - return; -} + flecs_process_pending_tables(world); + ecs_assert( flecs_sparse_count(world->pending_tables) == 0, + ECS_INTERNAL_ERROR, NULL); -ecs_entity_t ecs_get_pipeline( - const ecs_world_t *world) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - world = ecs_get_world(world); - return world->pipeline; -error: - return 0; + flecs_table_cache_iter(&idr->cache, out); + return idr; } -/* -- Module implementation -- */ - -static -void FlecsPipelineFini( +ecs_id_record_t* flecs_empty_table_iter( ecs_world_t *world, - void *ctx) + ecs_id_t id, + ecs_table_cache_iter_t *out) { - (void)ctx; - if (ecs_get_stage_count(world)) { - ecs_set_threads(world, 0); + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { + return NULL; } + + flecs_process_pending_tables(world); + ecs_assert( flecs_sparse_count(world->pending_tables) == 0, + ECS_INTERNAL_ERROR, NULL); + + flecs_table_cache_empty_iter(&idr->cache, out); + return idr; } -void FlecsPipelineImport( +void ecs_force_aperiodic( ecs_world_t *world) { - ECS_MODULE(world, FlecsPipeline); - - ECS_IMPORT(world, FlecsSystem); - - ecs_set_name_prefix(world, "Ecs"); + flecs_process_pending_tables(world); + flecs_eval_component_monitors(world); +} - flecs_bootstrap_tag(world, EcsPipeline); - flecs_bootstrap_component(world, EcsPipelineQuery); - /* Phases of the builtin pipeline are regular entities. Names are set so - * they can be resolved by type expressions. */ - flecs_bootstrap_tag(world, EcsPreFrame); - flecs_bootstrap_tag(world, EcsOnLoad); - flecs_bootstrap_tag(world, EcsPostLoad); - flecs_bootstrap_tag(world, EcsPreUpdate); - flecs_bootstrap_tag(world, EcsOnUpdate); - flecs_bootstrap_tag(world, EcsOnValidate); - flecs_bootstrap_tag(world, EcsPostUpdate); - flecs_bootstrap_tag(world, EcsPreStore); - flecs_bootstrap_tag(world, EcsOnStore); - flecs_bootstrap_tag(world, EcsPostFrame); +static +bool observer_run(ecs_iter_t *it) { + ecs_observer_t *o = it->ctx; + ecs_world_t *world = it->world; - /* Set ctor and dtor for PipelineQuery */ - ecs_set(world, ecs_id(EcsPipelineQuery), EcsComponentLifecycle, { - .ctor = ecs_default_ctor, - .dtor = ecs_dtor(EcsPipelineQuery) - }); + ecs_assert(o->callback != NULL, ECS_INVALID_PARAMETER, NULL); - /* When the Pipeline tag is added a pipeline will be created */ - ecs_observer_init(world, &(ecs_observer_desc_t) { - .entity.name = "OnUpdatePipeline", - .filter.terms = { - { .id = EcsPipeline }, - { .id = ecs_id(EcsType) } - }, - .events = { EcsOnSet }, - .callback = OnUpdatePipeline - }); + if (o->last_event_id == world->event_id) { + /* Already handled this event */ + return false; + } - /* Create the builtin pipeline */ - world->pipeline = ecs_type_init(world, &(ecs_type_desc_t){ - .entity = { - .name = "BuiltinPipeline", - .add = {EcsPipeline} - }, - .ids = { - EcsPreFrame, EcsOnLoad, EcsPostLoad, EcsPreUpdate, EcsOnUpdate, - EcsOnValidate, EcsPostUpdate, EcsPreStore, EcsOnStore, EcsPostFrame - } - }); + o->last_event_id = world->event_id; - /* Cleanup thread administration when world is destroyed */ - ecs_atfini(world, FlecsPipelineFini, NULL); -} + ecs_iter_t user_it = *it; + user_it.term_count = o->filter.term_count_actual; + user_it.terms = o->filter.terms; + user_it.is_filter = o->filter.filter; + user_it.ids = NULL; + user_it.columns = NULL; + user_it.subjects = NULL; + user_it.sizes = NULL; + user_it.ptrs = NULL; -#endif + flecs_iter_init(&user_it); + ecs_table_t *table = it->table; + ecs_table_t *prev_table = it->other_table; + int32_t pivot_term = it->term_index; + ecs_term_t *term = &o->filter.terms[pivot_term]; -#ifdef FLECS_TIMER + if (term->oper == EcsNot) { + table = it->other_table; + prev_table = it->table; + } -static -void AddTickSource(ecs_iter_t *it) { - int32_t i; - for (i = 0; i < it->count; i ++) { - ecs_set(it->world, it->entities[i], EcsTickSource, {0}); + if (!table) { + table = &world->store.root; + } + if (!prev_table) { + prev_table = &world->store.root; } -} -static -void ProgressTimers(ecs_iter_t *it) { - EcsTimer *timer = ecs_term(it, EcsTimer, 1); - EcsTickSource *tick_source = ecs_term(it, EcsTickSource, 2); + static int obs_count = 0; + obs_count ++; - ecs_assert(timer != NULL, ECS_INTERNAL_ERROR, NULL); + /* Populate the column for the term that triggered. This will allow the + * matching algorithm to pick the right column in case the term is a + * wildcard matching multiple columns. */ + user_it.columns[0] = 0; + user_it.columns[pivot_term] = it->columns[0]; - int i; - for (i = 0; i < it->count; i ++) { - tick_source[i].tick = false; + if (flecs_filter_match_table(world, &o->filter, table, + user_it.ids, user_it.columns, user_it.subjects, NULL, NULL, false, -1)) + { + /* Monitor observers only trigger when the filter matches for the first + * time with an entity */ + if (o->is_monitor) { + if (flecs_filter_match_table(world, &o->filter, prev_table, + NULL, NULL, NULL, NULL, NULL, true, -1)) + { + goto done; + } - if (!timer[i].active) { - continue; + if (term->oper == EcsNot) { + /* Flip event if this is a Not, so OnAdd and OnRemove can be + * reliably used to check if we're entering or leaving the + * monitor */ + if (it->event == EcsOnAdd) { + user_it.event = EcsOnRemove; + } else if (it->event == EcsOnRemove) { + user_it.event = EcsOnAdd; + } + } } - const ecs_world_info_t *info = ecs_get_world_info(it->world); - FLECS_FLOAT time_elapsed = timer[i].time + info->delta_time_raw; - FLECS_FLOAT timeout = timer[i].timeout; - - if (time_elapsed >= timeout) { - FLECS_FLOAT t = time_elapsed - timeout; - if (t > timeout) { - t = 0; - } + flecs_iter_populate_data(world, &user_it, + it->table, it->offset, it->count, user_it.ptrs, user_it.sizes); - timer[i].time = t; /* Initialize with remainder */ - tick_source[i].tick = true; - tick_source[i].time_elapsed = time_elapsed; + user_it.ids[it->term_index] = it->event_id; + user_it.system = o->entity; + user_it.term_index = it->term_index; + user_it.self = o->self; + user_it.ctx = o->ctx; + user_it.term_count = o->filter.term_count_actual; - if (timer[i].single_shot) { - timer[i].active = false; - } - } else { - timer[i].time = time_elapsed; - } + o->callback(&user_it); + + ecs_iter_fini(&user_it); + return true; } + +done: + ecs_iter_fini(&user_it); + return false; } -static -void ProgressRateFilters(ecs_iter_t *it) { - EcsRateFilter *filter = ecs_term(it, EcsRateFilter, 1); - EcsTickSource *tick_dst = ecs_term(it, EcsTickSource, 2); - - int i; - for (i = 0; i < it->count; i ++) { - ecs_entity_t src = filter[i].src; - bool inc = false; - - filter[i].time_elapsed += it->delta_time; - - if (src) { - const EcsTickSource *tick_src = ecs_get(it->world, src, EcsTickSource); - if (tick_src) { - inc = tick_src->tick; - } else { - inc = true; - } - } else { - inc = true; - } - - if (inc) { - filter[i].tick_count ++; - bool triggered = !(filter[i].tick_count % filter[i].rate); - tick_dst[i].tick = triggered; - tick_dst[i].time_elapsed = filter[i].time_elapsed; - - if (triggered) { - filter[i].time_elapsed = 0; - } - } else { - tick_dst[i].tick = false; - } - } +bool ecs_observer_default_run_action(ecs_iter_t *it) { + return observer_run(it); } -static -void ProgressTickSource(ecs_iter_t *it) { - EcsTickSource *tick_src = ecs_term(it, EcsTickSource, 1); - - /* If tick source has no filters, tick unconditionally */ - int i; - for (i = 0; i < it->count; i ++) { - tick_src[i].tick = true; - tick_src[i].time_elapsed = it->delta_time; - } +static +void default_observer_run_callback(ecs_iter_t *it) { + observer_run(it); } -ecs_entity_t ecs_set_timeout( - ecs_world_t *world, - ecs_entity_t timer, - FLECS_FLOAT timeout) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - - timer = ecs_set(world, timer, EcsTimer, { - .timeout = timeout, - .single_shot = true, - .active = true - }); - - EcsSystem *system_data = ecs_get_mut(world, timer, EcsSystem, NULL); - if (system_data) { - system_data->tick_source = timer; +/* For convenience, so applications can (in theory) use a single run callback + * that uses ecs_iter_next to iterate results */ +static +bool default_observer_next_callback(ecs_iter_t *it) { + if (it->interrupted_by) { + return false; + } else { + it->interrupted_by = it->system; + return true; } - -error: - return timer; } -FLECS_FLOAT ecs_get_timeout( - const ecs_world_t *world, - ecs_entity_t timer) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(timer != 0, ECS_INVALID_PARAMETER, NULL); +static +void observer_run_callback(ecs_iter_t *it) { + ecs_observer_t *o = it->ctx; + ecs_run_action_t run = o->run; - const EcsTimer *value = ecs_get(world, timer, EcsTimer); - if (value) { - return value->timeout; + if (run) { + it->next = default_observer_next_callback; + it->callback = default_observer_run_callback; + it->interrupted_by = 0; + run(it); + } else { + observer_run(it); } -error: - return 0; } -ecs_entity_t ecs_set_interval( +static +void observer_yield_existing( ecs_world_t *world, - ecs_entity_t timer, - FLECS_FLOAT interval) + ecs_observer_t *observer) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - - timer = ecs_set(world, timer, EcsTimer, { - .timeout = interval, - .active = true - }); - - EcsSystem *system_data = ecs_get_mut(world, timer, EcsSystem, NULL); - if (system_data) { - system_data->tick_source = timer; + ecs_run_action_t run = observer->run; + if (!run) { + run = default_observer_run_callback; } -error: - return timer; -} - -FLECS_FLOAT ecs_get_interval( - const ecs_world_t *world, - ecs_entity_t timer) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - if (!timer) { - return 0; + int32_t pivot_term = ecs_filter_pivot_term(world, &observer->filter); + if (pivot_term < 0) { + return; } - const EcsTimer *value = ecs_get(world, timer, EcsTimer); - if (value) { - return value->timeout; - } -error: - return 0; -} + /* If yield existing is enabled, trigger for each thing that matches + * the event, if the event is iterable. */ + int i, count = observer->event_count; + for (i = 0; i < count; i ++) { + ecs_entity_t evt = observer->events[i]; + const EcsIterable *iterable = ecs_get(world, evt, EcsIterable); + if (!iterable) { + continue; + } -void ecs_start_timer( - ecs_world_t *world, - ecs_entity_t timer) -{ - EcsTimer *ptr = ecs_get_mut(world, timer, EcsTimer, NULL); - ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ptr->active = true; - ptr->time = 0; -error: - return; -} + ecs_iter_t it; + iterable->init(world, world, &it, &observer->filter.terms[pivot_term]); + it.terms = observer->filter.terms; + it.term_count = 1; + it.term_index = pivot_term; + it.system = observer->entity; + it.ctx = observer; + it.binding_ctx = observer->binding_ctx; + it.event = evt; -void ecs_stop_timer( - ecs_world_t *world, - ecs_entity_t timer) -{ - EcsTimer *ptr = ecs_get_mut(world, timer, EcsTimer, NULL); - ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ptr->active = false; -error: - return; + ecs_iter_next_action_t next = it.next; + ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL); + while (next(&it)) { + run(&it); + world->event_id ++; + } + } } -ecs_entity_t ecs_set_rate( +ecs_entity_t ecs_observer_init( ecs_world_t *world, - ecs_entity_t filter, - int32_t rate, - ecs_entity_t source) + const ecs_observer_desc_t *desc) { + ecs_entity_t entity = 0; ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); + ecs_check(desc->callback != NULL || desc->run != NULL, + ECS_INVALID_OPERATION, NULL); - filter = ecs_set(world, filter, EcsRateFilter, { - .rate = rate, - .src = source - }); + /* If entity is provided, create it */ + ecs_entity_t existing = desc->entity.entity; + entity = ecs_entity_init(world, &desc->entity); + if (!existing && !desc->entity.name) { + ecs_add_pair(world, entity, EcsChildOf, EcsFlecsHidden); + } - EcsSystem *system_data = ecs_get_mut(world, filter, EcsSystem, NULL); - if (system_data) { - system_data->tick_source = filter; - } + bool added = false; + EcsObserver *comp = ecs_get_mut(world, entity, EcsObserver, &added); + if (added) { + ecs_observer_t *observer = flecs_sparse_add( + world->observers, ecs_observer_t); + ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL); + observer->id = flecs_sparse_last_id(world->observers); + comp->observer = observer; -error: - return filter; -} + /* Make writeable copy of filter desc so that we can set name. This will + * make debugging easier, as any error messages related to creating the + * filter will have the name of the observer. */ + ecs_filter_desc_t filter_desc = desc->filter; + filter_desc.name = desc->entity.name; -void ecs_set_tick_source( - ecs_world_t *world, - ecs_entity_t system, - ecs_entity_t tick_source) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(tick_source != 0, ECS_INVALID_PARAMETER, NULL); + /* Parse filter */ + ecs_filter_t *filter = &observer->filter; + if (ecs_filter_init(world, filter, &filter_desc)) { + flecs_observer_fini(world, observer); + return 0; + } - EcsSystem *system_data = ecs_get_mut(world, system, EcsSystem, NULL); - ecs_check(system_data != NULL, ECS_INVALID_PARAMETER, NULL); + /* Creating an observer with no terms has no effect */ + ecs_assert(observer->filter.term_count != 0, + ECS_INVALID_PARAMETER, NULL); - system_data->tick_source = tick_source; -error: - return; -} + int i, e; + for (i = 0; i < ECS_TRIGGER_DESC_EVENT_COUNT_MAX; i ++) { + ecs_entity_t event = desc->events[i]; + if (!event) { + break; + } -void FlecsTimerImport( - ecs_world_t *world) -{ - ECS_MODULE(world, FlecsTimer); + if (event == EcsMonitor) { + /* Monitor event must be first and last event */ + ecs_check(i == 0, ECS_INVALID_PARAMETER, NULL); - ECS_IMPORT(world, FlecsPipeline); + observer->events[0] = EcsOnAdd; + observer->events[1] = EcsOnRemove; + observer->event_count ++; + observer->is_monitor = true; + } else { + observer->events[i] = event; + } - ecs_set_name_prefix(world, "Ecs"); + observer->event_count ++; + } - flecs_bootstrap_component(world, EcsTimer); - flecs_bootstrap_component(world, EcsRateFilter); + /* Observer must have at least one event */ + ecs_check(observer->event_count != 0, ECS_INVALID_PARAMETER, NULL); - /* Add EcsTickSource to timers and rate filters */ - ecs_system_init(world, &(ecs_system_desc_t) { - .entity = { .name = "AddTickSource", .add = { EcsPreFrame } }, - .query.filter.terms = { - { .id = ecs_id(EcsTimer), .oper = EcsOr, .inout = EcsIn }, - { .id = ecs_id(EcsRateFilter), .oper = EcsOr, .inout = EcsIn }, - { .id = ecs_id(EcsTickSource), .oper = EcsNot, .inout = EcsOut} - }, - .callback = AddTickSource - }); + observer->callback = desc->callback; + observer->run = desc->run; + observer->self = desc->self; + observer->ctx = desc->ctx; + observer->binding_ctx = desc->binding_ctx; + observer->ctx_free = desc->ctx_free; + observer->binding_ctx_free = desc->binding_ctx_free; + observer->entity = entity; + comp->observer = observer; - /* Timer handling */ - ecs_system_init(world, &(ecs_system_desc_t) { - .entity = { .name = "ProgressTimers", .add = { EcsPreFrame } }, - .query.filter.terms = { - { .id = ecs_id(EcsTimer) }, - { .id = ecs_id(EcsTickSource) } - }, - .callback = ProgressTimers - }); + /* Create a trigger for each term in the filter */ + ecs_trigger_desc_t tdesc = { + .callback = observer_run_callback, + .ctx = observer, + .binding_ctx = desc->binding_ctx, + .match_prefab = observer->filter.match_prefab, + .match_disabled = observer->filter.match_disabled, + .last_event_id = &observer->last_event_id + }; - /* Rate filter handling */ - ecs_system_init(world, &(ecs_system_desc_t) { - .entity = { .name = "ProgressRateFilters", .add = { EcsPreFrame } }, - .query.filter.terms = { - { .id = ecs_id(EcsRateFilter), .inout = EcsIn }, - { .id = ecs_id(EcsTickSource), .inout = EcsOut } - }, - .callback = ProgressRateFilters - }); + for (i = 0; i < filter->term_count; i ++) { + tdesc.term = filter->terms[i]; + ecs_oper_kind_t oper = tdesc.term.oper; + ecs_id_t id = tdesc.term.id; - /* TickSource without a timer or rate filter just increases each frame */ - ecs_system_init(world, &(ecs_system_desc_t) { - .entity = { .name = "ProgressTickSource", .add = { EcsPreFrame } }, - .query.filter.terms = { - { .id = ecs_id(EcsTickSource), .inout = EcsOut }, - { .id = ecs_id(EcsRateFilter), .oper = EcsNot }, - { .id = ecs_id(EcsTimer), .oper = EcsNot } - }, - .callback = ProgressTickSource - }); -} + bool is_tag = ecs_id_is_tag(world, id); -#endif + if (is_tag) { + /* If id is a tag, convert OnSet/UnSet to OnAdd/OnRemove. This + * allows for creating OnSet observers with both components and + * tags that only fire when the entity has all ids */ + for (e = 0; e < observer->event_count; e ++) { + if (observer->events[e] == EcsOnSet) { + tdesc.events[e] = EcsOnAdd; + } else + if (observer->events[e] == EcsUnSet) { + tdesc.events[e] = EcsOnRemove; + } else { + tdesc.events[e] = observer->events[e]; + } + } + } else { + ecs_os_memcpy_n(tdesc.events, observer->events, ecs_entity_t, + observer->event_count); + } -#include + /* AndFrom & OrFrom terms insert multiple triggers */ + if (oper == EcsAndFrom || oper == EcsOrFrom) { + const EcsType *type = ecs_get(world, id, EcsType); + int32_t ti, ti_count = ecs_vector_count(type->normalized->type); + ecs_id_t *ti_ids = ecs_vector_first( + type->normalized->type, ecs_id_t); -/* Utilities for C++ API */ + /* Correct operator will be applied when a trigger occurs, and + * the observer is evaluated on the trigger source */ + tdesc.term.oper = EcsAnd; + for (ti = 0; ti < ti_count; ti ++) { + tdesc.term.pred.name = NULL; + tdesc.term.pred.entity = ti_ids[ti]; + tdesc.term.id = ti_ids[ti]; + ecs_entity_t t = ecs_vector_add(&observer->triggers, + ecs_entity_t)[0] = ecs_trigger_init(world, &tdesc); + if (!t) { + goto error; + } + } + continue; + } -#ifdef FLECS_CPP + ecs_entity_t t = ecs_vector_add(&observer->triggers, ecs_entity_t) + [0] = ecs_trigger_init(world, &tdesc); + if (!t) { + goto error; + } + } -/* Convert compiler-specific typenames extracted from __PRETTY_FUNCTION__ to - * a uniform identifier */ + if (desc->entity.name) { + ecs_trace("#[green]observer#[reset] %s created", + ecs_get_name(world, entity)); + } -#define ECS_CONST_PREFIX "const " -#define ECS_STRUCT_PREFIX "struct " -#define ECS_CLASS_PREFIX "class " -#define ECS_ENUM_PREFIX "enum " + if (desc->yield_existing) { + observer_yield_existing(world, observer); + } + } else { + ecs_assert(comp->observer != NULL, ECS_INTERNAL_ERROR, NULL); -#define ECS_CONST_LEN (-1 + (ecs_size_t)sizeof(ECS_CONST_PREFIX)) -#define ECS_STRUCT_LEN (-1 + (ecs_size_t)sizeof(ECS_STRUCT_PREFIX)) -#define ECS_CLASS_LEN (-1 + (ecs_size_t)sizeof(ECS_CLASS_PREFIX)) -#define ECS_ENUM_LEN (-1 + (ecs_size_t)sizeof(ECS_ENUM_PREFIX)) + /* If existing entity handle was provided, override existing params */ + if (existing) { + if (desc->callback) { + ((ecs_observer_t*)comp->observer)->callback = desc->callback; + } + if (desc->ctx) { + ((ecs_observer_t*)comp->observer)->ctx = desc->ctx; + } + if (desc->binding_ctx) { + ((ecs_observer_t*)comp->observer)->binding_ctx = + desc->binding_ctx; + } + } + } -static -ecs_size_t ecs_cpp_strip_prefix( - char *typeName, - ecs_size_t len, - const char *prefix, - ecs_size_t prefix_len) -{ - if ((len > prefix_len) && !ecs_os_strncmp(typeName, prefix, prefix_len)) { - ecs_os_memmove(typeName, typeName + prefix_len, len - prefix_len); - typeName[len - prefix_len] = '\0'; - len -= prefix_len; + return entity; +error: + if (entity) { + ecs_delete(world, entity); } - return len; + return 0; } -static -void ecs_cpp_trim_type_name( - char *typeName) +void flecs_observer_fini( + ecs_world_t *world, + ecs_observer_t *observer) { - ecs_size_t len = ecs_os_strlen(typeName); + /* Cleanup triggers */ + int i, count = ecs_vector_count(observer->triggers); + ecs_entity_t *triggers = ecs_vector_first(observer->triggers, ecs_entity_t); + for (i = 0; i < count; i ++) { + ecs_entity_t t = triggers[i]; + if (!t) continue; + ecs_delete(world, triggers[i]); + } + ecs_vector_free(observer->triggers); - len = ecs_cpp_strip_prefix(typeName, len, ECS_CONST_PREFIX, ECS_CONST_LEN); - len = ecs_cpp_strip_prefix(typeName, len, ECS_STRUCT_PREFIX, ECS_STRUCT_LEN); - len = ecs_cpp_strip_prefix(typeName, len, ECS_CLASS_PREFIX, ECS_CLASS_LEN); - len = ecs_cpp_strip_prefix(typeName, len, ECS_ENUM_PREFIX, ECS_ENUM_LEN); + /* Cleanup filters */ + ecs_filter_fini(&observer->filter); - while (typeName[len - 1] == ' ' || - typeName[len - 1] == '&' || - typeName[len - 1] == '*') - { - len --; - typeName[len] = '\0'; + /* Cleanup context */ + if (observer->ctx_free) { + observer->ctx_free(observer->ctx); } - /* Remove const at end of string */ - if (len > ECS_CONST_LEN) { - if (!ecs_os_strncmp(&typeName[len - ECS_CONST_LEN], " const", ECS_CONST_LEN)) { - typeName[len - ECS_CONST_LEN] = '\0'; - } - len -= ECS_CONST_LEN; + if (observer->binding_ctx_free) { + observer->binding_ctx_free(observer->binding_ctx); } - /* Check if there are any remaining "struct " strings, which can happen - * if this is a template type on msvc. */ - if (len > ECS_STRUCT_LEN) { - char *ptr = typeName; - while ((ptr = strstr(ptr + 1, ECS_STRUCT_PREFIX)) != 0) { - /* Make sure we're not matched with part of a longer identifier - * that contains 'struct' */ - if (ptr[-1] == '<' || ptr[-1] == ',' || isspace(ptr[-1])) { - ecs_os_memmove(ptr, ptr + ECS_STRUCT_LEN, - ecs_os_strlen(ptr + ECS_STRUCT_LEN) + 1); - len -= ECS_STRUCT_LEN; - } - } - } + /* Cleanup observer storage */ + flecs_sparse_remove(world->observers, observer->id); } -char* ecs_cpp_get_type_name( - char *type_name, - const char *func_name, - size_t len) +void* ecs_get_observer_ctx( + const ecs_world_t *world, + ecs_entity_t observer) { - memcpy(type_name, func_name + ECS_FUNC_NAME_FRONT(const char*, type_name), len); - type_name[len] = '\0'; - ecs_cpp_trim_type_name(type_name); - return type_name; + const EcsObserver *o = ecs_get(world, observer, EcsObserver); + if (o) { + return o->observer->ctx; + } else { + return NULL; + } } -char* ecs_cpp_get_symbol_name( - char *symbol_name, - const char *type_name, - size_t len) -{ - // Symbol is same as name, but with '::' replaced with '.' - ecs_os_strcpy(symbol_name, type_name); - - char *ptr; - size_t i; - for (i = 0, ptr = symbol_name; i < len && *ptr; i ++, ptr ++) { - if (*ptr == ':') { - symbol_name[i] = '.'; - ptr ++; - } else { - symbol_name[i] = *ptr; - } - } - - symbol_name[i] = '\0'; - - return symbol_name; -} - -static -const char* cpp_func_rchr( - const char *func_name, - ecs_size_t func_name_len, - char ch) +void* ecs_get_observer_binding_ctx( + const ecs_world_t *world, + ecs_entity_t observer) { - const char *r = strrchr(func_name, ch); - if ((r - func_name) >= (func_name_len - flecs_uto(ecs_size_t, ECS_FUNC_NAME_BACK))) { + const EcsObserver *o = ecs_get(world, observer, EcsObserver); + if (o) { + return o->observer->binding_ctx; + } else { return NULL; - } - return r; + } } -static -const char* cpp_func_max( - const char *a, - const char *b) -{ - if (a > b) return a; - return b; -} -char* ecs_cpp_get_constant_name( - char *constant_name, - const char *func_name, - size_t func_name_len) +void flecs_observable_init( + ecs_observable_t *observable) { - ecs_size_t f_len = flecs_uto(ecs_size_t, func_name_len); - const char *start = cpp_func_rchr(func_name, f_len, ' '); - start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ')')); - start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ':')); - start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ',')); - ecs_assert(start != NULL, ECS_INVALID_PARAMETER, func_name); - start ++; - - ecs_size_t len = flecs_uto(ecs_size_t, - (f_len - (start - func_name) - flecs_uto(ecs_size_t, ECS_FUNC_NAME_BACK))); - ecs_os_memcpy_n(constant_name, start, char, len); - constant_name[len] = '\0'; - return constant_name; + observable->events = ecs_sparse_new(ecs_event_record_t); } -// Names returned from the name_helper class do not start with :: -// but are relative to the root. If the namespace of the type -// overlaps with the namespace of the current module, strip it from -// the implicit identifier. -// This allows for registration of component types that are not in the -// module namespace to still be registered under the module scope. -const char* ecs_cpp_trim_module( - ecs_world_t *world, - const char *type_name) +void flecs_observable_fini( + ecs_observable_t *observable) { - ecs_entity_t scope = ecs_get_scope(world); - if (!scope) { - return type_name; - } + ecs_sparse_t *triggers = observable->events; + int32_t i, count = flecs_sparse_count(triggers); - char *path = ecs_get_path_w_sep(world, 0, scope, "::", NULL); - if (path) { - const char *ptr = strrchr(type_name, ':'); - ecs_assert(ptr != type_name, ECS_INTERNAL_ERROR, NULL); - if (ptr) { - ptr --; - ecs_assert(ptr[0] == ':', ECS_INTERNAL_ERROR, NULL); - ecs_size_t name_path_len = (ecs_size_t)(ptr - type_name); - if (name_path_len <= ecs_os_strlen(path)) { - if (!ecs_os_strncmp(type_name, path, name_path_len)) { - type_name = &type_name[name_path_len + 2]; - } - } + for (i = 0; i < count; i ++) { + ecs_event_record_t *et = + ecs_sparse_get_dense(triggers, ecs_event_record_t, i); + ecs_assert(et != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_map_iter_t it = ecs_map_iter(&et->event_ids); + ecs_event_id_record_t *idt; + while ((idt = ecs_map_next(&it, ecs_event_id_record_t, NULL))) { + ecs_map_fini(&idt->triggers); + ecs_map_fini(&idt->set_triggers); } + ecs_map_fini(&et->event_ids); } - ecs_os_free(path); - return type_name; + flecs_sparse_free(observable->events); } -// Validate registered component -void ecs_cpp_component_validate( +static +void notify_subset( ecs_world_t *world, - ecs_entity_t id, - const char *name, - size_t size, - size_t alignment, - bool implicit_name) + ecs_iter_t *it, + ecs_observable_t *observable, + ecs_entity_t entity, + ecs_entity_t event, + ecs_ids_t *ids) { - /* If entity has a name check if it matches */ - if (ecs_is_valid(world, id) && ecs_get_name(world, id) != NULL) { - if (!implicit_name && id >= EcsFirstUserComponentId) { -# ifndef FLECS_NDEBUG - char *path = ecs_get_path_w_sep( - world, 0, id, "::", NULL); - if (ecs_os_strcmp(path, name)) { - ecs_err( - "component '%s' already registered with name '%s'", - name, path); - ecs_abort(ECS_INCONSISTENT_NAME, NULL); - } - ecs_os_free(path); -# endif - } - } else { - /* Ensure that the entity id valid */ - if (!ecs_is_alive(world, id)) { - ecs_ensure(world, id); - } - - /* Register name with entity, so that when the entity is created the - * correct id will be resolved from the name. Only do this when the - * entity is empty. */ - ecs_add_path_w_sep(world, id, 0, name, "::", "::"); + ecs_id_t pair = ecs_pair(EcsWildcard, entity); + ecs_table_cache_iter_t idt; + ecs_id_record_t *idr = flecs_table_iter(world, pair, &idt); + if (!idr) { + return; } - /* If a component was already registered with this id but with a - * different size, the ecs_component_init function will fail. */ + const ecs_table_record_t *tr; + while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) { + ecs_table_t *table = tr->hdr.table; + ecs_id_t id = ecs_vector_get(table->type, ecs_id_t, tr->column)[0]; + ecs_entity_t rel = ECS_PAIR_FIRST(id); - /* We need to explicitly call ecs_component_init here again. Even though - * the component was already registered, it may have been registered - * with a different world. This ensures that the component is registered - * with the same id for the current world. - * If the component was registered already, nothing will change. */ - ecs_entity_t ent = ecs_component_init(world, &(ecs_component_desc_t) { - .entity.entity = id, - .size = size, - .alignment = alignment - }); - (void)ent; - ecs_assert(ent == id, ECS_INTERNAL_ERROR, NULL); -} + if (ecs_is_valid(world, rel) && !ecs_has_id(world, rel, EcsAcyclic)) { + /* Only notify for acyclic relations */ + continue; + } -ecs_entity_t ecs_cpp_component_register( - ecs_world_t *world, - ecs_entity_t id, - const char *name, - const char *symbol, - ecs_size_t size, - ecs_size_t alignment) -{ - (void)size; - (void)alignment; + int32_t e, entity_count = ecs_table_count(table); + it->table = table; + it->type = table->type; + it->other_table = NULL; + it->offset = 0; + it->count = entity_count; - /* If the component is not yet registered, ensure no other component - * or entity has been registered with this name. Ensure component is - * looked up from root. */ - ecs_entity_t prev_scope = ecs_set_scope(world, 0); - ecs_entity_t ent; - if (id) { - ent = id; - } else { - ent = ecs_lookup_path_w_sep(world, 0, name, "::", "::", false); - } - ecs_set_scope(world, prev_scope); + /* Treat as new event as this could trigger observers again for + * different tables. */ + world->event_id ++; - /* If entity exists, compare symbol name to ensure that the component - * we are trying to register under this name is the same */ - if (ent) { - if (!id && ecs_has(world, ent, EcsComponent)) { - const char *sym = ecs_get_symbol(world, ent); - ecs_assert(sym != NULL, ECS_MISSING_SYMBOL, - ecs_get_name(world, ent)); - (void)sym; + flecs_set_triggers_notify(it, observable, ids, event, + ecs_pair(rel, EcsWildcard)); -# ifndef FLECS_NDEBUG - if (ecs_os_strcmp(sym, symbol)) { - ecs_err( - "component with name '%s' is already registered for"\ - " type '%s' (trying to register for type '%s')", - name, sym, symbol); - ecs_abort(ECS_NAME_IN_USE, NULL); - } -# endif + ecs_entity_t *entities = ecs_vector_first( + table->storage.entities, ecs_entity_t); + ecs_record_t **records = ecs_vector_first( + table->storage.record_ptrs, ecs_record_t*); - /* If an existing id was provided, it's possible that this id was - * registered with another type. Make sure that in this case at - * least the component size/alignment matches. - * This allows applications to alias two different types to the same - * id, which enables things like redefining a C type in C++ by - * inheriting from it & adding utility functions etc. */ - } else { - const EcsComponent *comp = ecs_get(world, ent, EcsComponent); - if (comp) { - ecs_assert(comp->size == size, - ECS_INVALID_COMPONENT_SIZE, NULL); - ecs_assert(comp->alignment == alignment, - ECS_INVALID_COMPONENT_ALIGNMENT, NULL); - } else { - /* If the existing id is not a component, no checking is - * needed. */ + for (e = 0; e < entity_count; e ++) { + uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(records[e]->row); + if (flags & ECS_FLAG_OBSERVED_ACYCLIC) { + /* Only notify for entities that are used in pairs with + * acyclic relations */ + notify_subset(world, it, observable, entities[e], event, ids); } } - - /* If no entity is found, lookup symbol to check if the component was - * registered under a different name. */ - } else { - ent = ecs_lookup_symbol(world, symbol, false); - ecs_assert(ent == 0, ECS_INCONSISTENT_COMPONENT_ID, symbol); } - - return id; } -ecs_entity_t ecs_cpp_component_register_explicit( +void ecs_emit( ecs_world_t *world, - ecs_entity_t s_id, - ecs_entity_t id, - const char *name, - const char *type_name, - const char *symbol, - size_t size, - size_t alignment, - bool is_component) + ecs_event_desc_t *desc) { - // If an explicit id is provided, it is possible that the symbol and - // name differ from the actual type, as the application may alias - // one type to another. - if (!id) { - if (!name) { - // If no name was provided, retrieve the name implicitly from - // the name_helper class. - name = ecs_cpp_trim_module(world, type_name); - } - } else { - // If an explicit id is provided but it has no name, inherit - // the name from the type. - if (!ecs_is_valid(world, id) || !ecs_get_name(world, id)) { - name = ecs_cpp_trim_module(world, type_name); - } + ecs_poly_assert(world, ecs_world_t); + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->event != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->event != EcsWildcard, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->ids != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->ids->count != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->table != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->observable != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_ids_t *ids = desc->ids; + ecs_entity_t event = desc->event; + ecs_table_t *table = desc->table; + int32_t row = desc->offset; + int32_t i, count = desc->count; + ecs_entity_t relation = desc->relation; + + if (!count) { + count = ecs_table_count(table) - row; } - ecs_entity_t entity; - if (is_component || size != 0) { - entity = ecs_component_init(world, &(ecs_component_desc_t){ - .entity.entity = s_id, - .entity.name = name, - .entity.sep = "::", - .entity.root_sep = "::", - .entity.symbol = symbol, - .size = size, - .alignment = alignment - }); + ecs_iter_t it = { + .world = world, + .real_world = world, + .table = table, + .type = table->type, + .term_count = 1, + .other_table = desc->other_table, + .offset = row, + .count = count, + .param = (void*)desc->param, + .table_only = desc->table_event + }; + + world->event_id ++; + + ecs_observable_t *observable = ecs_get_observable(desc->observable); + ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL); + + if (!desc->relation) { + flecs_triggers_notify(&it, observable, ids, event); } else { - entity = ecs_entity_init(world, &(ecs_entity_desc_t){ - .entity = s_id, - .name = name, - .sep = "::", - .root_sep = "::", - .symbol = symbol - }); + flecs_set_triggers_notify(&it, observable, ids, event, + ecs_pair(relation, EcsWildcard)); } - ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!s_id || s_id == entity, ECS_INTERNAL_ERROR, NULL); - - return entity; -} + if (count && !desc->table_event) { + ecs_record_t **recs = ecs_vector_get( + table->storage.record_ptrs, ecs_record_t*, row); -ecs_entity_t ecs_cpp_enum_constant_register( - ecs_world_t *world, - ecs_entity_t parent, - ecs_entity_t id, - const char *name, - int value) -{ - ecs_suspend_readonly_state_t readonly_state; - world = flecs_suspend_readonly(world, &readonly_state); + for (i = 0; i < count; i ++) { + ecs_record_t *r = recs[i]; + if (!r) { + /* If the event is emitted after a bulk operation, it's possible + * that it hasn't been populate with entities yet. */ + continue; + } - const char *parent_name = ecs_get_name(world, parent); - ecs_size_t parent_name_len = ecs_os_strlen(parent_name); - if (!ecs_os_strncmp(name, parent_name, parent_name_len)) { - name += parent_name_len; - if (name[0] == '_') { - name ++; + uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(recs[i]->row); + if (flags & ECS_FLAG_OBSERVED_ACYCLIC) { + notify_subset(world, &it, observable, ecs_vector_first( + table->storage.entities, ecs_entity_t)[row + i], + event, ids); + } } } + +error: + return; +} - ecs_entity_t prev = ecs_set_scope(world, parent); - id = ecs_entity_init(world, &(ecs_entity_desc_t) { - .entity = id, - .name = name - }); - ecs_assert(id != 0, ECS_INVALID_OPERATION, name); - ecs_set_scope(world, prev); - ecs_set_id(world, id, parent, sizeof(int), &value); +#ifdef FLECS_SYSTEM +#ifndef FLECS_SYSTEM_PRIVATE_H +#define FLECS_SYSTEM_PRIVATE_H - flecs_resume_readonly(world, &readonly_state); +#ifdef FLECS_SYSTEM - ecs_trace("#[green]constant#[reset] %s.%s created with value %d", - ecs_get_name(world, parent), name, value); - return id; -} +typedef struct EcsSystem { + ecs_run_action_t run; /* See ecs_system_desc_t */ + ecs_iter_action_t action; /* See ecs_system_desc_t */ -static int32_t flecs_reset_count = 0; + ecs_entity_t entity; /* Entity id of system, used for ordering */ + ecs_query_t *query; /* System query */ + ecs_system_status_action_t status_action; /* Status action */ + ecs_entity_t tick_source; /* Tick source associated with system */ + + /* Schedule parameters */ + bool multi_threaded; + bool no_staging; -int32_t ecs_cpp_reset_count_get(void) { - return flecs_reset_count; -} + int32_t invoke_count; /* Number of times system is invoked */ + float time_spent; /* Time spent on running system */ + FLECS_FLOAT time_passed; /* Time passed since last invocation */ + int32_t last_frame; /* Last frame for which the system was considered */ -int32_t ecs_cpp_reset_count_inc(void) { - return ++flecs_reset_count; -} + ecs_entity_t self; /* Entity associated with system */ -#endif + void *ctx; /* Userdata for system */ + void *status_ctx; /* User data for status action */ + void *binding_ctx; /* Optional language binding context */ + ecs_ctx_free_t ctx_free; + ecs_ctx_free_t status_ctx_free; + ecs_ctx_free_t binding_ctx_free; +} EcsSystem; -#ifdef FLECS_DEPRECATED +/* Invoked when system becomes active / inactive */ +void ecs_system_activate( + ecs_world_t *world, + ecs_entity_t system, + bool activate, + const EcsSystem *system_data); +/* Internal function to run a system */ +ecs_entity_t ecs_run_intern( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t system, + EcsSystem *system_data, + int32_t stage_current, + int32_t stage_count, + FLECS_FLOAT delta_time, + int32_t offset, + int32_t limit, + void *param); #endif +#endif -#ifdef FLECS_OS_API_IMPL -#ifdef ECS_TARGET_MSVC -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN #endif -#include -#include static -ecs_os_thread_t win_thread_new( - ecs_os_thread_callback_t callback, - void *arg) +void compute_group_id( + ecs_query_t *query, + ecs_query_table_match_t *match) { - HANDLE *thread = ecs_os_malloc_t(HANDLE); - *thread = CreateThread( - NULL, 0, (LPTHREAD_START_ROUTINE)callback, arg, 0, NULL); - return (ecs_os_thread_t)(uintptr_t)thread; -} + ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); -static -void* win_thread_join( - ecs_os_thread_t thr) -{ - HANDLE *thread = (HANDLE*)(uintptr_t)thr; - DWORD r = WaitForSingleObject(*thread, INFINITE); - if (r == WAIT_FAILED) { - ecs_err("win_thread_join: WaitForSingleObject failed"); + if (query->group_by) { + ecs_table_t *table = match->table; + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + + match->group_id = query->group_by(query->world, table->type, + query->group_by_id, query->group_by_ctx); + } else { + match->group_id = 0; } - ecs_os_free(thread); - return NULL; } static -int32_t win_ainc( - int32_t *count) +ecs_query_table_list_t* get_group( + ecs_query_t *query, + uint64_t group_id) { - return InterlockedIncrement(count); + return ecs_map_get(&query->groups, ecs_query_table_list_t, group_id); } static -int32_t win_adec( - int32_t *count) +ecs_query_table_list_t* ensure_group( + ecs_query_t *query, + uint64_t group_id) { - return InterlockedDecrement(count); + return ecs_map_ensure(&query->groups, ecs_query_table_list_t, group_id); } +/* Find the last node of the group after which this group should be inserted */ static -ecs_os_mutex_t win_mutex_new(void) { - CRITICAL_SECTION *mutex = ecs_os_malloc_t(CRITICAL_SECTION); - InitializeCriticalSection(mutex); - return (ecs_os_mutex_t)(uintptr_t)mutex; -} - -static -void win_mutex_free( - ecs_os_mutex_t m) +ecs_query_table_node_t* find_group_insertion_node( + ecs_query_t *query, + uint64_t group_id) { - CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; - DeleteCriticalSection(mutex); - ecs_os_free(mutex); -} + /* Grouping must be enabled */ + ecs_assert(query->group_by != NULL, ECS_INTERNAL_ERROR, NULL); -static -void win_mutex_lock( - ecs_os_mutex_t m) -{ - CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; - EnterCriticalSection(mutex); + ecs_map_iter_t it = ecs_map_iter(&query->groups); + ecs_query_table_list_t *list, *closest_list = NULL; + uint64_t id, closest_id = 0; + + /* Find closest smaller group id */ + while ((list = ecs_map_next(&it, ecs_query_table_list_t, &id))) { + if (id >= group_id) { + continue; + } + + if (!list->last) { + ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL); + continue; + } + + if (!closest_list || ((group_id - id) < (group_id - closest_id))) { + closest_id = id; + closest_list = list; + } + } + + if (closest_list) { + return closest_list->last; + } else { + return NULL; /* Group should be first in query */ + } } +/* Initialize group with first node */ static -void win_mutex_unlock( - ecs_os_mutex_t m) +void create_group( + ecs_query_t *query, + ecs_query_table_node_t *node) { - CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; - LeaveCriticalSection(mutex); -} + ecs_query_table_match_t *match = node->match; + uint64_t group_id = match->group_id; -static -ecs_os_cond_t win_cond_new(void) { - CONDITION_VARIABLE *cond = ecs_os_malloc_t(CONDITION_VARIABLE); - InitializeConditionVariable(cond); - return (ecs_os_cond_t)(uintptr_t)cond; -} + /* If query has grouping enabled & this is a new/empty group, find + * the insertion point for the group */ + ecs_query_table_node_t *insert_after = find_group_insertion_node( + query, group_id); -static -void win_cond_free( - ecs_os_cond_t c) -{ - (void)c; -} + if (!insert_after) { + /* This group should appear first in the query list */ + ecs_query_table_node_t *query_first = query->list.first; + if (query_first) { + /* If this is not the first match for the query, insert before it */ + node->next = query_first; + query_first->prev = node; + query->list.first = node; + } else { + /* If this is the first match of the query, initialize its list */ + ecs_assert(query->list.last == NULL, ECS_INTERNAL_ERROR, NULL); + query->list.first = node; + query->list.last = node; + } + } else { + ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); -static -void win_cond_signal( - ecs_os_cond_t c) -{ - CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; - WakeConditionVariable(cond); + /* This group should appear after another group */ + ecs_query_table_node_t *insert_before = insert_after->next; + node->prev = insert_after; + insert_after->next = node; + node->next = insert_before; + if (insert_before) { + insert_before->prev = node; + } else { + ecs_assert(query->list.last == insert_after, + ECS_INTERNAL_ERROR, NULL); + + /* This group should appear last in the query list */ + query->list.last = node; + } + } } -static -void win_cond_broadcast( - ecs_os_cond_t c) +static +void remove_group( + ecs_query_t *query, + uint64_t group_id) { - CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; - WakeAllConditionVariable(cond); + ecs_map_remove(&query->groups, group_id); } -static -void win_cond_wait( - ecs_os_cond_t c, - ecs_os_mutex_t m) +/* Find the list the node should be part of */ +static +ecs_query_table_list_t* get_node_list( + ecs_query_t *query, + ecs_query_table_node_t *node) { - CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; - CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; - SleepConditionVariableCS(cond, mutex, INFINITE); + ecs_query_table_match_t *match = node->match; + if (query->group_by) { + return get_group(query, match->group_id); + } else { + return &query->list; + } } -static bool win_time_initialized; -static double win_time_freq; -static LARGE_INTEGER win_time_start; - +/* Find or create the list the node should be part of */ static -void win_time_setup(void) { - if ( win_time_initialized) { - return; +ecs_query_table_list_t* ensure_node_list( + ecs_query_t *query, + ecs_query_table_node_t *node) +{ + ecs_query_table_match_t *match = node->match; + if (query->group_by) { + return ensure_group(query, match->group_id); + } else { + return &query->list; } - - win_time_initialized = true; - - LARGE_INTEGER freq; - QueryPerformanceFrequency(&freq); - QueryPerformanceCounter(&win_time_start); - win_time_freq = (double)freq.QuadPart / 1000000000.0; } +/* Remove node from list */ static -void win_sleep( - int32_t sec, - int32_t nanosec) +void remove_table_node( + ecs_query_t *query, + ecs_query_table_node_t *node) { - HANDLE timer; - LARGE_INTEGER ft; - - ft.QuadPart = -((int64_t)sec * 10000000 + (int64_t)nanosec / 100); + ecs_query_table_node_t *prev = node->prev; + ecs_query_table_node_t *next = node->next; - timer = CreateWaitableTimer(NULL, TRUE, NULL); - SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0); - WaitForSingleObject(timer, INFINITE); - CloseHandle(timer); -} + ecs_assert(prev != node, ECS_INTERNAL_ERROR, NULL); + ecs_assert(next != node, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL); -static double win_time_freq; -static ULONG win_current_resolution; + ecs_query_table_list_t *list = get_node_list(query, node); -static -void win_enable_high_timer_resolution(bool enable) -{ - HMODULE hntdll = GetModuleHandle((LPCTSTR)"ntdll.dll"); - if (!hntdll) { + if (!list || !list->first) { + /* If list contains no nodes, the node must be empty */ + ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL); return; } - LONG (__stdcall *pNtSetTimerResolution)( - ULONG desired, BOOLEAN set, ULONG * current); - - pNtSetTimerResolution = (LONG(__stdcall*)(ULONG, BOOLEAN, ULONG*)) - GetProcAddress(hntdll, "NtSetTimerResolution"); + ecs_assert(prev != NULL || query->list.first == node, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(next != NULL || query->list.last == node, + ECS_INTERNAL_ERROR, NULL); - if(!pNtSetTimerResolution) { - return; + if (prev) { + prev->next = next; + } + if (next) { + next->prev = prev; } - ULONG current, resolution = 10000; /* 1 ms */ + ecs_assert(list->count > 0, ECS_INTERNAL_ERROR, NULL); + list->count --; - if (!enable && win_current_resolution) { - pNtSetTimerResolution(win_current_resolution, 0, ¤t); - win_current_resolution = 0; - return; - } else if (!enable) { - return; - } + if (query->group_by) { + ecs_query_table_match_t *match = node->match; + uint64_t group_id = match->group_id; - if (resolution == win_current_resolution) { - return; + /* Make sure query.list is updated if this is the first or last group */ + if (query->list.first == node) { + ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL); + query->list.first = next; + prev = next; + } + if (query->list.last == node) { + ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL); + query->list.last = prev; + next = prev; + } + + ecs_assert(query->list.count > 0, ECS_INTERNAL_ERROR, NULL); + query->list.count --; + + /* Make sure group list only contains nodes that belong to the group */ + if (prev && prev->match->group_id != group_id) { + /* The previous node belonged to another group */ + prev = next; + } + if (next && next->match->group_id != group_id) { + /* The next node belonged to another group */ + next = prev; + } + + /* Do check again, in case both prev & next belonged to another group */ + if (prev && prev->match->group_id != group_id) { + /* There are no more matches left in this group */ + remove_group(query, group_id); + list = NULL; + } } - if (win_current_resolution) { - pNtSetTimerResolution(win_current_resolution, 0, ¤t); + if (list) { + if (list->first == node) { + list->first = next; + } + if (list->last == node) { + list->last = prev; + } } - if (pNtSetTimerResolution(resolution, 1, ¤t)) { - /* Try setting a lower resolution */ - resolution *= 2; - if(pNtSetTimerResolution(resolution, 1, ¤t)) return; + node->prev = NULL; + node->next = NULL; + +#ifdef FLECS_SYSTEM + if (query->list.first == NULL && query->system && !query->world->is_fini) { + ecs_system_activate(query->world, query->system, false, NULL); } +#endif - win_current_resolution = resolution; + query->match_count ++; } +/* Add node to list */ static -uint64_t win_time_now(void) { - uint64_t now; +void insert_table_node( + ecs_query_t *query, + ecs_query_table_node_t *node) +{ + /* Node should not be part of an existing list */ + ecs_assert(node->prev == NULL && node->next == NULL, + ECS_INTERNAL_ERROR, NULL); - LARGE_INTEGER qpc_t; - QueryPerformanceCounter(&qpc_t); - now = (uint64_t)(qpc_t.QuadPart / win_time_freq); + /* If this is the first match, activate system */ +#ifdef FLECS_SYSTEM + if (!query->list.first && query->system) { + ecs_system_activate(query->world, query->system, true, NULL); + } +#endif - return now; -} + compute_group_id(query, node->match); -void ecs_set_os_api_impl(void) { - ecs_os_set_api_defaults(); + ecs_query_table_list_t *list = ensure_node_list(query, node); + if (list->last) { + ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_os_api_t api = ecs_os_api; + ecs_query_table_node_t *last = list->last; + ecs_query_table_node_t *last_next = last->next; - api.thread_new_ = win_thread_new; - api.thread_join_ = win_thread_join; - api.ainc_ = win_ainc; - api.adec_ = win_adec; - api.mutex_new_ = win_mutex_new; - api.mutex_free_ = win_mutex_free; - api.mutex_lock_ = win_mutex_lock; - api.mutex_unlock_ = win_mutex_unlock; - api.cond_new_ = win_cond_new; - api.cond_free_ = win_cond_free; - api.cond_signal_ = win_cond_signal; - api.cond_broadcast_ = win_cond_broadcast; - api.cond_wait_ = win_cond_wait; - api.sleep_ = win_sleep; - api.now_ = win_time_now; - api.enable_high_timer_resolution_ = win_enable_high_timer_resolution; + node->prev = last; + node->next = last_next; + last->next = node; - win_time_setup(); + if (last_next) { + last_next->prev = node; + } - ecs_os_set_api(&api); -} + list->last = node; -#else -#include "pthread.h" + if (query->group_by) { + /* Make sure to update query list if this is the last group */ + if (query->list.last == last) { + query->list.last = node; + } + } + } else { + ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL); -#if defined(__APPLE__) && defined(__MACH__) -#include -#elif defined(__EMSCRIPTEN__) -#include -#else -#include -#endif + list->first = node; + list->last = node; -static -ecs_os_thread_t posix_thread_new( - ecs_os_thread_callback_t callback, - void *arg) -{ - pthread_t *thread = ecs_os_malloc(sizeof(pthread_t)); + if (query->group_by) { + /* Initialize group with its first node */ + create_group(query, node); + } + } - if (pthread_create (thread, NULL, callback, arg) != 0) { - ecs_os_abort(); + if (query->group_by) { + query->list.count ++; } - return (ecs_os_thread_t)(uintptr_t)thread; -} + list->count ++; + query->match_count ++; -static -void* posix_thread_join( - ecs_os_thread_t thread) -{ - void *arg; - pthread_t *thr = (pthread_t*)(uintptr_t)thread; - pthread_join(*thr, &arg); - ecs_os_free(thr); - return arg; -} + ecs_assert(node->prev != node, ECS_INTERNAL_ERROR, NULL); + ecs_assert(node->next != node, ECS_INTERNAL_ERROR, NULL); -static -int32_t posix_ainc( - int32_t *count) -{ - int value; -#ifdef __GNUC__ - value = __sync_add_and_fetch (count, 1); - return value; -#else - /* Unsupported */ - abort(); -#endif + ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(list->last == node, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(query->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL); } static -int32_t posix_adec( - int32_t *count) +ecs_query_table_match_t* cache_add( + ecs_query_table_t *elem) { - int value; -#ifdef __GNUC__ - value = __sync_sub_and_fetch (count, 1); - return value; -#else - /* Unsupported */ - abort(); -#endif -} + ecs_query_table_match_t *result = ecs_os_calloc_t(ecs_query_table_match_t); + ecs_query_table_node_t *node = &result->node; -static -ecs_os_mutex_t posix_mutex_new(void) { - pthread_mutex_t *mutex = ecs_os_malloc(sizeof(pthread_mutex_t)); - if (pthread_mutex_init(mutex, NULL)) { - abort(); + node->match = result; + if (!elem->first) { + elem->first = result; + elem->last = result; + } else { + ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL); + elem->last->next_match = result; + elem->last = result; } - return (ecs_os_mutex_t)(uintptr_t)mutex; -} -static -void posix_mutex_free( - ecs_os_mutex_t m) -{ - pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; - pthread_mutex_destroy(mutex); - ecs_os_free(mutex); + return result; } -static -void posix_mutex_lock( - ecs_os_mutex_t m) -{ - pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; - if (pthread_mutex_lock(mutex)) { - abort(); - } -} +typedef struct { + ecs_table_t *table; + int32_t *dirty_state; + int32_t column; +} table_dirty_state_t; static -void posix_mutex_unlock( - ecs_os_mutex_t m) +void get_dirty_state( + ecs_query_t *query, + ecs_query_table_match_t *match, + int32_t term, + table_dirty_state_t *out) { - pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; - if (pthread_mutex_unlock(mutex)) { - abort(); + ecs_world_t *world = query->world; + ecs_entity_t subject = match->subjects[term]; + int32_t column; + + if (!subject) { + out->table = match->table; + column = match->columns[term]; + if (column == -1) { + column = 0; + } + } else { + out->table = ecs_get_table(world, subject); + column = -match->columns[term]; } -} -static -ecs_os_cond_t posix_cond_new(void) { - pthread_cond_t *cond = ecs_os_malloc(sizeof(pthread_cond_t)); - if (pthread_cond_init(cond, NULL)) { - abort(); + out->dirty_state = flecs_table_get_dirty_state(out->table); + + if (column) { + out->column = ecs_table_type_to_storage_index(out->table, column - 1); + } else { + out->column = -1; } - return (ecs_os_cond_t)(uintptr_t)cond; } -static -void posix_cond_free( - ecs_os_cond_t c) +/* Get match monitor. Monitors are used to keep track of whether components + * matched by the query in a table have changed. */ +static +bool get_match_monitor( + ecs_query_t *query, + ecs_query_table_match_t *match) { - pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; - if (pthread_cond_destroy(cond)) { - abort(); + if (match->monitor) { + return false; } - ecs_os_free(cond); -} -static -void posix_cond_signal( - ecs_os_cond_t c) -{ - pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; - if (pthread_cond_signal(cond)) { - abort(); - } -} - -static -void posix_cond_broadcast( - ecs_os_cond_t c) -{ - pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; - if (pthread_cond_broadcast(cond)) { - abort(); - } -} + int32_t *monitor = ecs_os_calloc_n(int32_t, query->filter.term_count + 1); -static -void posix_cond_wait( - ecs_os_cond_t c, - ecs_os_mutex_t m) -{ - pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; - pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; - if (pthread_cond_wait(cond, mutex)) { - abort(); - } -} + /* Mark terms that don't need to be monitored. This saves time when reading + * and/or updating the monitor. */ + const ecs_filter_t *f = &query->filter; + int32_t i, t = -1, term_count = f->term_count_actual; + table_dirty_state_t cur_dirty_state; -static bool posix_time_initialized; + for (i = 0; i < term_count; i ++) { + if (t == f->terms[i].index) { + if (monitor[t + 1] != -1) { + continue; + } + } -#if defined(__APPLE__) && defined(__MACH__) -static mach_timebase_info_data_t posix_osx_timebase; -static uint64_t posix_time_start; -#else -static uint64_t posix_time_start; -#endif + t = f->terms[i].index; + monitor[t + 1] = -1; -static -void posix_time_setup(void) { - if (posix_time_initialized) { - return; - } - - posix_time_initialized = true; + if (f->terms[i].inout != EcsIn && + f->terms[i].inout != EcsInOut && + f->terms[i].inout != EcsInOutDefault) { + continue; /* If term isn't read, don't monitor */ + } - #if defined(__APPLE__) && defined(__MACH__) - mach_timebase_info(&posix_osx_timebase); - posix_time_start = mach_absolute_time(); - #else - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - posix_time_start = (uint64_t)ts.tv_sec*1000000000 + (uint64_t)ts.tv_nsec; - #endif -} + int32_t column = match->columns[t]; + if (column == 0) { + continue; /* Don't track terms that aren't matched */ + } -static -void posix_sleep( - int32_t sec, - int32_t nanosec) -{ - struct timespec sleepTime; - ecs_assert(sec >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(nanosec >= 0, ECS_INTERNAL_ERROR, NULL); + get_dirty_state(query, match, t, &cur_dirty_state); + if (cur_dirty_state.column == -1) { + continue; /* Don't track terms that aren't stored */ + } - sleepTime.tv_sec = sec; - sleepTime.tv_nsec = nanosec; - if (nanosleep(&sleepTime, NULL)) { - ecs_err("nanosleep failed"); + monitor[t + 1] = 0; } -} -static -void posix_enable_high_timer_resolution(bool enable) { - (void)enable; -} + match->monitor = monitor; -/* prevent 64-bit overflow when computing relative timestamp - see https://gist.github.com/jspohr/3dc4f00033d79ec5bdaf67bc46c813e3 -*/ -#if defined(ECS_TARGET_DARWIN) -static -int64_t posix_int64_muldiv(int64_t value, int64_t numer, int64_t denom) { - int64_t q = value / denom; - int64_t r = value % denom; - return q * numer + r * numer / denom; + query->flags |= EcsQueryHasMonitor; + + return true; } -#endif +/* Synchronize match monitor with table dirty state */ static -uint64_t posix_time_now(void) { - ecs_assert(posix_time_initialized != 0, ECS_INTERNAL_ERROR, NULL); +void sync_match_monitor( + ecs_query_t *query, + ecs_query_table_match_t *match) +{ + ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); + if (!match->monitor) { + if (query->flags & EcsQueryHasMonitor) { + get_match_monitor(query, match); + } else { + return; + } + } - uint64_t now; + int32_t *monitor = match->monitor; + ecs_table_t *table = match->table; + int32_t *dirty_state = flecs_table_get_dirty_state(table); + ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); + table_dirty_state_t cur; - #if defined(ECS_TARGET_DARWIN) - now = (uint64_t) posix_int64_muldiv( - (int64_t)mach_absolute_time(), - (int64_t)posix_osx_timebase.numer, - (int64_t)posix_osx_timebase.denom); - #elif defined(__EMSCRIPTEN__) - now = (long long)(emscripten_get_now() * 1000.0 * 1000); - #else - struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - now = ((uint64_t)ts.tv_sec * 1000 * 1000 * 1000 + (uint64_t)ts.tv_nsec); - #endif + monitor[0] = dirty_state[0]; /* Did table gain/lose entities */ - return now; + int32_t i, term_count = query->filter.term_count_actual; + for (i = 0; i < term_count; i ++) { + int32_t t = query->filter.terms[i].index; + if (monitor[t + 1] == -1) { + continue; + } + + get_dirty_state(query, match, t, &cur); + ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); + monitor[t + 1] = cur.dirty_state[cur.column + 1]; + } } -void ecs_set_os_api_impl(void) { - ecs_os_set_api_defaults(); - - ecs_os_api_t api = ecs_os_api; - - api.thread_new_ = posix_thread_new; - api.thread_join_ = posix_thread_join; - api.ainc_ = posix_ainc; - api.adec_ = posix_adec; - api.mutex_new_ = posix_mutex_new; - api.mutex_free_ = posix_mutex_free; - api.mutex_lock_ = posix_mutex_lock; - api.mutex_unlock_ = posix_mutex_unlock; - api.cond_new_ = posix_cond_new; - api.cond_free_ = posix_cond_free; - api.cond_signal_ = posix_cond_signal; - api.cond_broadcast_ = posix_cond_broadcast; - api.cond_wait_ = posix_cond_wait; - api.sleep_ = posix_sleep; - api.now_ = posix_time_now; - api.enable_high_timer_resolution_ = posix_enable_high_timer_resolution; - - posix_time_setup(); - - ecs_os_set_api(&api); -} +/* Check if single match term has changed */ +static +bool check_match_monitor_term( + ecs_query_t *query, + ecs_query_table_match_t *match, + int32_t term) +{ + ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); -#endif -#endif + if (get_match_monitor(query, match)) { + return true; + } + + int32_t *monitor = match->monitor; + ecs_table_t *table = match->table; + int32_t *dirty_state = flecs_table_get_dirty_state(table); + ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); + table_dirty_state_t cur; + int32_t state = monitor[term]; + if (state == -1) { + return false; + } -#ifdef FLECS_PLECS + if (!term) { + return monitor[0] != dirty_state[0]; + } -#include -#include + get_dirty_state(query, match, term - 1, &cur); + ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); -#define TOK_NEWLINE '\n' -#define TOK_WITH "with" -#define TOK_USING "using" + return monitor[term] != cur.dirty_state[cur.column + 1]; +} -#define STACK_MAX_SIZE (64) +/* Check if any term for match has changed */ +static +bool check_match_monitor( + ecs_query_t *query, + ecs_query_table_match_t *match) +{ + ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); -typedef struct { - const char *name; - const char *code; + if (get_match_monitor(query, match)) { + return true; + } - ecs_entity_t last_predicate; - ecs_entity_t last_subject; - ecs_entity_t last_object; + int32_t *monitor = match->monitor; + ecs_table_t *table = match->table; + int32_t *dirty_state = flecs_table_get_dirty_state(table); + ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); + table_dirty_state_t cur; - ecs_id_t last_assign_id; - ecs_entity_t assign_to; + if (monitor[0] != dirty_state[0]) { + return true; + } - ecs_entity_t scope[STACK_MAX_SIZE]; - ecs_entity_t default_scope_type[STACK_MAX_SIZE]; - ecs_entity_t with[STACK_MAX_SIZE]; - ecs_entity_t using[STACK_MAX_SIZE]; - int32_t with_frames[STACK_MAX_SIZE]; - int32_t using_frames[STACK_MAX_SIZE]; - int32_t sp; - int32_t with_frame; - int32_t using_frame; + ecs_filter_t *f = &query->filter; + int32_t i, term_count = f->term_count_actual; + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &f->terms[i]; + int32_t t = term->index; + if (monitor[t + 1] == -1) { + continue; + } - char *comment; + get_dirty_state(query, match, t, &cur); + ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); - bool with_stmt; - bool scope_assign_stmt; - bool using_stmt; - bool assign_stmt; - bool isa_stmt; + if (monitor[t + 1] != cur.dirty_state[cur.column + 1]) { + return true; + } + } - int32_t errors; -} plecs_state_t; + return false; +} +/* Check if any term for matched table has changed */ static -ecs_entity_t plecs_lookup( - const ecs_world_t *world, - const char *path, - plecs_state_t *state, - bool is_subject) +bool check_table_monitor( + ecs_query_t *query, + ecs_query_table_t *table, + int32_t term) { - ecs_entity_t e = 0; + ecs_query_table_node_t *cur, *end = table->last->node.next; - if (!is_subject) { - int using_scope = state->using_frame - 1; - for (; using_scope >= 0; using_scope--) { - e = ecs_lookup_path_w_sep( - world, state->using[using_scope], path, NULL, NULL, false); - if (e) { - break; + for (cur = &table->first->node; cur != end; cur = cur->next) { + ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur; + if (term == -1) { + if (check_match_monitor(query, match)) { + return true; } + } else { + if (check_match_monitor_term(query, match, term)) { + return true; + } } } - if (!e) { - e = ecs_lookup_path_w_sep(world, 0, path, NULL, NULL, !is_subject); - } - - return e; + return false; } -/* Lookup action used for deserializing entity refs in component values */ -#ifdef FLECS_EXPR static -ecs_entity_t plecs_lookup_action( - const ecs_world_t *world, - const char *path, - void *ctx) +bool check_query_monitor( + ecs_query_t *query) { - return plecs_lookup(world, path, ctx, false); + ecs_table_cache_iter_t it; + if (flecs_table_cache_iter(&query->cache, &it)) { + ecs_query_table_t *qt; + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + if (check_table_monitor(query, qt, -1)) { + return true; + } + } + } + + return false; } -#endif static -void clear_comment( - const char *expr, - const char *ptr, - plecs_state_t *state) +void init_query_monitors( + ecs_query_t *query) { - if (state->comment) { - ecs_parser_error(state->name, expr, ptr - expr, "unused doc comment"); - ecs_os_free(state->comment); - state->comment = NULL; + ecs_query_table_node_t *cur = query->list.first; - state->errors ++; /* Non-fatal error */ + /* Ensure each match has a monitor */ + for (; cur != NULL; cur = cur->next) { + ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur; + get_match_monitor(query, match); } } +/* Builtin group_by callback for Cascade terms. + * This function traces the hierarchy depth of an entity type by following a + * relation upwards (to its 'parents') for as long as those parents have the + * specified component id. + * The result of the function is the number of parents with the provided + * component for a given relation. */ static -const char* parse_fluff( - const char *expr, - const char *ptr, - plecs_state_t *state) +uint64_t group_by_cascade( + ecs_world_t *world, + ecs_type_t type, + ecs_entity_t component, + void *ctx) { - char *comment; - const char *next = ecs_parse_fluff(ptr, &comment); + uint64_t result = 0; + int32_t i, count = ecs_vector_count(type); + ecs_entity_t *array = ecs_vector_first(type, ecs_entity_t); + ecs_term_t *term = ctx; + ecs_entity_t relation = term->subj.set.relation; - if (comment && comment[0] == '/') { - comment = (char*)ecs_parse_fluff(comment + 1, NULL); - int32_t len = (ecs_size_t)(next - comment); - int32_t newline_count = 0; + /* Cascade needs a relation to calculate depth from */ + ecs_check(relation != 0, ECS_INVALID_PARAMETER, NULL); - /* Trim trailing whitespaces */ - while (len >= 0 && (isspace(comment[len - 1]))) { - if (comment[len - 1] == '\n') { - newline_count ++; - if (newline_count > 1) { - /* If newline separates comment from statement, discard */ - len = -1; + /* Should only be used with cascade terms */ + ecs_check(term->subj.set.mask & EcsCascade, ECS_INVALID_PARAMETER, NULL); + + /* Iterate back to front as relations are more likely to occur near the + * end of a type. */ + for (i = count - 1; i >= 0; i --) { + /* Find relation & relation object in entity type */ + if (ECS_HAS_RELATION(array[i], relation)) { + ecs_type_t obj_type = ecs_get_type(world, + ecs_pair_second(world, array[i])); + int32_t j, c_count = ecs_vector_count(obj_type); + ecs_entity_t *c_array = ecs_vector_first(obj_type, ecs_entity_t); + + /* Iterate object type, check if it has the specified component */ + for (j = 0; j < c_count; j ++) { + /* If it has the component, it is part of the tree matched by + * the query, increase depth */ + if (c_array[j] == component) { + result ++; + + /* Recurse to test if the object has matching parents */ + result += group_by_cascade(world, obj_type, component, ctx); break; } } - len --; - } - if (len > 0) { - clear_comment(expr, ptr, state); - state->comment = ecs_os_calloc_n(char, len + 1); - ecs_os_strncpy(state->comment, comment, len); - } else { - ecs_parser_error(state->name, expr, ptr - expr, - "unused doc comment"); - state->errors ++; - } - } else { - if (ptr != next && state->comment) { - clear_comment(expr, ptr, state); + if (j != c_count) { + break; + } + + /* If the id doesn't have a role set, we'll find no more relations */ + } else if (!(array[i] & ECS_ROLE_MASK)) { + break; } } - return next; + return result; +error: + return 0; } static -ecs_entity_t ensure_entity( +int get_comp_and_src( ecs_world_t *world, - plecs_state_t *state, - const char *path, - bool is_subject) + ecs_query_t *query, + int32_t t, + ecs_table_t *table_arg, + ecs_entity_t *component_out, + ecs_entity_t *entity_out, + bool *match_out) { - if (!path) { - return 0; + ecs_entity_t component = 0, entity = 0; + + ecs_term_t *terms = query->filter.terms; + int32_t term_count = query->filter.term_count; + ecs_term_t *term = &terms[t]; + ecs_term_id_t *subj = &term->subj; + ecs_oper_kind_t op = term->oper; + + *match_out = true; + + if (op == EcsNot) { + entity = subj->entity; } - ecs_entity_t e = plecs_lookup(world, path, state, is_subject); - if (!e) { - if (!is_subject) { - /* If this is not a subject create an existing empty id, which - * ensures that scope & with are not applied */ - e = ecs_new_id(world); + if (!subj->entity) { + component = term->id; + } else { + ecs_table_t *table = table_arg; + if (subj->entity != EcsThis) { + table = ecs_get_table(world, subj->entity); } - e = ecs_add_path(world, e, 0, path); - ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL); - } else { - /* If entity exists, make sure it gets the right scope and with */ - if (is_subject) { - ecs_entity_t scope = ecs_get_scope(world); - if (scope) { - ecs_add_pair(world, e, EcsChildOf, scope); - } + if (op == EcsOr) { + for (; t < term_count; t ++) { + term = &terms[t]; - ecs_entity_t with = ecs_get_with(world); - if (with) { - ecs_add_id(world, e, with); - } - } - } + /* Keep iterating until the next non-OR expression */ + if (term->oper != EcsOr) { + t --; + break; + } - return e; -} + if (!component) { + ecs_entity_t source = 0; + int32_t result = ecs_search_relation(world, table, + 0, term->id, subj->set.relation, subj->set.min_depth, + subj->set.max_depth, &source, NULL, NULL); -static -bool pred_is_subj( - ecs_term_t *term, - plecs_state_t *state) -{ - if (term->subj.name != NULL) { - return false; - } - if (term->obj.name != NULL) { - return false; - } - if (term->subj.set.mask == EcsNothing) { - return false; - } - if (state->with_stmt) { - return false; - } - if (state->assign_stmt) { - return false; - } - if (state->isa_stmt) { - return false; - } - if (state->using_stmt) { - return false; - } + if (result != -1) { + component = term->id; + } - return true; -} + if (source) { + entity = source; + } + } + } + } else { + component = term->id; -/* Set masks aren't useful in plecs, so translate them back to entity names */ -static -const char* set_mask_to_name( - ecs_flags32_t flags) -{ - if (flags == EcsSelf) { - return "self"; - } else if (flags == EcsAll) { - return "all"; - } else if (flags == EcsSuperSet) { - return "super"; - } else if (flags == EcsSubSet) { - return "sub"; - } else if (flags == EcsCascade || flags == (EcsSuperSet|EcsCascade)) { - return "cascade"; - } else if (flags == EcsParent) { - return "parent"; - } - return NULL; -} + ecs_entity_t source = 0; + bool result = ecs_search_relation(world, table, 0, component, + subj->set.relation, subj->set.min_depth, subj->set.max_depth, + &source, NULL, NULL) != -1; -static -int create_term( - ecs_world_t *world, - ecs_term_t *term, - const char *name, - const char *expr, - int64_t column, - plecs_state_t *state) -{ - state->last_subject = 0; - state->last_predicate = 0; - state->last_object = 0; - state->last_assign_id = 0; + *match_out = result; - const char *pred_name = term->pred.name; - const char *subj_name = term->subj.name; - const char *obj_name = term->obj.name; + if (op == EcsNot) { + result = !result; + } - if (!subj_name) { - subj_name = set_mask_to_name(term->subj.set.mask); - } - if (!obj_name) { - obj_name = set_mask_to_name(term->obj.set.mask); - } + /* Optional terms may not have the component. *From terms contain + * the id of a type of which the contents must match, but the type + * itself does not need to match. */ + if (op == EcsOptional || op == EcsAndFrom || op == EcsOrFrom || + op == EcsNotFrom) + { + result = true; + } - if (!ecs_term_id_is_set(&term->pred)) { - ecs_parser_error(name, expr, column, "missing predicate in expression"); - return -1; + /* Table has already been matched, so unless column is optional + * any components matched from the table must be available. */ + if (table == table_arg) { + ecs_assert(result == true, ECS_INTERNAL_ERROR, NULL); + } + + if (source) { + entity = source; + } + } + + if (subj->entity != EcsThis) { + entity = subj->entity; + } } - if (state->assign_stmt && term->subj.entity != EcsThis) { - ecs_parser_error(name, expr, column, - "invalid statement in assign statement"); - return -1; + if (entity == EcsThis) { + entity = 0; } - bool pred_as_subj = pred_is_subj(term, state); + *component_out = component; + *entity_out = entity; - ecs_entity_t pred = ensure_entity(world, state, pred_name, pred_as_subj); - ecs_entity_t subj = ensure_entity(world, state, subj_name, true); - ecs_entity_t obj = 0; + return t; +} - if (ecs_term_id_is_set(&term->obj)) { - obj = ensure_entity(world, state, obj_name, - state->assign_stmt == false); - } +typedef struct pair_offset_t { + int32_t index; + int32_t count; +} pair_offset_t; - if (state->assign_stmt || state->isa_stmt) { - subj = state->assign_to; - } +/* Get index for specified pair. Take into account that a pair can be matched + * multiple times per table, by keeping an offset of the last found index */ +static +int32_t get_pair_index( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_id_t pair, + int32_t column_index, + pair_offset_t *pair_offsets, + int32_t count) +{ + int32_t result; - if (state->isa_stmt && obj) { - ecs_parser_error(name, expr, column, - "invalid object in inheritance statement"); - return -1; + /* The count variable keeps track of the number of times a pair has been + * matched with the current table. Compare the count to check if the index + * was already resolved for this iteration */ + if (pair_offsets[column_index].count == count) { + /* If it was resolved, return the last stored index. Subtract one as the + * index is offset by one, to ensure we're not getting stuck on the same + * index. */ + result = pair_offsets[column_index].index - 1; + } else { + /* First time for this iteration that the pair index is resolved, look + * it up in the type. */ + result = ecs_search_offset(world, table, + pair_offsets[column_index].index, pair, 0); + pair_offsets[column_index].index = result + 1; + pair_offsets[column_index].count = count; } - if (state->using_stmt && (obj || subj)) { - ecs_parser_error(name, expr, column, - "invalid predicate/object in using statement"); - return -1; - } + return result; +} - if (state->isa_stmt) { - pred = ecs_pair(EcsIsA, pred); - } +static +int32_t get_component_index( + ecs_world_t *world, + ecs_table_t *table, + ecs_type_t table_type, + ecs_entity_t *component_out, + int32_t column_index, + ecs_oper_kind_t op, + pair_offset_t *pair_offsets, + int32_t count) +{ + int32_t result = 0; + ecs_entity_t component = *component_out; - if (subj) { - if (!obj) { - ecs_add_id(world, subj, pred); - state->last_assign_id = pred; - } else { - ecs_add_pair(world, subj, pred, obj); - state->last_object = obj; - state->last_assign_id = ecs_pair(pred, obj); - } - state->last_predicate = pred; - state->last_subject = subj; + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - pred_as_subj = false; - } else { - if (!obj) { - /* If no subject or object were provided, use predicate as subj - * unless the expression explictly excluded the subject */ - if (pred_as_subj) { - state->last_subject = pred; - subj = pred; + if (component) { + /* If requested component is a case, find the corresponding switch to + * lookup in the table */ + if (ECS_HAS_ROLE(component, CASE)) { + ecs_entity_t sw = ECS_PAIR_FIRST(component); + result = ecs_search(world, table, ECS_SWITCH | sw, 0); + ecs_assert(result != -1, ECS_INTERNAL_ERROR, NULL); + } else + if (ECS_HAS_ROLE(component, PAIR)) { + ecs_entity_t rel = ECS_PAIR_FIRST(component); + ecs_entity_t obj = ECS_PAIR_SECOND(component); + + /* Both the relationship and the object of the pair must be set */ + ecs_assert(rel != 0, ECS_INVALID_PARAMETER, NULL); + ecs_assert(obj != 0, ECS_INVALID_PARAMETER, NULL); + + if (rel == EcsWildcard || obj == EcsWildcard) { + ecs_assert(pair_offsets != NULL, ECS_INTERNAL_ERROR, NULL); + + /* Get index of pair. Start looking from the last pair index + * as this may not be the first instance of the pair. */ + result = get_pair_index(world, table, component, column_index, + pair_offsets, count); + + if (result != -1) { + /* If component of current column is a pair, get the actual + * pair type for the table, so the system can see which + * component the pair was applied to */ + ecs_entity_t *pair = ecs_vector_get( + table_type, ecs_entity_t, result); + *component_out = *pair; + + /* Check if the pair is a tag or whether it has data */ + if (ecs_get(world, rel, EcsComponent) == NULL) { + /* If pair has no data associated with it, use the + * component to which the pair has been added */ + component = ECS_PAIR_SECOND(*pair); + } else { + component = rel; + } + } } else { - state->last_predicate = pred; - pred_as_subj = false; + /* If the low part is a regular entity (component), then + * this query exactly matches a single pair instance. In + * this case we can simply do a lookup of the pair + * identifier in the table type. */ + result = ecs_search(world, table, component, 0); } } else { - state->last_predicate = pred; - state->last_object = obj; - pred_as_subj = false; + /* Get column index for component */ + result = ecs_search(world, table, component, 0); } - } - /* If this is a with clause (the list of entities between 'with' and scope - * open), add subject to the array of with frames */ - if (state->with_stmt) { - ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL); - ecs_id_t id; + /* If column is found, add one to the index, as column zero in + * a table is reserved for entity id's */ + if (result != -1) { + result ++; + } - if (obj) { - id = ecs_pair(pred, obj); - } else { - id = pred; + /* ecs_table_column_offset may return -1 if the component comes + * from a prefab. If so, the component will be resolved as a + * reference (see below) */ + } + + if (op == EcsAndFrom || op == EcsOrFrom || op == EcsNotFrom) { + result = 0; + } else if (op == EcsOptional) { + /* If table doesn't have the field, mark it as no data */ + if (-1 == ecs_search_relation(world, table, 0, component, EcsIsA, + 0, 0, 0, 0, 0)) + { + result = 0; } + } - state->with[state->with_frame ++] = id; - - } else if (state->using_stmt) { - ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(obj == 0, ECS_INTERNAL_ERROR, NULL); + return result; +} - state->using[state->using_frame ++] = pred; - state->using_frames[state->sp] = state->using_frame; +static +ecs_vector_t* add_ref( + ecs_world_t *world, + ecs_query_t *query, + ecs_vector_t *references, + ecs_term_t *term, + ecs_entity_t component, + ecs_entity_t entity) +{ + ecs_ref_t *ref = ecs_vector_add(&references, ecs_ref_t); + ecs_term_id_t *subj = &term->subj; - /* If this is not a with/using clause, add with frames to subject */ - } else { - if (subj) { - int32_t i, frame_count = state->with_frames[state->sp]; - for (i = 0; i < frame_count; i ++) { - ecs_add_id(world, subj, state->with[i]); - } - } + if (!(subj->set.mask & EcsCascade)) { + ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); } + + *ref = (ecs_ref_t){0}; + ref->entity = entity; + ref->component = component; - /* If an id was provided by itself, add default scope type to it */ - ecs_entity_t default_scope_type = state->default_scope_type[state->sp]; - if (pred_as_subj && default_scope_type) { - ecs_add_id(world, subj, default_scope_type); - } + const EcsComponent *c_info = flecs_component_from_id(world, component); + if (c_info) { + if (c_info->size && subj->entity != 0) { + if (entity) { + ecs_get_ref_id(world, ref, entity, component); + } - /* If a comment preceded the statement, add it as a brief description */ -#ifdef FLECS_DOC - if (subj && state->comment) { - ecs_doc_set_brief(world, subj, state->comment); - ecs_os_free(state->comment); - state->comment = NULL; + query->flags |= EcsQueryHasRefs; + } } -#endif - return 0; + return references; } static -const char* parse_inherit_stmt( - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) +int32_t get_pair_count( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_entity_t pair) { - if (state->isa_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "cannot nest inheritance"); - return NULL; - } - - if (!state->last_subject) { - ecs_parser_error(name, expr, ptr - expr, - "missing entity to assign inheritance to"); - return NULL; + int32_t i = -1, result = 0; + while (-1 != (i = ecs_search_offset(world, table, i + 1, pair, 0))) { + result ++; } - - state->isa_stmt = true; - state->assign_to = state->last_subject; - return ptr; + return result; } +/* For each pair that the query subscribes for, count the occurrences in the + * table. Cardinality of subscribed for pairs must be the same as in the table + * or else the table won't match. */ static -const char* parse_assign_expr( - ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) +int32_t count_pairs( + const ecs_world_t *world, + const ecs_query_t *query, + const ecs_table_t *table) { - (void)world; - - if (!state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "unexpected value outside of assignment statement"); - return NULL; - } - - ecs_id_t assign_id = state->last_assign_id; - if (!assign_id) { - ecs_parser_error(name, expr, ptr - expr, - "missing type for assignment statement"); - return NULL; - } - -#ifndef FLECS_EXPR - ecs_parser_error(name, expr, ptr - expr, - "cannot parse value, missing FLECS_EXPR addon"); - return NULL; -#else - ecs_entity_t assign_to = state->assign_to; - if (!assign_to) { - assign_to = state->last_subject; - } + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count; + int32_t first_count = 0, pair_count = 0; - if (!assign_to) { - ecs_parser_error(name, expr, ptr - expr, - "missing entity to assign to"); - return NULL; - } + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; - ecs_entity_t type = ecs_get_typeid(world, assign_id); - if (!type) { - char *id_str = ecs_id_str(world, assign_id); - ecs_parser_error(name, expr, ptr - expr, - "invalid assignment, '%s' is not a type", id_str); - ecs_os_free(id_str); - return NULL; - } + if (!ECS_HAS_ROLE(term->id, PAIR)) { + continue; + } - void *value_ptr = ecs_get_mut_id( - world, assign_to, assign_id, NULL); + if (term->subj.entity != EcsThis) { + continue; + } - ptr = ecs_parse_expr(world, ptr, type, value_ptr, - &(ecs_parse_expr_desc_t) { - .name = name, - .expr = expr, - .lookup_action = plecs_lookup_action, - .lookup_ctx = state - }); - if (!ptr) { - return NULL; + if (ecs_id_is_wildcard(term->id)) { + pair_count = get_pair_count(world, table, term->id); + if (!first_count) { + first_count = pair_count; + } else { + if (first_count != pair_count) { + /* The pairs that this query subscribed for occur in the + * table but don't have the same cardinality. Ignore the + * table. This could typically happen for empty tables along + * a path in the table graph. */ + return -1; + } + } + } } - ecs_modified_id(world, assign_to, assign_id); -#endif - - return ptr; + return first_count; } static -const char* parse_assign_stmt( +ecs_type_t get_term_type( ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) + ecs_term_t *term, + ecs_entity_t component) { - (void)world; + ecs_oper_kind_t oper = term->oper; + ecs_assert(oper == EcsAndFrom || oper == EcsOrFrom || oper == EcsNotFrom, + ECS_INTERNAL_ERROR, NULL); + (void)oper; - state->isa_stmt = false; + const EcsType *type = ecs_get(world, component, EcsType); + if (type) { + return type->normalized->type; + } else { + return ecs_get_type(world, component); + } +} - /* Component scope (add components to entity) */ - if (!state->last_subject) { - ecs_parser_error(name, expr, ptr - expr, - "missing entity to assign to"); - return NULL; - } +/** Add table to system, compute offsets for system components in table it */ +static +void add_table( + ecs_world_t *world, + ecs_query_t *query, + ecs_table_t *table) +{ + ecs_type_t table_type = NULL; + ecs_term_t *terms = query->filter.terms; + int32_t t, c, term_count = query->filter.term_count; - if (state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid assign statement in assign statement"); - return NULL; + if (table) { + table_type = table->type; } - if (!state->scope_assign_stmt) { - state->assign_to = state->last_subject; + int32_t pair_cur = 0, pair_count = count_pairs(world, query, table); + + /* If the query has pairs, we need to account for the fact that a table may + * have multiple components to which the pair is applied, which means the + * table has to be registered with the query multiple times, with different + * table columns. If so, allocate a small array for each pair in which the + * last added table index of the pair is stored, so that in the next + * iteration we can start the search from the correct offset type. */ + pair_offset_t *pair_offsets = NULL; + if (pair_count) { + pair_offsets = ecs_os_calloc( + ECS_SIZEOF(pair_offset_t) * term_count); } - state->assign_stmt = true; - - /* Assignment without a preceding component */ - if (ptr[0] == '{') { - ecs_entity_t type = 0; + ecs_query_table_match_t *table_data; + ecs_vector_t *references = NULL; - if (state->scope_assign_stmt) { - ecs_assert(state->assign_to == ecs_get_scope(world), - ECS_INTERNAL_ERROR, NULL); + ecs_query_table_t *qt = ecs_os_calloc_t(ecs_query_table_t); + ecs_table_cache_insert(&query->cache, table, &qt->hdr); + +add_pair: + table_data = cache_add(qt); + table_data->table = table; + if (table) { + table_type = table->type; + } + + if (term_count) { + /* Array that contains the system column to table column mapping */ + table_data->columns = ecs_os_calloc_n(int32_t, query->filter.term_count_actual); + ecs_assert(table_data->columns != NULL, ECS_OUT_OF_MEMORY, NULL); + + /* Store the components of the matched table. In the case of OR expressions, + * components may differ per matched table. */ + table_data->ids = ecs_os_calloc_n(ecs_entity_t, query->filter.term_count_actual); + ecs_assert(table_data->ids != NULL, ECS_OUT_OF_MEMORY, NULL); + + /* Cache subject (source) entity ids for components */ + table_data->subjects = ecs_os_calloc_n(ecs_entity_t, query->filter.term_count_actual); + ecs_assert(table_data->subjects != NULL, ECS_OUT_OF_MEMORY, NULL); + + /* Cache subject (source) entity ids for components */ + table_data->sizes = ecs_os_calloc_n(ecs_size_t, query->filter.term_count_actual); + ecs_assert(table_data->sizes != NULL, ECS_OUT_OF_MEMORY, NULL); + } + + /* Walk columns parsed from the system signature */ + c = 0; + for (t = 0; t < term_count; t ++) { + ecs_term_t *term = &terms[t]; + ecs_term_id_t subj = term->subj; + ecs_entity_t entity = 0, component = 0; + ecs_oper_kind_t op = term->oper; + + if (op == EcsNot) { + subj.entity = 0; } - /* If we're in a scope & last_subject is a type, assign to scope */ - if (ecs_get_scope(world) != 0) { - type = ecs_get_typeid(world, state->last_subject); - if (type != 0) { - type = state->last_subject; + /* Get actual component and component source for current column */ + bool match; + t = get_comp_and_src(world, query, t, table, &component, &entity, &match); + + /* This column does not retrieve data from a static entity */ + if (!entity && subj.entity) { + int32_t index = get_component_index(world, table, table_type, + &component, c, op, pair_offsets, pair_cur + 1); + + if (index == -1) { + if (op == EcsOptional && subj.set.mask == EcsSelf) { + index = 0; + } + } else { + if (op == EcsOptional && !(subj.set.mask & EcsSelf)) { + index = 0; + } + } + + table_data->columns[c] = index; + + /* If the column is a case, we should only iterate the entities in + * the column for this specific case. Add a sparse column with the + * case id so we can find the correct entities when iterating */ + if (ECS_HAS_ROLE(component, CASE)) { + flecs_sparse_column_t *sc = ecs_vector_add( + &table_data->sparse_columns, flecs_sparse_column_t); + sc->signature_column_index = t; + sc->sw_case = ECS_PAIR_SECOND(component); + sc->sw_column = NULL; + } + + /* If table has a disabled bitmask for components, check if there is + * a disabled column for the queried for component. If so, cache it + * in a vector as the iterator will need to skip the entity when the + * component is disabled. */ + if (index && (table && table->flags & EcsTableHasDisabled)) { + ecs_entity_t bs_id = + (component & ECS_COMPONENT_MASK) | ECS_DISABLED; + int32_t bs_index = ecs_search(world, table, bs_id, 0); + if (bs_index != -1) { + flecs_bitset_column_t *elem = ecs_vector_add( + &table_data->bitset_columns, flecs_bitset_column_t); + elem->column_index = bs_index; + elem->bs_column = NULL; + } } } - /* If type hasn't been set yet, check if scope has default type */ - if (!type && !state->scope_assign_stmt) { - type = state->default_scope_type[state->sp]; + ecs_entity_t type_id = ecs_get_typeid(world, component); + if (!type_id && !(ECS_ROLE_MASK & component)) { + type_id = component; } - /* If no type has been found still, check if last with id is a type */ - if (!type && !state->scope_assign_stmt) { - int32_t with_frame_count = state->with_frames[state->sp]; - if (with_frame_count) { - type = state->with[with_frame_count - 1]; + if (entity || table_data->columns[c] == -1 || subj.set.mask & EcsCascade) { + if (type_id) { + references = add_ref(world, query, references, term, + component, entity); + table_data->columns[c] = -ecs_vector_count(references); + } + + table_data->subjects[c] = entity; + flecs_add_flag(world, entity, ECS_FLAG_OBSERVED); + + if (!match) { + ecs_ref_t *ref = ecs_vector_last(references, ecs_ref_t); + ref->entity = 0; } } - if (!type) { - ecs_parser_error(name, expr, ptr - expr, - "missing type for assignment"); - return NULL; + if (type_id) { + const EcsComponent *cptr = ecs_get(world, type_id, EcsComponent); + if (!cptr || !cptr->size) { + int32_t column = table_data->columns[c]; + if (column < 0) { + ecs_ref_t *r = ecs_vector_get( + references, ecs_ref_t, -column - 1); + r->component = 0; + } + } + + if (cptr) { + table_data->sizes[c] = cptr->size; + } else { + table_data->sizes[c] = 0; + } + } else { + table_data->sizes[c] = 0; } - state->last_assign_id = type; + + if (ECS_HAS_ROLE(component, SWITCH)) { + table_data->sizes[c] = ECS_SIZEOF(ecs_entity_t); + } else if (ECS_HAS_ROLE(component, CASE)) { + table_data->sizes[c] = ECS_SIZEOF(ecs_entity_t); + } + + table_data->ids[c] = component; + + c ++; } - return ptr; -} + if (references) { + ecs_size_t ref_size = ECS_SIZEOF(ecs_ref_t) * ecs_vector_count(references); + table_data->references = ecs_os_malloc(ref_size); + ecs_os_memcpy(table_data->references, + ecs_vector_first(references, ecs_ref_t), ref_size); + ecs_vector_free(references); + references = NULL; + } -static -const char* parse_using_stmt( - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) -{ - if (state->isa_stmt || state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid usage of using keyword"); - return NULL; + /* Insert match to iteration list if table is not empty */ + if (!table || ecs_table_count(table) != 0) { + ecs_assert(table == qt->hdr.table, ECS_INTERNAL_ERROR, NULL); + insert_table_node(query, &table_data->node); } - /* Add following expressions to using list */ - state->using_stmt = true; + /* Use tail recursion when adding table for multiple pairs */ + pair_cur ++; + if (pair_cur < pair_count) { + goto add_pair; + } - return ptr + 5; + if (pair_offsets) { + ecs_os_free(pair_offsets); + } } static -const char* parse_with_stmt( - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) +bool match_term( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_term_t *term) { - if (state->isa_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid with after inheritance"); - return NULL; + ecs_term_id_t *subj = &term->subj; + + /* If term has no subject, there's nothing to match */ + if (!subj->entity) { + return true; } - if (state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid with in assign_stmt"); - return NULL; + if (term->subj.entity != EcsThis) { + table = ecs_get_table(world, subj->entity); } - /* Add following expressions to with list */ - state->with_stmt = true; - return ptr + 5; + return ecs_search_relation( + world, table, 0, term->id, subj->set.relation, + subj->set.min_depth, subj->set.max_depth, NULL, NULL, NULL) != -1; } -static -const char* parse_scope_open( - ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) +/* Match table with query */ +bool flecs_query_match( + const ecs_world_t *world, + const ecs_table_t *table, + const ecs_query_t *query) { - state->isa_stmt = false; + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + if (!table->type) { + return false; + } - if (state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid scope in assign_stmt"); - return NULL; + if (!(query->flags & EcsQueryNeedsTables)) { + return false; } - state->sp ++; + /* Don't match disabled entities */ + if (!(query->flags & EcsQueryMatchDisabled) && ecs_search( + world, table, EcsDisabled, 0) != -1) + { + return false; + } - ecs_entity_t scope = 0; - ecs_entity_t default_scope_type = 0; + /* Don't match prefab entities */ + if (!(query->flags & EcsQueryMatchPrefab) && ecs_search( + world, table, EcsPrefab, 0) != -1) + { + return false; + } - if (!state->with_stmt) { - if (state->last_subject) { - scope = state->last_subject; - ecs_set_scope(world, state->last_subject); + /* Check if pair cardinality matches pairs in query, if any */ + if (count_pairs(world, query, table) == -1) { + return false; + } - /* Check if scope has a default child component */ - ecs_entity_t def_type_src = ecs_get_object_for_id(world, scope, - 0, ecs_pair(EcsDefaultChildComponent, EcsWildcard)); + ecs_term_t *terms = query->filter.terms; + int32_t i, term_count = query->filter.term_count; - if (def_type_src) { - default_scope_type = ecs_get_object( - world, def_type_src, EcsDefaultChildComponent, 0); + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; + ecs_oper_kind_t oper = term->oper; + + if (term->subj.var != EcsVarIsVariable || term->subj.entity != EcsThis){ + /* If term is matched on entity instead of This variable, it does + * not affect whether the table is matched */ + continue; + } + + if (oper == EcsAnd) { + if (!match_term(world, table, term)) { + return false; } - } else { - if (state->last_object) { - scope = ecs_pair( - state->last_predicate, state->last_object); - ecs_set_with(world, scope); - } else { - if (state->last_predicate) { - scope = ecs_pair(EcsChildOf, state->last_predicate); + + } else if (oper == EcsNot) { + if (match_term(world, table, term)) { + return false; + } + + } else if (oper == EcsOr) { + bool match = false; + + for (; i < term_count; i ++) { + term = &terms[i]; + if (term->oper != EcsOr) { + i --; + break; + } + + if (!match && match_term( world, table, term)) { + match = true; } - ecs_set_scope(world, state->last_predicate); } - } - state->scope[state->sp] = scope; - state->default_scope_type[state->sp] = default_scope_type; - } else { - state->scope[state->sp] = state->scope[state->sp - 1]; - state->default_scope_type[state->sp] = - state->default_scope_type[state->sp - 1]; - } + if (!match) { + return false; + } + + } else if (oper == EcsAndFrom || oper == EcsOrFrom || oper == EcsNotFrom) { + ecs_type_t type = get_term_type((ecs_world_t*)world, term, term->id); + int32_t match_count = 0, j, count = ecs_vector_count(type); + ecs_entity_t *ids = ecs_vector_first(type, ecs_entity_t); - state->using_frames[state->sp] = state->using_frame; - state->with_frames[state->sp] = state->with_frame; - state->with_stmt = false; + for (j = 0; j < count; j ++) { + ecs_term_t tmp_term = *term; + tmp_term.oper = EcsAnd; + tmp_term.id = ids[j]; + tmp_term.pred.entity = ids[j]; - return ptr; + if (match_term(world, table, &tmp_term)) { + match_count ++; + } + } + + if (oper == EcsAndFrom && match_count != count) { + return false; + } + if (oper == EcsOrFrom && match_count == 0) { + return false; + } + if (oper == EcsNotFrom && match_count != 0) { + return false; + } + } + } + + return true; } +/** Match existing tables against system (table is created before system) */ static -const char* parse_scope_close( +void match_tables( ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) + ecs_query_t *query) { - if (state->isa_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "invalid '}' after inheritance statement"); - return NULL; - } + int32_t i, count = flecs_sparse_count(&world->store.tables); - if (state->assign_stmt) { - ecs_parser_error(name, expr, ptr - expr, - "unfinished assignment before }"); - return NULL; + for (i = 0; i < count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense( + &world->store.tables, ecs_table_t, i); + + if (flecs_query_match(world, table, query)) { + add_table(world, query, table); + } } +} - state->scope[state->sp] = 0; - state->default_scope_type[state->sp] = 0; - state->sp --; +static +int32_t qsort_partition( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + ecs_entity_t *entities, + void *ptr, + int32_t elem_size, + int32_t lo, + int32_t hi, + ecs_order_by_action_t compare) +{ + int32_t p = (hi + lo) / 2; + void *pivot = ECS_ELEM(ptr, elem_size, p); + ecs_entity_t pivot_e = entities[p]; + int32_t i = lo - 1, j = hi + 1; + void *el; - if (state->sp < 0) { - ecs_parser_error(name, expr, ptr - expr, "invalid } without a {"); - return NULL; - } +repeat: + { + do { + i ++; + el = ECS_ELEM(ptr, elem_size, i); + } while ( compare(entities[i], el, pivot_e, pivot) < 0); - ecs_id_t id = state->scope[state->sp]; + do { + j --; + el = ECS_ELEM(ptr, elem_size, j); + } while ( compare(entities[j], el, pivot_e, pivot) > 0); - if (!id || ECS_HAS_ROLE(id, PAIR)) { - ecs_set_with(world, id); + if (i >= j) { + return j; + } + + flecs_table_swap(world, table, data, i, j); + + if (p == i) { + pivot = ECS_ELEM(ptr, elem_size, j); + pivot_e = entities[j]; + } else if (p == j) { + pivot = ECS_ELEM(ptr, elem_size, i); + pivot_e = entities[i]; + } + + goto repeat; } +} - if (!id || !ECS_HAS_ROLE(id, PAIR)) { - ecs_set_scope(world, id); +static +void qsort_array( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + ecs_entity_t *entities, + void *ptr, + int32_t size, + int32_t lo, + int32_t hi, + ecs_order_by_action_t compare) +{ + if ((hi - lo) < 1) { + return; } - state->with_frame = state->with_frames[state->sp]; - state->using_frame = state->using_frames[state->sp]; - state->last_subject = 0; - state->assign_stmt = false; + int32_t p = qsort_partition( + world, table, data, entities, ptr, size, lo, hi, compare); - return ptr; + qsort_array(world, table, data, entities, ptr, size, lo, p, compare); + + qsort_array(world, table, data, entities, ptr, size, p + 1, hi, compare); } static -const char *parse_plecs_term( +void sort_table( ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) + ecs_table_t *table, + int32_t column_index, + ecs_order_by_action_t compare) { - ecs_term_t term = {0}; - ecs_entity_t scope = ecs_get_scope(world); - - /* If first character is a (, this should be interpreted as an id assigned - * to the current scope if: - * - this is not already an assignment: "Foo = (Hello, World)" - * - this is in a scope - */ - bool scope_assignment = (ptr[0] == '(') && !state->assign_stmt && scope != 0; - - ptr = ecs_parse_term(world, name, expr, ptr, &term); - if (!ptr) { - return NULL; + ecs_data_t *data = &table->storage; + if (!data->entities) { + /* Nothing to sort */ + return; } - if (!ecs_term_is_initialized(&term)) { - ecs_parser_error(name, expr, ptr - expr, "expected identifier"); - return NULL; /* No term found */ + int32_t count = flecs_table_data_count(data); + if (count < 2) { + return; } - /* Lookahead to check if this is an implicit scope assignment (no parens) */ - if (ptr[0] == '=') { - const char *tptr = ecs_parse_fluff(ptr + 1, NULL); - if (tptr[0] == '{') { - ecs_entity_t pred = plecs_lookup( - world, term.pred.name, state, false); - ecs_entity_t obj = plecs_lookup( - world, term.obj.name, state, false); - ecs_id_t id = 0; - if (pred && obj) { - id = ecs_pair(pred, obj); - } else if (pred) { - id = pred; - } + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - if (id && (ecs_get_typeid(world, id) != 0)) { - scope_assignment = true; - } - } + void *ptr = NULL; + int32_t size = 0; + if (column_index != -1) { + ecs_column_t *column = &data->columns[column_index]; + size = column->size; + ptr = ecs_vector_first_t(column->data, size, column->alignment); } - bool prev = state->assign_stmt; - if (scope_assignment) { - state->assign_stmt = true; - state->assign_to = scope; - } - if (create_term(world, &term, name, expr, (ptr - expr), state)) { - ecs_term_fini(&term); - return NULL; /* Failed to create term */ - } - if (scope_assignment) { - state->last_subject = state->last_assign_id; - state->scope_assign_stmt = true; - } - state->assign_stmt = prev; + qsort_array(world, table, data, entities, ptr, size, 0, count - 1, compare); +} - ecs_term_fini(&term); +/* Helper struct for building sorted table ranges */ +typedef struct sort_helper_t { + ecs_query_table_match_t *match; + ecs_entity_t *entities; + const void *ptr; + int32_t row; + int32_t elem_size; + int32_t count; + bool shared; +} sort_helper_t; - return ptr; +static +const void* ptr_from_helper( + sort_helper_t *helper) +{ + ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL); + ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL); + if (helper->shared) { + return helper->ptr; + } else { + return ECS_ELEM(helper->ptr, helper->elem_size, helper->row); + } } static -const char* parse_stmt( - ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - plecs_state_t *state) +ecs_entity_t e_from_helper( + sort_helper_t *helper) { - state->assign_stmt = false; - state->scope_assign_stmt = false; - state->isa_stmt = false; - state->with_stmt = false; - state->using_stmt = false; - state->last_subject = 0; - state->last_predicate = 0; - state->last_object = 0; - - ptr = parse_fluff(expr, ptr, state); - - char ch = ptr[0]; - - if (!ch) { - goto done; - } else if (ch == '{') { - ptr = parse_fluff(expr, ptr + 1, state); - goto scope_open; - } else if (ch == '}') { - ptr = parse_fluff(expr, ptr + 1, state); - goto scope_close; - } else if (ch == '(') { - goto term_expr; - } else if (!ecs_os_strncmp(ptr, TOK_USING " ", 5)) { - ptr = parse_using_stmt(name, expr, ptr, state); - if (!ptr) goto error; - goto term_expr; - } else if (!ecs_os_strncmp(ptr, TOK_WITH " ", 5)) { - ptr = parse_with_stmt(name, expr, ptr, state); - if (!ptr) goto error; - goto term_expr; + if (helper->row < helper->count) { + return helper->entities[helper->row]; } else { - goto term_expr; + return 0; } +} -term_expr: - if (!ptr[0]) { - goto done; +static +void build_sorted_table_range( + ecs_query_t *query, + ecs_query_table_list_t *list) +{ + ecs_world_t *world = query->world; + ecs_entity_t id = query->order_by_component; + ecs_order_by_action_t compare = query->order_by; + + if (!list->count) { + return; } - if (!(ptr = parse_plecs_term(world, name, ptr, ptr, state))) { - goto error; - } + int to_sort = 0; - ptr = parse_fluff(expr, ptr, state); + sort_helper_t *helper = ecs_os_malloc_n(sort_helper_t, list->count); + ecs_query_table_node_t *cur, *end = list->last->next; + for (cur = list->first; cur != end; cur = cur->next) { + ecs_query_table_match_t *match = cur->match; + ecs_table_t *table = match->table; + ecs_data_t *data = &table->storage; + ecs_vector_t *entities; - if (ptr[0] == '{' && !isspace(ptr[-1])) { - /* A '{' directly after an identifier (no whitespace) is a literal */ - goto assign_expr; - } + if (!(entities = data->entities) || !ecs_table_count(table)) { + continue; + } - if (!state->using_stmt) { - if (ptr[0] == ':') { - ptr = parse_fluff(expr, ptr + 1, state); - goto inherit_stmt; - } else if (ptr[0] == '=') { - ptr = parse_fluff(expr, ptr + 1, state); - goto assign_stmt; - } else if (ptr[0] == ',') { - ptr = parse_fluff(expr, ptr + 1, state); - goto term_expr; - } else if (ptr[0] == '{') { - state->assign_stmt = false; - ptr = parse_fluff(expr, ptr + 1, state); - goto scope_open; + int32_t index = -1; + if (id) { + index = ecs_search(world, table->storage_table, id, 0); + } + + if (index != -1) { + ecs_column_t *column = &data->columns[index]; + int16_t size = column->size; + int16_t align = column->alignment; + helper[to_sort].ptr = ecs_vector_first_t(column->data, size, align); + helper[to_sort].elem_size = size; + helper[to_sort].shared = false; + } else if (id) { + /* Find component in prefab */ + ecs_entity_t base = 0; + ecs_search_relation(world, table, 0, id, + EcsIsA, 1, 0, &base, NULL, NULL); + + /* If a base was not found, the query should not have allowed using + * the component for sorting */ + ecs_assert(base != 0, ECS_INTERNAL_ERROR, NULL); + + const EcsComponent *cptr = ecs_get(world, id, EcsComponent); + ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); + + helper[to_sort].ptr = ecs_get_id(world, base, id); + helper[to_sort].elem_size = cptr->size; + helper[to_sort].shared = true; + } else { + helper[to_sort].ptr = NULL; + helper[to_sort].elem_size = 0; + helper[to_sort].shared = false; } + + helper[to_sort].match = match; + helper[to_sort].entities = ecs_vector_first(entities, ecs_entity_t); + helper[to_sort].row = 0; + helper[to_sort].count = ecs_table_count(table); + to_sort ++; } - state->assign_stmt = false; - goto done; + ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL); -inherit_stmt: - ptr = parse_inherit_stmt(name, expr, ptr, state); - if (!ptr) goto error; + bool proceed; + do { + int32_t j, min = 0; + proceed = true; - /* Expect base identifier */ - goto term_expr; + ecs_entity_t e1; + while (!(e1 = e_from_helper(&helper[min]))) { + min ++; + if (min == to_sort) { + proceed = false; + break; + } + } -assign_stmt: - ptr = parse_assign_stmt(world, name, expr, ptr, state); - if (!ptr) goto error; + if (!proceed) { + break; + } - ptr = parse_fluff(expr, ptr, state); + for (j = min + 1; j < to_sort; j++) { + ecs_entity_t e2 = e_from_helper(&helper[j]); + if (!e2) { + continue; + } - /* Assignment without a preceding component */ - if (ptr[0] == '{') { - goto assign_expr; - } + const void *ptr1 = ptr_from_helper(&helper[min]); + const void *ptr2 = ptr_from_helper(&helper[j]); - /* Expect component identifiers */ - goto term_expr; + if (compare(e1, ptr1, e2, ptr2) > 0) { + min = j; + e1 = e_from_helper(&helper[min]); + } + } -assign_expr: - ptr = parse_assign_expr(world, name, expr, ptr, state); - if (!ptr) goto error; + sort_helper_t *cur_helper = &helper[min]; + if (!cur || cur->match != cur_helper->match) { + cur = ecs_vector_add(&query->table_slices, ecs_query_table_node_t); + ecs_assert(cur != NULL, ECS_INTERNAL_ERROR, NULL); + cur->match = cur_helper->match; + cur->offset = cur_helper->row; + cur->count = 1; + } else { + cur->count ++; + } - ptr = parse_fluff(expr, ptr, state); - if (ptr[0] == ',') { - ptr ++; - goto term_expr; - } else if (ptr[0] == '{') { - state->assign_stmt = false; - ptr ++; - goto scope_open; - } else { - state->assign_stmt = false; - goto done; + cur_helper->row ++; + } while (proceed); + + /* Iterate through the vector of slices to set the prev/next ptrs. This + * can't be done while building the vector, as reallocs may occur */ + int32_t i, count = ecs_vector_count(query->table_slices); + ecs_query_table_node_t *nodes = ecs_vector_first( + query->table_slices, ecs_query_table_node_t); + for (i = 0; i < count; i ++) { + nodes[i].prev = &nodes[i - 1]; + nodes[i].next = &nodes[i + 1]; } -scope_open: - ptr = parse_scope_open(world, name, expr, ptr, state); - if (!ptr) goto error; - goto done; + nodes[0].prev = NULL; + nodes[i - 1].next = NULL; -scope_close: - ptr = parse_scope_close(world, name, expr, ptr, state); - if (!ptr) goto error; - goto done; + ecs_os_free(helper); +} -done: - return ptr; -error: - return NULL; +static +void build_sorted_tables( + ecs_query_t *query) +{ + ecs_vector_clear(query->table_slices); + + if (query->group_by) { + /* Populate sorted node list in grouping order */ + ecs_query_table_node_t *cur = query->list.first; + if (cur) { + do { + /* Find list for current group */ + ecs_query_table_match_t *match = cur->match; + ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); + uint64_t group_id = match->group_id; + ecs_query_table_list_t *list = ecs_map_get(&query->groups, + ecs_query_table_list_t, group_id); + ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL); + + /* Sort tables in current group */ + build_sorted_table_range(query, list); + + /* Find next group to sort */ + cur = list->last->next; + } while (cur); + } + } else { + build_sorted_table_range(query, &query->list); + } } -int ecs_plecs_from_str( +static +void sort_tables( ecs_world_t *world, - const char *name, - const char *expr) + ecs_query_t *query) { - const char *ptr = expr; - ecs_term_t term = {0}; - plecs_state_t state = {0}; - - if (!expr) { - return 0; + ecs_order_by_action_t compare = query->order_by; + if (!compare) { + return; } + + ecs_entity_t order_by_component = query->order_by_component; + int32_t i, order_by_term = -1; - state.scope[0] = 0; - ecs_entity_t prev_scope = ecs_set_scope(world, 0); - ecs_entity_t prev_with = ecs_set_with(world, 0); + /* Find term that iterates over component (must be at least one) */ + if (order_by_component) { + const ecs_filter_t *f = &query->filter; + int32_t term_count = f->term_count_actual; + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &f->terms[i]; + if (term->subj.entity != EcsThis) { + continue; + } - do { - expr = ptr = parse_stmt(world, name, expr, ptr, &state); - if (!ptr) { - goto error; + if (term->id == order_by_component) { + order_by_term = i; + break; + } } - if (!ptr[0]) { - break; /* End of expression */ + ecs_assert(order_by_term != -1, ECS_INTERNAL_ERROR, NULL); + } + + /* Iterate over non-empty tables. Don't bother with empty tables as they + * have nothing to sort */ + + bool tables_sorted = false; + + ecs_table_cache_iter_t it; + ecs_query_table_t *qt; + flecs_table_cache_iter(&query->cache, &it); + + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + ecs_table_t *table = qt->hdr.table; + bool dirty = false; + + if (check_table_monitor(query, qt, 0)) { + dirty = true; } - } while (true); - ecs_set_scope(world, prev_scope); - ecs_set_with(world, prev_with); - - clear_comment(expr, ptr, &state); + int32_t column = -1; + if (order_by_component) { + if (check_table_monitor(query, qt, order_by_term + 1)) { + dirty = true; + } - if (state.sp != 0) { - ecs_parser_error(name, expr, 0, "missing end of scope"); - goto error; - } + if (dirty) { + column = -1; - if (state.assign_stmt) { - ecs_parser_error(name, expr, 0, "unfinished assignment"); - goto error; - } + ecs_table_t *storage_table = table->storage_table; + if (storage_table) { + column = ecs_search(world, storage_table, + order_by_component, NULL); + } - if (state.errors) { - goto error; + if (column == -1) { + /* Component is shared, no sorting is needed */ + dirty = false; + } + } + } + + if (!dirty) { + continue; + } + + /* Something has changed, sort the table */ + sort_table(world, table, column, compare); + tables_sorted = true; } - return 0; -error: - ecs_set_scope(world, state.scope[0]); - ecs_set_with(world, prev_with); - ecs_term_fini(&term); - return -1; + if (tables_sorted || query->match_count != query->prev_match_count) { + build_sorted_tables(query); + query->match_count ++; /* Increase version if tables changed */ + } } -int ecs_plecs_from_file( - ecs_world_t *world, - const char *filename) +static +bool has_refs( + ecs_query_t *query) { - FILE* file; - char* content = NULL; - int32_t bytes; - size_t size; - - /* Open file for reading */ - ecs_os_fopen(&file, filename, "r"); - if (!file) { - ecs_err("%s (%s)", ecs_os_strerror(errno), filename); - goto error; - } + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count; - /* Determine file size */ - fseek(file, 0 , SEEK_END); - bytes = (int32_t)ftell(file); - if (bytes == -1) { - goto error; - } - rewind(file); + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + ecs_term_id_t *subj = &term->subj; - /* Load contents in memory */ - content = ecs_os_malloc(bytes + 1); - size = (size_t)bytes; - if (!(size = fread(content, 1, size, file)) && bytes) { - ecs_err("%s: read zero bytes instead of %d", filename, size); - ecs_os_free(content); - content = NULL; - goto error; - } else { - content[size] = '\0'; + if (term->oper == EcsNot && !subj->entity) { + /* Special case: if oper kind is Not and the query contained a + * shared expression, the expression is translated to FromEmpty to + * prevent resolving the ref */ + return true; + } else if (subj->entity && (subj->entity != EcsThis || subj->set.mask != EcsSelf)) { + /* If entity is not this, or if it can be substituted by other + * entities, the query can have references. */ + return true; + } } - fclose(file); - - int result = ecs_plecs_from_str(world, filename, content); - ecs_os_free(content); - return result; -error: - ecs_os_free(content); - return -1; + return false; } -#endif +static +bool has_pairs( + ecs_query_t *query) +{ + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count; + for (i = 0; i < count; i ++) { + if (ecs_id_is_wildcard(terms[i].id)) { + return true; + } + } -#ifdef FLECS_RULES + return false; +} -#include +static +void for_each_component_monitor( + ecs_world_t *world, + ecs_query_t *query, + void(*callback)( + ecs_world_t* world, + ecs_entity_t relation, + ecs_id_t id, + ecs_query_t *query)) +{ + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count; -/** Implementation of the rule query engine. - * - * A rule (terminology borrowed from prolog) is a list of constraints that - * specify which conditions must be met for an entity to match the rule. While - * this description matches any kind of ECS query, the rule engine has features - * that go beyond regular (flecs) ECS queries: - * - * - query for all components of an entity (vs. all entities for a component) - * - query for all relationship pairs of an entity - * - support for query variables that are resolved at evaluation time - * - automatic traversal of transitive relationships - * - * Query terms can have the following forms: - * - * - Component(Subject) - * - Relation(Subject, Object) - * - * Additionally the query parser supports the following shorthand notations: - * - * - Component // short for Component(This) - * - (Relation, Object) // short for Relation(This, Object) - * - * The subject, or first arugment of a term represents the entity on which the - * component or relation is matched. By default the subject is set to a builtin - * This variable, which causes the behavior to match a regular ECS query: - * - * - Position, Velocity - * - * Is equivalent to - * - * - Position(This), Velocity(This) - * - * The function of the variable is to ensure that all components are matched on - * the same entity. Conceptually the query first populates the This variable - * with all entities that have Position. When the query evaluates the Velocity - * term, the variable is populated and the entity it contains will be checked - * for whether it has Velocity. - * - * The actual implementation is more efficient and does not check per-entity. - * - * Custom variables can be used to join parts of different terms. For example, - * the following query can be used to find entities with a parent that has a - * Position component (note that variable names start with a _): - * - * - ChildOf(This, _Parent), Component(_Parent) - * - * The rule engine uses a backtracking algorithm to find the set of entities - * and variables that match all terms. As soon as the engine finds a term that - * does not match with the currently evaluated entity, the entity is discarded. - * When an entity is found for which all terms match, the entity is yielded to - * the iterator. - * - * While a rule is being evaluated, a variable can either contain a single - * entity or a table. The engine will attempt to work with tables as much as - * possible so entities can be eliminated/yielded in bulk. A rule may store - * both the table and entity version of a variable and only switch from table to - * entity when necessary. - * - * The rule engine has an algorithm for computing which variables should be - * resolved first. This algorithm works by finding a "root" variable, which is - * the subject variable that occurs in the term with the least dependencies. The - * remaining variables are then resolved based on their "distance" from the root - * with the closest variables being resolved first. - * - * This generally results in an ordering that resolves the variables with the - * least dependencies first and the most dependencies last, which is beneficial - * for two reasons: - * - * - it improves the average performance of all queries - * - it makes performance less dependent on how an application orders the terms - * - * A possible improvement would be for the query engine to also consider - * the number of tables that need to be evaluated for each term, as starting - * with the smallest term reduces the amount of work. Other than static variable - * analysis however, this can only be determined when the query is executed. - * - * Rules are "compiled" into a set of instructions that encode the operations - * the query needs to perform in order to find the right set of entities. - * Operations can either yield data, which progresses the program, or signal - * that there is no (more) matching data, which discards the current variables. - * - * An operation can yield multiple times, if there are multiple matches for its - * inputs. Operations are called with a redo flag, which can be either true or - * false. When redo is true the operation will yield the next result. When redo - * is false, the operation will reset its state and start from the first result. - * - * Operations can have an input, output and a filter. Most commonly an operation - * either matches the filter against an input and yields if it matches, or uses - * the filter to find all matching results and store the result in the output. - * - * Variables are resolved by matching a filter against the output of an - * operation. When a term contains variables, they are encoded as register ids - * in the filter. When the filter is evaluated, the most recent values of the - * register are used to match/lookup the output. - * - * For example, a filter could be (ChildOf, _Parent). When the program starts, - * the _Parent register is initialized with *, so that when this filter is first - * evaluated, the operation will find all tables with (ChildOf, *). The _Parent - * register is then populated by taking the actual value of the table. If the - * table has type [(ChildOf, Sun)], _Parent will be initialized with Sun. - * - * It is possible that a filter matches multiple times. Consider the filter - * (Likes, _Food), and a table [(Likes, Apples), (Likes, Pears)]. In this case - * an operation will yield the table twice, once with _Food=Apples, and once - * with _Food=Pears. - * - * If a rule contains a term with a transitive relation, it will automatically - * substitute the parts of the term to find a fact that matches. The following - * examples illustrate how transitivity is resolved: - * - * Query: - * LocatedIn(Bob, SanFrancisco) - * - * Expands to: - * LocatedIn(Bob, SanFrancisco:self|subset) - * - * Explanation: - * "Is Bob located in San Francisco" - This term is true if Bob is either - * located in San Francisco, or is located in anything that is itself located - * in (a subset of) San Francisco. - * - * - * Query: - * LocatedIn(Bob, X) - * - * Expands to: - * LocatedIn(Bob, X:self|superset) - * - * Explanation: - * "Where is Bob located?" - This term recursively returns all places that - * Bob is located in, which includes his location and the supersets of his - * location. When Bob is located in San Francisco, he is also located in - * the United States, North America etc. - * - * - * Query: - * LocatedIn(X, NorthAmerica) - * - * Expands to: - * LocatedIn(X, NorthAmerica:self|subset) - * - * Explanation: - * "What is located in North America?" - This term returns everything located - * in North America and its subsets, as something located in San Francisco is - * located in UnitedStates, which is located in NorthAmerica. - * - * - * Query: - * LocatedIn(X, Y) - * - * Expands to: - * LocatedIn(X, Y) - * - * Explanation: - * "Where is everything located" - This term returns everything that is - * located somewhere. No substitution is performed as this would explode the - * results while not yielding new information. - * - * - * In the above terms, the variable indicates the part of the term that is - * unknown at evaluation time. In an actual rule the picked strategy depends on - * whether the variable is known when the term is evaluated. For example, if - * variable X has been resolved by the time Located(X, Y) is evaluated, the - * strategy from the LocatedIn(Bob, X) example will be used. - */ - -#define ECS_RULE_MAX_VAR_COUNT (32) - -#define RULE_PAIR_PREDICATE (1) -#define RULE_PAIR_OBJECT (2) - -/* A rule pair contains a predicate and object that can be stored in a register. */ -typedef struct ecs_rule_pair_t { - union { - int32_t reg; - ecs_entity_t ent; - } pred; - union { - int32_t reg; - ecs_entity_t ent; - } obj; - int32_t reg_mask; /* bit 1 = predicate, bit 2 = object */ - - bool transitive; /* Is predicate transitive */ - bool final; /* Is predicate final */ - bool reflexive; /* Is predicate reflexive */ - bool acyclic; /* Is predicate acyclic */ - bool obj_0; -} ecs_rule_pair_t; - -/* Filter for evaluating & reifing types and variables. Filters are created ad- - * hoc from pairs, and take into account all variables that had been resolved - * up to that point. */ -typedef struct ecs_rule_filter_t { - ecs_id_t mask; /* Mask with wildcard in place of variables */ - - bool wildcard; /* Does the filter contain wildcards */ - bool pred_wildcard; /* Is predicate a wildcard */ - bool obj_wildcard; /* Is object a wildcard */ - bool same_var; /* True if pred & obj are both the same variable */ - - int32_t hi_var; /* If hi part should be stored in var, this is the var id */ - int32_t lo_var; /* If lo part should be stored in var, this is the var id */ -} ecs_rule_filter_t; - -/* A rule register stores temporary values for rule variables */ -typedef enum ecs_rule_var_kind_t { - EcsRuleVarKindTable, /* Used for sorting, must be smallest */ - EcsRuleVarKindEntity, - EcsRuleVarKindUnknown -} ecs_rule_var_kind_t; - -typedef struct ecs_table_slice_t { - ecs_table_t *table; - int32_t offset; - int32_t count; -} ecs_table_slice_t; - -typedef struct ecs_rule_reg_t { - /* Used for table variable */ - ecs_table_slice_t table; - - /* Used for entity variable. May also be set for table variable if it needs - * to store an empty entity. */ - ecs_entity_t entity; -} ecs_rule_reg_t; - -/* Operations describe how the rule should be evaluated */ -typedef enum ecs_rule_op_kind_t { - EcsRuleInput, /* Input placeholder, first instruction in every rule */ - EcsRuleSelect, /* Selects all ables for a given predicate */ - EcsRuleWith, /* Applies a filter to a table or entity */ - EcsRuleSubSet, /* Finds all subsets for transitive relationship */ - EcsRuleSuperSet, /* Finds all supersets for a transitive relationship */ - EcsRuleStore, /* Store entity in table or entity variable */ - EcsRuleEach, /* Forwards each entity in a table */ - EcsRuleSetJmp, /* Set label for jump operation to one of two values */ - EcsRuleJump, /* Jump to an operation label */ - EcsRuleNot, /* Invert result of an operation */ - EcsRuleInTable, /* Test if entity (subject) is in table (r_in) */ - EcsRuleEq, /* Test if entity in (subject) and (r_in) are equal */ - EcsRuleYield /* Yield result */ -} ecs_rule_op_kind_t; - -/* Single operation */ -typedef struct ecs_rule_op_t { - ecs_rule_op_kind_t kind; /* What kind of operation is it */ - ecs_rule_pair_t filter; /* Parameter that contains optional filter */ - ecs_entity_t subject; /* If set, operation has a constant subject */ - - int32_t on_pass; /* Jump location when match succeeds */ - int32_t on_fail; /* Jump location when match fails */ - int32_t frame; /* Register frame */ - - int32_t term; /* Corresponding term index in signature */ - int32_t r_in; /* Optional In/Out registers */ - int32_t r_out; - - bool has_in, has_out; /* Keep track of whether operation uses input - * and/or output registers. This helps with - * debugging rule programs. */ -} ecs_rule_op_t; - -/* With context. Shared with select. */ -typedef struct ecs_rule_with_ctx_t { - ecs_id_record_t *idr; /* Currently evaluated table set */ - ecs_table_cache_iter_t it; - int32_t column; -} ecs_rule_with_ctx_t; - -/* Subset context */ -typedef struct ecs_rule_subset_frame_t { - ecs_rule_with_ctx_t with_ctx; - ecs_table_t *table; - int32_t row; - int32_t column; -} ecs_rule_subset_frame_t; - -typedef struct ecs_rule_subset_ctx_t { - ecs_rule_subset_frame_t storage[16]; /* Alloc-free array for small trees */ - ecs_rule_subset_frame_t *stack; - int32_t sp; -} ecs_rule_subset_ctx_t; - -/* Superset context */ -typedef struct ecs_rule_superset_frame_t { - ecs_table_t *table; - int32_t column; -} ecs_rule_superset_frame_t; - -typedef struct ecs_rule_superset_ctx_t { - ecs_rule_superset_frame_t storage[16]; /* Alloc-free array for small trees */ - ecs_rule_superset_frame_t *stack; - ecs_id_record_t *idr; - int32_t sp; -} ecs_rule_superset_ctx_t; - -/* Each context */ -typedef struct ecs_rule_each_ctx_t { - int32_t row; /* Currently evaluated row in evaluated table */ -} ecs_rule_each_ctx_t; - -/* Jump context */ -typedef struct ecs_rule_setjmp_ctx_t { - int32_t label; /* Operation label to jump to */ -} ecs_rule_setjmp_ctx_t; - -/* Operation context. This is a per-operation, per-iterator structure that - * stores information for stateful operations. */ -typedef struct ecs_rule_op_ctx_t { - union { - ecs_rule_subset_ctx_t subset; - ecs_rule_superset_ctx_t superset; - ecs_rule_with_ctx_t with; - ecs_rule_each_ctx_t each; - ecs_rule_setjmp_ctx_t setjmp; - } is; -} ecs_rule_op_ctx_t; - -/* Rule variables allow for the rule to be parameterized */ -typedef struct ecs_rule_var_t { - ecs_rule_var_kind_t kind; - char *name; /* Variable name */ - int32_t id; /* Unique variable id */ - int32_t other; /* Id to table variable (-1 if none exists) */ - int32_t occurs; /* Number of occurrences (used for operation ordering) */ - int32_t depth; /* Depth in dependency tree (used for operation ordering) */ - bool marked; /* Used for cycle detection */ -} ecs_rule_var_t; - -/* Variable ids per term */ -typedef struct ecs_rule_term_vars_t { - int32_t pred; - int32_t subj; - int32_t obj; -} ecs_rule_term_vars_t; - -/* Top-level rule datastructure */ -struct ecs_rule_t { - ecs_header_t hdr; - - ecs_world_t *world; /* Ref to world so rule can be used by itself */ - ecs_rule_op_t *operations; /* Operations array */ - ecs_filter_t filter; /* Filter of rule */ - - /* Passed to iterator */ - char *var_names[ECS_RULE_MAX_VAR_COUNT]; - - /* Variable ids used in terms */ - ecs_rule_term_vars_t term_vars[ECS_RULE_MAX_VAR_COUNT]; - - /* Variable array */ - ecs_rule_var_t vars[ECS_RULE_MAX_VAR_COUNT]; - - int32_t var_count; /* Number of variables in signature */ - int32_t subj_var_count; - int32_t frame_count; /* Number of register frames */ - int32_t operation_count; /* Number of operations in rule */ - - ecs_iterable_t iterable; /* Iterable mixin */ -}; - -/* ecs_rule_t mixins */ -ecs_mixins_t ecs_rule_t_mixins = { - .type_name = "ecs_rule_t", - .elems = { - [EcsMixinWorld] = offsetof(ecs_rule_t, world), - [EcsMixinIterable] = offsetof(ecs_rule_t, iterable) - } -}; - -static -void rule_error( - const ecs_rule_t *rule, - const char *fmt, - ...) -{ - va_list valist; - va_start(valist, fmt); - ecs_parser_errorv(rule->filter.name, rule->filter.expr, -1, fmt, valist); - va_end(valist); -} - -static -bool subj_is_set( - ecs_term_t *term) -{ - return ecs_term_id_is_set(&term->subj); -} - -static -bool obj_is_set( - ecs_term_t *term) -{ - return ecs_term_id_is_set(&term->obj) || term->role == ECS_PAIR; -} - -static -ecs_rule_op_t* create_operation( - ecs_rule_t *rule) -{ - int32_t cur = rule->operation_count ++; - rule->operations = ecs_os_realloc( - rule->operations, (cur + 1) * ECS_SIZEOF(ecs_rule_op_t)); - - ecs_rule_op_t *result = &rule->operations[cur]; - ecs_os_memset_t(result, 0, ecs_rule_op_t); - - return result; -} - -static -const char* get_var_name(const char *name) { - if (name && !ecs_os_strcmp(name, "This")) { - /* Make sure that both This and . resolve to the same variable */ - name = "."; - } - - return name; -} - -static -ecs_rule_var_t* create_variable( - ecs_rule_t *rule, - ecs_rule_var_kind_t kind, - const char *name) -{ - int32_t cur = ++ rule->var_count; - - name = get_var_name(name); - if (name && !ecs_os_strcmp(name, "*")) { - /* Wildcards are treated as anonymous variables */ - name = NULL; - } - - ecs_rule_var_t *var = &rule->vars[cur - 1]; - if (name) { - var->name = ecs_os_strdup(name); - } else { - /* Anonymous register */ - char name_buff[32]; - ecs_os_sprintf(name_buff, "_%u", cur - 1); - var->name = ecs_os_strdup(name_buff); - } - - var->kind = kind; - - /* The variable id is the location in the variable array and also points to - * the register element that corresponds with the variable. */ - var->id = cur - 1; - - /* Depth is used to calculate how far the variable is from the root, where - * the root is the variable with 0 dependencies. */ - var->depth = UINT8_MAX; - var->marked = false; - var->occurs = 0; - - return var; -} - -static -ecs_rule_var_t* create_anonymous_variable( - ecs_rule_t *rule, - ecs_rule_var_kind_t kind) -{ - return create_variable(rule, kind, NULL); -} - -/* Find variable with specified name and type. If Unknown is provided as type, - * the function will return any variable with the provided name. The root - * variable can occur both as a table and entity variable, as some rules - * require that each entity in a table is iterated. In this case, there are two - * variables, one for the table and one for the entities in the table, that both - * have the same name. */ -static -ecs_rule_var_t* find_variable( - const ecs_rule_t *rule, - ecs_rule_var_kind_t kind, - const char *name) -{ - ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL); - - name = get_var_name(name); - - const ecs_rule_var_t *variables = rule->vars; - int32_t i, count = rule->var_count; - - for (i = 0; i < count; i ++) { - const ecs_rule_var_t *variable = &variables[i]; - if (!ecs_os_strcmp(name, variable->name)) { - if (kind == EcsRuleVarKindUnknown || kind == variable->kind) { - return (ecs_rule_var_t*)variable; - } - } - } - - return NULL; -} - -/* Ensure variable with specified name and type exists. If an existing variable - * is found with an unknown type, its type will be overwritten with the - * specified type. During the variable ordering phase it is not yet clear which - * variable is the root. Which variable is the root determines its type, which - * is why during this phase variables are still untyped. */ -static -ecs_rule_var_t* ensure_variable( - ecs_rule_t *rule, - ecs_rule_var_kind_t kind, - const char *name) -{ - ecs_rule_var_t *var = find_variable(rule, kind, name); - if (!var) { - var = create_variable(rule, kind, name); - } else { - if (var->kind == EcsRuleVarKindUnknown) { - var->kind = kind; - } - } - - return var; -} - -static -const char *term_id_var_name( - ecs_term_id_t *term_id) -{ - if (term_id->var == EcsVarIsVariable) { - if (term_id->name) { - return term_id->name; - } else if (term_id->entity == EcsThis) { - return "."; - } else if (term_id->entity == EcsWildcard) { - return "*"; - } else if (term_id->entity == EcsAny) { - return "_"; - } else { - ecs_check(term_id->name != NULL, ECS_INVALID_PARAMETER, NULL); - } - } - -error: - return NULL; -} - -static -ecs_rule_var_t* ensure_term_id_variable( - ecs_rule_t *rule, - ecs_term_id_t *term_id) -{ - if (term_id->var == EcsVarIsVariable) { - if (term_id->entity == EcsAny) { - /* Any variables aren't translated to rule variables since their - * result isn't stored. */ - return NULL; - } - - const char *name = term_id_var_name(term_id); - ecs_rule_var_t *var = ensure_variable(rule, EcsRuleVarKindEntity, name); - ecs_os_strset(&term_id->name, var->name); - return var; - } - return NULL; -} - -static -bool term_id_is_variable( - ecs_term_id_t *term_id) -{ - return term_id->var == EcsVarIsVariable; -} + for (i = 0; i < count; i++) { + ecs_term_t *term = &terms[i]; + ecs_term_id_t *subj = &term->subj; -/* Get variable from a term identifier */ -static -ecs_rule_var_t* term_id_to_var( - ecs_rule_t *rule, - ecs_term_id_t *id) -{ - if (id->var == EcsVarIsVariable) {; - return find_variable(rule, EcsRuleVarKindUnknown, term_id_var_name(id)); + /* If component is requested with EcsCascade register component as a + * parent monitor. Parent monitors keep track of whether an entity moved + * in the hierarchy, which potentially requires the query to reorder its + * tables. + * Also register a regular component monitor for EcsCascade columns. + * This ensures that when the component used in the EcsCascade column + * is added or removed tables are updated accordingly*/ + if (subj->set.mask & EcsSuperSet && subj->set.mask & EcsCascade && + subj->set.relation != EcsIsA) + { + if (term->oper != EcsOr) { + if (term->subj.set.relation != EcsIsA) { + callback( + world, term->subj.set.relation, term->id, query); + } + callback(world, 0, term->id, query); + } + + /* FromAny also requires registering a monitor, as FromAny columns can + * be matched with prefabs. The only term kinds that do not require + * registering a monitor are FromOwned and FromEmpty. */ + } else if ((subj->set.mask & EcsSuperSet) || (subj->entity != EcsThis)){ + if (term->oper != EcsOr) { + callback(world, 0, term->id, query); + } + } } - return NULL; } -/* Get variable from a term predicate */ static -ecs_rule_var_t* term_pred( - ecs_rule_t *rule, - ecs_term_t *term) +void register_monitors( + ecs_world_t *world, + ecs_query_t *query) { - return term_id_to_var(rule, &term->pred); + for_each_component_monitor(world, query, flecs_monitor_register); } -/* Get variable from a term subject */ static -ecs_rule_var_t* term_subj( - ecs_rule_t *rule, - ecs_term_t *term) +void unregister_monitors( + ecs_world_t *world, + ecs_query_t *query) { - return term_id_to_var(rule, &term->subj); + for_each_component_monitor(world, query, flecs_monitor_unregister); } -/* Get variable from a term object */ static -ecs_rule_var_t* term_obj( - ecs_rule_t *rule, - ecs_term_t *term) +bool is_term_id_supported( + ecs_term_id_t *term_id) { - if (obj_is_set(term)) { - return term_id_to_var(rule, &term->obj); - } else { - return NULL; + if (term_id->var != EcsVarIsVariable) { + return true; } -} - -/* Return predicate variable from pair */ -static -ecs_rule_var_t* pair_pred( - ecs_rule_t *rule, - const ecs_rule_pair_t *pair) -{ - if (pair->reg_mask & RULE_PAIR_PREDICATE) { - return &rule->vars[pair->pred.reg]; - } else { - return NULL; + if (term_id->entity == EcsWildcard) { + return true; } + return false; } -/* Return object variable from pair */ static -ecs_rule_var_t* pair_obj( - ecs_rule_t *rule, - const ecs_rule_pair_t *pair) +void process_signature( + ecs_world_t *world, + ecs_query_t *query) { - if (pair->reg_mask & RULE_PAIR_OBJECT) { - return &rule->vars[pair->obj.reg]; - } else { - return NULL; - } -} + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count; -/* Create new frame for storing register values. Each operation that yields data - * gets its own register frame, which contains all variables reified up to that - * point. The preceding frame always contains the reified variables from the - * previous operation. Operations that do not yield data (such as control flow) - * do not have their own frames. */ -static -int32_t push_frame( - ecs_rule_t *rule) -{ - return rule->frame_count ++; -} + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + ecs_term_id_t *pred = &term->pred; + ecs_term_id_t *subj = &term->subj; + ecs_term_id_t *obj = &term->obj; + ecs_oper_kind_t op = term->oper; + ecs_inout_kind_t inout = term->inout; -/* Get register array for current stack frame. The stack frame is determined by - * the current operation that is evaluated. The register array contains the - * values for the reified variables. If a variable hasn't been reified yet, its - * register will store a wildcard. */ -static -ecs_rule_reg_t* get_register_frame( - const ecs_rule_iter_t *it, - int32_t frame) -{ - if (it->registers) { - return &it->registers[frame * it->rule->var_count]; - } else { - return NULL; - } -} + bool is_pred_supported = is_term_id_supported(pred); + bool is_subj_supported = is_term_id_supported(subj); + bool is_obj_supported = is_term_id_supported(obj); -/* Get register array for current stack frame. The stack frame is determined by - * the current operation that is evaluated. The register array contains the - * values for the reified variables. If a variable hasn't been reified yet, its - * register will store a wildcard. */ -static -ecs_rule_reg_t* get_registers( - const ecs_rule_iter_t *it, - ecs_rule_op_t *op) -{ - return get_register_frame(it, op->frame); -} + (void)pred; + (void)obj; + (void)is_pred_supported; + (void)is_subj_supported; + (void)is_obj_supported; -/* Get columns array. Columns store, for each matched column in a table, the - * index at which it occurs. This reduces the amount of searching that - * operations need to do in a type, since select/with already provide it. */ -static -int32_t* rule_get_columns_frame( - ecs_rule_iter_t *it, - int32_t frame) -{ - return &it->columns[frame * it->rule->filter.term_count]; -} + /* Queries do not support named variables */ + ecs_check(is_pred_supported, ECS_UNSUPPORTED, NULL); + ecs_check(is_obj_supported, ECS_UNSUPPORTED, NULL); + ecs_check(is_subj_supported || subj->entity == EcsThis, + ECS_UNSUPPORTED, NULL); -static -int32_t* rule_get_columns( - ecs_rule_iter_t *it, - ecs_rule_op_t *op) -{ - return rule_get_columns_frame(it, op->frame); -} + /* If self is not included in set, always start from depth 1 */ + if (!subj->set.min_depth && !(subj->set.mask & EcsSelf)) { + subj->set.min_depth = 1; + } -static -void entity_reg_set( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r, - ecs_entity_t entity) -{ - (void)rule; - ecs_assert(rule->vars[r].kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); - ecs_check(ecs_is_valid(rule->world, entity), ECS_INVALID_PARAMETER, NULL); - regs[r].entity = entity; -error: - return; -} + if (inout != EcsIn) { + query->flags |= EcsQueryHasOutColumns; + } -static -ecs_entity_t entity_reg_get( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r) -{ - (void)rule; - ecs_entity_t e = regs[r].entity; - if (!e) { - return EcsWildcard; + if (op == EcsOptional) { + query->flags |= EcsQueryHasOptional; + } + + if (!(query->flags & EcsQueryMatchDisabled)) { + if (op == EcsAnd || op == EcsOr || op == EcsOptional) { + if (term->id == EcsDisabled) { + query->flags |= EcsQueryMatchDisabled; + } + } + } + + if (!(query->flags & EcsQueryMatchPrefab)) { + if (op == EcsAnd || op == EcsOr || op == EcsOptional) { + if (term->id == EcsPrefab) { + query->flags |= EcsQueryMatchPrefab; + } + } + } + + if (subj->entity == EcsThis) { + query->flags |= EcsQueryNeedsTables; + } + + if (subj->set.mask & EcsCascade && term->oper == EcsOptional) { + /* Query can only have one cascade column */ + ecs_assert(query->cascade_by == 0, ECS_INVALID_PARAMETER, NULL); + query->cascade_by = i + 1; + } + + if (subj->entity && subj->entity != EcsThis && + subj->set.mask == EcsSelf) + { + flecs_add_flag(world, term->subj.entity, ECS_FLAG_OBSERVED); + } + } + + query->flags |= (ecs_flags32_t)(has_refs(query) * EcsQueryHasRefs); + query->flags |= (ecs_flags32_t)(has_pairs(query) * EcsQueryHasTraits); + + if (!(query->flags & EcsQueryIsSubquery)) { + register_monitors(world, query); } - - ecs_check(ecs_is_valid(rule->world, e), ECS_INVALID_PARAMETER, NULL); - return e; error: - return 0; + return; } static -void table_reg_set( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r, +bool match_table( + ecs_world_t *world, + ecs_query_t *query, ecs_table_t *table) { - (void)rule; - ecs_assert(rule->vars[r].kind == EcsRuleVarKindTable, - ECS_INTERNAL_ERROR, NULL); - - regs[r].table.table = table; - regs[r].table.offset = 0; - regs[r].table.count = 0; - regs[r].entity = 0; -} - -static -ecs_table_slice_t table_reg_get( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r) -{ - (void)rule; - ecs_assert(rule->vars[r].kind == EcsRuleVarKindTable, - ECS_INTERNAL_ERROR, NULL); - - return regs[r].table; + if (flecs_query_match(world, table, query)) { + add_table(world, query, table); + return true; + } + return false; } +/** When a table becomes empty remove it from the query list, or vice versa. */ static -ecs_entity_t reg_get_entity( - const ecs_rule_t *rule, - ecs_rule_op_t *op, - ecs_rule_reg_t *regs, - int32_t r) +void update_table( + ecs_query_t *query, + ecs_table_t *table, + bool empty) { - if (r == UINT8_MAX) { - ecs_assert(op->subject != 0, ECS_INTERNAL_ERROR, NULL); + int32_t prev_count = ecs_query_table_count(query); + ecs_table_cache_set_empty(&query->cache, table, empty); + int32_t cur_count = ecs_query_table_count(query); - /* The subject is referenced from the query string by string identifier. - * If subject entity is not valid, it could have been deletd by the - * application after the rule was created */ - ecs_check(ecs_is_valid(rule->world, op->subject), - ECS_INVALID_PARAMETER, NULL); + if (prev_count != cur_count) { + ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table); + ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_query_table_match_t *cur, *next; - return op->subject; - } - if (rule->vars[r].kind == EcsRuleVarKindTable) { - int32_t offset = regs[r].table.offset; + for (cur = qt->first; cur != NULL; cur = next) { + next = cur->next_match; - ecs_assert(regs[r].table.count == 1, ECS_INTERNAL_ERROR, NULL); - ecs_data_t *data = &table_reg_get(rule, regs, r).table->storage; - ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); - ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(offset < ecs_vector_count(data->entities), - ECS_INTERNAL_ERROR, NULL); - ecs_check(ecs_is_valid(rule->world, entities[offset]), - ECS_INVALID_PARAMETER, NULL); - - return entities[offset]; - } - if (rule->vars[r].kind == EcsRuleVarKindEntity) { - return entity_reg_get(rule, regs, r); - } + if (empty) { + ecs_assert(ecs_table_count(table) == 0, + ECS_INTERNAL_ERROR, NULL); - /* Must return an entity */ - ecs_assert(false, ECS_INTERNAL_ERROR, NULL); + remove_table_node(query, &cur->node); + } else { + ecs_assert(ecs_table_count(table) != 0, + ECS_INTERNAL_ERROR, NULL); + insert_table_node(query, &cur->node); + } + } + } -error: - return 0; + ecs_assert(cur_count || query->list.first == NULL, + ECS_INTERNAL_ERROR, NULL); } static -ecs_table_slice_t table_from_entity( - const ecs_world_t *world, - ecs_entity_t entity) +void add_subquery( + ecs_world_t *world, + ecs_query_t *parent, + ecs_query_t *subquery) { - ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); + ecs_query_t **elem = ecs_vector_add(&parent->subqueries, ecs_query_t*); + *elem = subquery; + + ecs_table_cache_t *cache = &parent->cache; + ecs_table_cache_iter_t it; + ecs_query_table_t *qt; + flecs_table_cache_iter(cache, &it); + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + match_table(world, subquery, qt->hdr.table); + } - ecs_table_slice_t slice = {0}; - ecs_record_t *record = ecs_eis_get(world, entity); - if (record) { - slice.table = record->table; - slice.offset = ECS_RECORD_TO_ROW(record->row); - slice.count = 1; + flecs_table_cache_empty_iter(cache, &it); + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + match_table(world, subquery, qt->hdr.table); } - - return slice; } static -ecs_table_slice_t reg_get_table( - const ecs_rule_t *rule, - ecs_rule_op_t *op, - ecs_rule_reg_t *regs, - int32_t r) +void notify_subqueries( + ecs_world_t *world, + ecs_query_t *query, + ecs_query_event_t *event) { - if (r == UINT8_MAX) { - ecs_check(ecs_is_valid(rule->world, op->subject), - ECS_INVALID_PARAMETER, NULL); - return table_from_entity(rule->world, op->subject); - } - if (rule->vars[r].kind == EcsRuleVarKindTable) { - return table_reg_get(rule, regs, r); + if (query->subqueries) { + ecs_query_t **queries = ecs_vector_first(query->subqueries, ecs_query_t*); + int32_t i, count = ecs_vector_count(query->subqueries); + + ecs_query_event_t sub_event = *event; + sub_event.parent_query = query; + + for (i = 0; i < count; i ++) { + ecs_query_t *sub = queries[i]; + flecs_query_notify(world, sub, &sub_event); + } } - if (rule->vars[r].kind == EcsRuleVarKindEntity) { - return table_from_entity(rule->world, entity_reg_get(rule, regs, r)); - } -error: - return (ecs_table_slice_t){0}; } static -void reg_set_entity( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r, - ecs_entity_t entity) +void resolve_cascade_subject_for_table( + ecs_world_t *world, + ecs_query_t *query, + const ecs_table_t *table, + ecs_query_table_match_t *table_data) { - if (rule->vars[r].kind == EcsRuleVarKindTable) { - ecs_world_t *world = rule->world; - ecs_check(ecs_is_valid(world, entity), ECS_INVALID_PARAMETER, NULL); - regs[r].table = table_from_entity(world, entity); - regs[r].entity = entity; + int32_t term_index = query->cascade_by - 1; + ecs_term_t *term = &query->filter.terms[term_index]; + + ecs_assert(table_data->references != 0, ECS_INTERNAL_ERROR, NULL); + + /* Obtain reference index */ + int32_t *column_indices = table_data->columns; + int32_t ref_index = -column_indices[term_index] - 1; + + /* Obtain pointer to the reference data */ + ecs_ref_t *references = table_data->references; + + /* Find source for component */ + ecs_entity_t subject = 0; + ecs_search_relation(world, table, 0, term->id, + term->subj.set.relation, 1, 0, &subject, NULL, NULL); + + /* If container was found, update the reference */ + if (subject) { + ecs_ref_t *ref = &references[ref_index]; + ecs_assert(ref->component == term->id, ECS_INTERNAL_ERROR, NULL); + + references[ref_index].entity = ecs_get_alive(world, subject); + table_data->subjects[term_index] = subject; + ecs_get_ref_id(world, ref, subject, term->id); } else { - entity_reg_set(rule, regs, r, entity); + references[ref_index].entity = 0; + table_data->subjects[term_index] = 0; + } + + if (ecs_table_count(table)) { + /* The subject (or depth of the subject) may have changed, so reinsert + * the node to make sure it's in the right group */ + remove_table_node(query, &table_data->node); + insert_table_node(query, &table_data->node); } -error: - return; } static -void reg_set_table( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t r, - ecs_table_slice_t table) +void resolve_cascade_subject( + ecs_world_t *world, + ecs_query_t *query, + ecs_query_table_t *elem, + const ecs_table_t *table) { - if (rule->vars[r].kind == EcsRuleVarKindEntity) { - ecs_check(table.count == 1, ECS_INTERNAL_ERROR, NULL); - regs[r].table = table; - regs[r].entity = ecs_vector_get(table.table->storage.entities, - ecs_entity_t, table.offset)[0]; - } else { - regs[r].table = table; - regs[r].entity = 0; + ecs_query_table_match_t *cur; + for (cur = elem->first; cur != NULL; cur = cur->next_match) { + resolve_cascade_subject_for_table(world, query, table, cur); } -error: - return; } -/* This encodes a column expression into a pair. A pair stores information about - * the variable(s) associated with the column. Pairs are used by operations to - * apply filters, and when there is a match, to reify variables. */ +/* Remove table */ static -ecs_rule_pair_t term_to_pair( - ecs_rule_t *rule, - ecs_term_t *term) +void query_table_free( + ecs_query_t *query, + ecs_query_table_t *elem) { - ecs_rule_pair_t result = {0}; - - /* Terms must always have at least one argument (the subject) */ - ecs_assert(subj_is_set(term), ECS_INTERNAL_ERROR, NULL); - - /* If the predicate id is a variable, find the variable and encode its id - * in the pair so the operation can find it later. */ - if (term->pred.var == EcsVarIsVariable) { - if (term->pred.entity != EcsAny) { - /* Always lookup var as an entity, as pairs never refer to tables */ - const ecs_rule_var_t *var = find_variable( - rule, EcsRuleVarKindEntity, term_id_var_name(&term->pred)); - - /* Variables should have been declared */ - ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(var->kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); - result.pred.reg = var->id; - - /* Set flag so the operation can see the predicate is a variable */ - result.reg_mask |= RULE_PAIR_PREDICATE; - result.final = true; - } else { - result.pred.ent = EcsWildcard; - result.final = true; - } - } else { - /* If the predicate is not a variable, simply store its id. */ - ecs_entity_t pred_id = term->pred.entity; - result.pred.ent = pred_id; + ecs_query_table_match_t *cur, *next; - /* Test if predicate is transitive. When evaluating the predicate, this - * will also take into account transitive relationships */ - if (ecs_has_id(rule->world, pred_id, EcsTransitive)) { - /* Transitive queries must have an object */ - if (obj_is_set(term)) { - result.transitive = true; - } - } + for (cur = elem->first; cur != NULL; cur = next) { + ecs_os_free(cur->columns); + ecs_os_free(cur->ids); + ecs_os_free(cur->subjects); + ecs_os_free(cur->sizes); + ecs_os_free(cur->references); + ecs_os_free(cur->sparse_columns); + ecs_os_free(cur->bitset_columns); + ecs_os_free(cur->monitor); - if (ecs_has_id(rule->world, pred_id, EcsFinal)) { - result.final = true; + if (!elem->hdr.empty) { + remove_table_node(query, &cur->node); } - if (ecs_has_id(rule->world, pred_id, EcsReflexive)) { - result.reflexive = true; - } + next = cur->next_match; - if (ecs_has_id(rule->world, pred_id, EcsAcyclic)) { - result.acyclic = true; - } + ecs_os_free(cur); } - /* The pair doesn't do anything with the subject (subjects are the things that - * are matched against pairs) so if the column does not have a object, - * there is nothing left to do. */ - if (!obj_is_set(term)) { - return result; + ecs_os_free(elem); +} + +static +void unmatch_table( + ecs_query_t *query, + ecs_table_t *table) +{ + ecs_query_table_t *qt = ecs_table_cache_remove( + &query->cache, table, NULL); + if (qt) { + query_table_free(query, qt); } +} - /* If arguments is higher than 2 this is not a pair but a nested rule */ - ecs_assert(obj_is_set(term), ECS_INTERNAL_ERROR, NULL); +static +void rematch_table( + ecs_world_t *world, + ecs_query_t *query, + ecs_table_t *table) +{ + ecs_query_table_t *match = ecs_table_cache_get(&query->cache, table); - /* Same as above, if the object is a variable, store it and flag it */ - if (term->obj.var == EcsVarIsVariable) { - if (term->obj.entity != EcsAny) { - const ecs_rule_var_t *var = find_variable( - rule, EcsRuleVarKindEntity, term_id_var_name(&term->obj)); + if (flecs_query_match(world, table, query)) { + /* If the table matches, and it is not currently matched, add */ + if (match == NULL) { + add_table(world, query, table); - /* Variables should have been declared */ - ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(var->kind == EcsRuleVarKindEntity, ECS_INTERNAL_ERROR, - NULL); + /* If table still matches and has cascade column, reevaluate the + * sources of references. This may have changed in case + * components were added/removed to container entities */ + } else if (query->cascade_by) { + resolve_cascade_subject(world, query, match, table); - result.obj.reg = var->id; - result.reg_mask |= RULE_PAIR_OBJECT; - } else { - result.obj.ent = EcsWildcard; + /* If query has optional columns, it is possible that a column that + * previously had data no longer has data, or vice versa. Do a + * rematch to make sure data is consistent. */ + } else if (query->flags & EcsQueryHasOptional) { + /* Check if optional terms that weren't matched before are matched + * now & vice versa */ + ecs_query_table_match_t *qt = match->first; + + bool rematch = false; + int32_t i, count = query->filter.term_count_actual; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &query->filter.terms[i]; + + if (term->oper == EcsOptional) { + int32_t t = term->index; + int32_t column = 0; + flecs_term_match_table(world, term, table, + table->type, 0, &column, 0, 0, true); + if (column && (qt->columns[t] == 0)) { + rematch = true; + } else if (!column && (qt->columns[t] != 0)) { + rematch = true; + } + } + } + + if (rematch) { + unmatch_table(query, table); + add_table(world, query, table); + } } } else { - /* If the object is not a variable, simply store its id */ - result.obj.ent = term->obj.entity; - if (!result.obj.ent) { - result.obj_0 = true; + /* Table no longer matches, remove */ + if (match != NULL) { + unmatch_table(query, table); + notify_subqueries(world, query, &(ecs_query_event_t){ + .kind = EcsQueryTableUnmatch, + .table = table + }); } } - - return result; } -/* When an operation has a pair, it is used to filter its input. This function - * translates a pair back into an entity id, and in the process substitutes the - * variables that have already been filled out. It's one of the most important - * functions, as a lot of the filtering logic depends on having an entity that - * has all of the reified variables correctly filled out. */ static -ecs_rule_filter_t pair_to_filter( - ecs_rule_iter_t *it, - ecs_rule_op_t *op, - ecs_rule_pair_t pair) +bool satisfy_constraints( + ecs_world_t *world, + const ecs_filter_t *filter) { - ecs_entity_t pred = pair.pred.ent; - ecs_entity_t obj = pair.obj.ent; - ecs_rule_filter_t result = { - .lo_var = -1, - .hi_var = -1 - }; - - /* Get registers in case we need to resolve ids from registers. Get them - * from the previous, not the current stack frame as the current operation - * hasn't reified its variables yet. */ - ecs_rule_reg_t *regs = get_register_frame(it, op->frame - 1); + ecs_term_t *terms = filter->terms; + int32_t i, count = filter->term_count; - if (pair.reg_mask & RULE_PAIR_OBJECT) { - obj = entity_reg_get(it->rule, regs, pair.obj.reg); - obj = ecs_entity_t_lo(obj); /* Filters don't have generations */ + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + ecs_term_id_t *subj = &term->subj; + ecs_oper_kind_t oper = term->oper; - if (obj == EcsWildcard) { - result.wildcard = true; - result.obj_wildcard = true; - result.lo_var = pair.obj.reg; + if (oper == EcsOptional) { + continue; } - } - - if (pair.reg_mask & RULE_PAIR_PREDICATE) { - pred = entity_reg_get(it->rule, regs, pair.pred.reg); - pred = ecs_entity_t_lo(pred); /* Filters don't have generations */ - if (pred == EcsWildcard) { - if (result.wildcard) { - result.same_var = pair.pred.reg == pair.obj.reg; + if (subj->entity != EcsThis && subj->entity) { + ecs_table_t *table = ecs_get_table(world, subj->entity); + if (!table) { + goto no_match; } - result.wildcard = true; - result.pred_wildcard = true; - - if (obj) { - result.hi_var = pair.pred.reg; - } else { - result.lo_var = pair.pred.reg; + if (!flecs_term_match_table(world, term, table, table->type, NULL, + NULL, NULL, NULL, true)) + { + goto no_match; } } } - if (!obj && !pair.obj_0) { - result.mask = pred; - } else { - result.mask = ecs_pair(pred, obj); - } - - return result; + return true; +no_match: + return false; } -/* This function is responsible for reifying the variables (filling them out - * with their actual values as soon as they are known). It uses the pair - * expression returned by pair_get_most_specific_var, and attempts to fill out each of the - * wildcards in the pair. If a variable isn't reified yet, the pair expression - * will still contain one or more wildcards, which is harmless as the respective - * registers will also point to a wildcard. */ +/* Rematch system with tables after a change happened to a watched entity */ static -void reify_variables( - ecs_rule_iter_t *it, - ecs_rule_op_t *op, - ecs_rule_filter_t *filter, - ecs_type_t type, - int32_t column) -{ - const ecs_rule_t *rule = it->rule; - const ecs_rule_var_t *vars = rule->vars; - (void)vars; - - ecs_rule_reg_t *regs = get_registers(it, op); - ecs_entity_t *elem = ecs_vector_get(type, ecs_entity_t, column); - ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - - int32_t obj_var = filter->lo_var; - int32_t pred_var = filter->hi_var; +void rematch_tables( + ecs_world_t *world, + ecs_query_t *query, + ecs_query_t *parent_query) +{ + if (parent_query) { + ecs_table_cache_iter_t it; + if (flecs_table_cache_iter(&parent_query->cache, &it)) { + ecs_query_table_t *qt; + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + rematch_table(world, query, qt->hdr.table); + } + } - if (obj_var != -1) { - ecs_assert(vars[obj_var].kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); + if (flecs_table_cache_empty_iter(&parent_query->cache, &it)) { + ecs_query_table_t *qt; + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + rematch_table(world, query, qt->hdr.table); + } + } + } else { + ecs_sparse_t *tables = &world->store.tables; + int32_t i, count = flecs_sparse_count(tables); - entity_reg_set(rule, regs, obj_var, - ecs_get_alive(rule->world, ECS_PAIR_SECOND(*elem))); + for (i = 0; i < count; i ++) { + /* Is the system currently matched with the table? */ + ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); + rematch_table(world, query, table); + } } - if (pred_var != -1) { - ecs_assert(vars[pred_var].kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); - - entity_reg_set(rule, regs, pred_var, - ecs_get_alive(rule->world, - ECS_PAIR_FIRST(*elem))); - } + /* Enable/disable system if constraints are (not) met. If the system is + * already dis/enabled this operation has no side effects. */ + query->constraints_satisfied = satisfy_constraints(world, &query->filter); } -/* Returns whether variable is a subject */ static -bool is_subject( - ecs_rule_t *rule, - ecs_rule_var_t *var) +void remove_subquery( + ecs_query_t *parent, + ecs_query_t *sub) { - ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(parent != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(sub != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(parent->subqueries != NULL, ECS_INTERNAL_ERROR, NULL); - if (!var) { - return false; - } + int32_t i, count = ecs_vector_count(parent->subqueries); + ecs_query_t **sq = ecs_vector_first(parent->subqueries, ecs_query_t*); - if (var->id < rule->subj_var_count) { - return true; + for (i = 0; i < count; i ++) { + if (sq[i] == sub) { + break; + } } - return false; + ecs_vector_remove(parent->subqueries, ecs_query_t*, i); } -static -bool skip_term(ecs_term_t *term) { - if (term->subj.set.mask & EcsNothing) { - return true; - } - if (term->oper == EcsNot) { - return true; +/* -- Private API -- */ + +void flecs_query_notify( + ecs_world_t *world, + ecs_query_t *query, + ecs_query_event_t *event) +{ + bool notify = true; + + switch(event->kind) { + case EcsQueryTableMatch: + /* Creation of new table */ + if (match_table(world, query, event->table)) { + if (query->subqueries) { + notify_subqueries(world, query, event); + } + } + notify = false; + break; + case EcsQueryTableUnmatch: + /* Deletion of table */ + unmatch_table(query, event->table); + break; + case EcsQueryTableRematch: + /* Rematch tables of query */ + rematch_tables(world, query, event->parent_query); + break; + case EcsQueryOrphan: + ecs_assert(query->flags & EcsQueryIsSubquery, ECS_INTERNAL_ERROR, NULL); + query->flags |= EcsQueryIsOrphaned; + query->parent = NULL; + break; } - return false; + if (notify) { + notify_subqueries(world, query, event); + } } static -int32_t get_variable_depth( - ecs_rule_t *rule, - ecs_rule_var_t *var, - ecs_rule_var_t *root, - int recur); - -static -int32_t crawl_variable( - ecs_rule_t *rule, - ecs_rule_var_t *var, - ecs_rule_var_t *root, - int recur) +void query_order_by( + ecs_world_t *world, + ecs_query_t *query, + ecs_entity_t order_by_component, + ecs_order_by_action_t order_by) { - ecs_term_t *terms = rule->filter.terms; - int32_t i, count = rule->filter.term_count; - - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - if (skip_term(term)) { - continue; - } - - ecs_rule_var_t - *pred = term_pred(rule, term), - *subj = term_subj(rule, term), - *obj = term_obj(rule, term); + ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(!(query->flags & EcsQueryIsOrphaned), ECS_INVALID_PARAMETER, NULL); + ecs_check(query->flags & EcsQueryNeedsTables, ECS_INVALID_PARAMETER, NULL); - /* Variable must at least appear once in term */ - if (var != pred && var != subj && var != obj) { - continue; - } + query->order_by_component = order_by_component; + query->order_by = order_by; - if (pred && pred != var && !pred->marked) { - get_variable_depth(rule, pred, root, recur + 1); - } + ecs_vector_free(query->table_slices); + query->table_slices = NULL; - if (subj && subj != var && !subj->marked) { - get_variable_depth(rule, subj, root, recur + 1); - } + sort_tables(world, query); - if (obj && obj != var && !obj->marked) { - get_variable_depth(rule, obj, root, recur + 1); - } + if (!query->table_slices) { + build_sorted_tables(query); } +error: + return; +} - return 0; +static +void query_group_by( + ecs_query_t *query, + ecs_entity_t sort_component, + ecs_group_by_action_t group_by) +{ + /* Cannot change grouping once a query has been created */ + ecs_check(query->group_by_id == 0, ECS_INVALID_OPERATION, NULL); + ecs_check(query->group_by == 0, ECS_INVALID_OPERATION, NULL); + + query->group_by_id = sort_component; + query->group_by = group_by; + ecs_map_init(&query->groups, ecs_query_table_list_t, 16); +error: + return; } +/* Implementation for iterable mixin */ static -int32_t get_depth_from_var( - ecs_rule_t *rule, - ecs_rule_var_t *var, - ecs_rule_var_t *root, - int recur) +void query_iter_init( + const ecs_world_t *world, + const ecs_poly_t *poly, + ecs_iter_t *iter, + ecs_term_t *filter) { - /* If variable is the root or if depth has been set, return depth + 1 */ - if (var == root || var->depth != UINT8_MAX) { - return var->depth + 1; - } + ecs_poly_assert(poly, ecs_query_t); - /* Variable is already being evaluated, so this indicates a cycle. Stop */ - if (var->marked) { - return 0; - } - - /* Variable is not yet being evaluated and depth has not yet been set. - * Calculate depth. */ - int32_t depth = get_variable_depth(rule, var, root, recur + 1); - if (depth == UINT8_MAX) { - return depth; + if (filter) { + iter[1] = ecs_query_iter(world, (ecs_query_t*)poly); + iter[0] = ecs_term_chain_iter(&iter[1], filter); } else { - return depth + 1; + iter[0] = ecs_query_iter(world, (ecs_query_t*)poly); } } static -int32_t get_depth_from_term( - ecs_rule_t *rule, - ecs_rule_var_t *cur, - ecs_rule_var_t *pred, - ecs_rule_var_t *obj, - ecs_rule_var_t *root, - int recur) -{ - int32_t result = UINT8_MAX; - - /* If neither of the other parts of the terms are variables, this - * variable is guaranteed to have no dependencies. */ - if (!pred && !obj) { - result = 0; - } else { - /* If this is a variable that is not the same as the current, - * we can use it to determine dependency depth. */ - if (pred && cur != pred) { - int32_t depth = get_depth_from_var(rule, pred, root, recur); - if (depth == UINT8_MAX) { - return UINT8_MAX; - } +void query_on_event( + ecs_iter_t *it) +{ + /* Because this is the observer::run callback, checking if this is event is + * already handled is not done for us. */ + ecs_world_t *world = it->world; + ecs_observer_t *o = it->ctx; + if (o->last_event_id == world->event_id) { + return; + } + o->last_event_id = world->event_id; - /* If the found depth is lower than the depth found, overwrite it */ - if (depth < result) { - result = depth; - } - } + ecs_query_t *query = o->ctx; + ecs_table_t *table = it->table; - /* Same for obj */ - if (obj && cur != obj) { - int32_t depth = get_depth_from_var(rule, obj, root, recur); - if (depth == UINT8_MAX) { - return UINT8_MAX; - } + ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); - if (depth < result) { - result = depth; - } - } + /* The observer isn't doing the matching because the query can do it more + * efficiently by checking the table with the query cache. */ + if (ecs_table_cache_get(&query->cache, table) == NULL) { + return; } - return result; + ecs_entity_t event = it->event; + if (event == EcsOnTableEmpty) { + update_table(query, table, true); + } else + if (event == EcsOnTableFill) { + update_table(query, table, false); + } } -/* Find the depth of the dependency tree from the variable to the root */ -static -int32_t get_variable_depth( - ecs_rule_t *rule, - ecs_rule_var_t *var, - ecs_rule_var_t *root, - int recur) -{ - var->marked = true; - - /* Iterate columns, find all instances where 'var' is not used as subject. - * If the subject of that column is either the root or a variable for which - * the depth is known, the depth for this variable can be determined. */ - ecs_term_t *terms = rule->filter.terms; - int32_t i, count = rule->filter.term_count; - int32_t result = UINT8_MAX; - - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - if (skip_term(term)) { - continue; - } +/* -- Public API -- */ - ecs_rule_var_t - *pred = term_pred(rule, term), - *subj = term_subj(rule, term), - *obj = term_obj(rule, term); +ecs_query_t* ecs_query_init( + ecs_world_t *world, + const ecs_query_desc_t *desc) +{ + ecs_query_t *result = NULL; + ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); - if (subj != var) { - continue; - } + /* Ensure that while initially populating the query with tables, they are + * in the right empty/non-empty list. This ensures the query won't miss + * empty/non-empty events for tables that are currently out of sync, but + * change back to being in sync before processing pending events. */ + ecs_force_aperiodic(world); - if (!is_subject(rule, pred)) { - pred = NULL; - } + result = flecs_sparse_add(world->queries, ecs_query_t); + ecs_poly_init(result, ecs_query_t); + result->id = flecs_sparse_last_id(world->queries); - if (!is_subject(rule, obj)) { - obj = NULL; - } + ecs_observer_desc_t observer_desc = { .filter = desc->filter }; + observer_desc.filter.match_empty_tables = true; - int32_t depth = get_depth_from_term(rule, var, pred, obj, root, recur); - if (depth < result) { - result = depth; - } + if (ecs_filter_init(world, &result->filter, &observer_desc.filter)) { + goto error; } - if (result == UINT8_MAX) { - result = 0; - } + if (result->filter.term_count) { + observer_desc.run = query_on_event; + observer_desc.ctx = result; + observer_desc.events[0] = EcsOnTableEmpty; + observer_desc.events[1] = EcsOnTableFill; + observer_desc.filter.filter = true; - var->depth = result; + /* ecs_filter_init could have moved away resources from the terms array + * in the descriptor, so use the terms array from the filter. */ + observer_desc.filter.terms_buffer = result->filter.terms; + observer_desc.filter.terms_buffer_count = result->filter.term_count; + observer_desc.filter.expr = NULL; /* Already parsed */ - /* Dependencies are calculated from subject to (pred, obj). If there were - * subjects that are only related by object (like (X, Y), (Z, Y)) it is - * possible that those have not yet been found yet. To make sure those - * variables are found, loop again & follow predicate & object links */ - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - if (skip_term(term)) { - continue; + result->observer = ecs_observer_init(world, &observer_desc); + if (!result->observer) { + goto error; } + } - ecs_rule_var_t - *subj = term_subj(rule, term), - *pred = term_pred(rule, term), - *obj = term_obj(rule, term); + ecs_table_cache_init(&result->cache); - /* Only evaluate pred & obj for current subject. This ensures that we - * won't evaluate variables that are unreachable from the root. This - * must be detected as unconstrained variables are not allowed. */ - if (subj != var) { - continue; - } + result->world = world; + result->iterable.init = query_iter_init; + result->system = desc->system; + result->prev_match_count = -1; - crawl_variable(rule, subj, root, recur); + process_signature(world, result); - if (pred && pred != var) { - crawl_variable(rule, pred, root, recur); - } + /* Group before matching so we won't have to move tables around later */ + int32_t cascade_by = result->cascade_by; + if (cascade_by) { + query_group_by(result, result->filter.terms[cascade_by - 1].id, + group_by_cascade); + result->group_by_ctx = &result->filter.terms[cascade_by - 1]; + } - if (obj && obj != var) { - crawl_variable(rule, obj, root, recur); - } + if (desc->group_by) { + /* Can't have a cascade term and group by at the same time, as cascade + * uses the group_by mechanism */ + ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER, NULL); + query_group_by(result, desc->group_by_id, desc->group_by); + result->group_by_ctx = desc->group_by_ctx; + result->group_by_ctx_free = desc->group_by_ctx_free; } - return var->depth; -} + if (desc->parent != NULL) { + result->flags |= EcsQueryIsSubquery; + } -/* Compare function used for qsort. It ensures that variables are first ordered - * by depth, followed by how often they occur. */ -static -int compare_variable( - const void* ptr1, - const void *ptr2) -{ - const ecs_rule_var_t *v1 = ptr1; - const ecs_rule_var_t *v2 = ptr2; + /* If a system is specified, ensure that if there are any subjects in the + * filter that refer to the system, the component is added */ + if (desc->system) { + int32_t t, term_count = result->filter.term_count; + ecs_term_t *terms = result->filter.terms; - if (v1->kind < v2->kind) { - return -1; - } else if (v1->kind > v2->kind) { - return 1; + for (t = 0; t < term_count; t ++) { + ecs_term_t *term = &terms[t]; + if (term->subj.entity == desc->system) { + ecs_add_id(world, desc->system, term->id); + } + } } - if (v1->depth < v2->depth) { - return -1; - } else if (v1->depth > v2->depth) { - return 1; + if (ecs_should_log_1()) { + char *filter_expr = ecs_filter_str(world, &result->filter); + ecs_dbg_1("#[green]query#[normal] [%s] created", filter_expr); + ecs_os_free(filter_expr); } - if (v1->occurs < v2->occurs) { - return 1; + ecs_log_push_1(); + + if (!desc->parent) { + if (result->flags & EcsQueryNeedsTables) { + match_tables(world, result); + } else { + /* Add stub table that resolves references (if any) so everything is + * preprocessed when the query is evaluated. */ + add_table(world, result, NULL); + } } else { - return -1; + add_subquery(world, desc->parent, result); + result->parent = desc->parent; } - return (v1->id < v2->id) - (v1->id > v2->id); -} - -/* After all subject variables have been found, inserted and sorted, the - * remaining variables (predicate & object) still need to be inserted. This - * function serves two purposes. The first purpose is to ensure that all - * variables are known before operations are emitted. This ensures that the - * variables array won't be reallocated while emitting, which simplifies code. - * The second purpose of the function is to ensure that if the root variable - * (which, if it exists has now been created with a table type) is also inserted - * with an entity type if required. This is used later to decide whether the - * rule needs to insert an each instruction. */ -static -void ensure_all_variables( - ecs_rule_t *rule) -{ - ecs_term_t *terms = rule->filter.terms; - int32_t i, count = rule->filter.term_count; - - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - if (skip_term(term)) { - continue; - } + if (desc->order_by) { + query_order_by( + world, result, desc->order_by_component, desc->order_by); + } - /* If predicate is a variable, make sure it has been registered */ - if (term->pred.var == EcsVarIsVariable) { - ensure_term_id_variable(rule, &term->pred); - } + result->constraints_satisfied = satisfy_constraints(world, &result->filter); - /* If subject is a variable and it is not This, make sure it is - * registered as an entity variable. This ensures that the program will - * correctly return all permutations */ - if (term->subj.var == EcsVarIsVariable) { - if (term->subj.entity != EcsThis) { - ensure_term_id_variable(rule, &term->subj); - } - } + ecs_log_pop_1(); - /* If object is a variable, make sure it has been registered */ - if (obj_is_set(term) && (term->obj.var == EcsVarIsVariable)) { - ensure_term_id_variable(rule, &term->obj); + return result; +error: + if (result) { + ecs_filter_fini(&result->filter); + if (result->observer) { + ecs_delete(world, result->observer); } - } + flecs_sparse_remove(world->queries, result->id); + } + return NULL; } -/* Scan for variables, put them in optimal dependency order. */ static -int scan_variables( - ecs_rule_t *rule) +void table_cache_free( + ecs_query_t *query) { - /* Objects found in rule. One will be elected root */ - int32_t subject_count = 0; - - /* If this (.) is found, it always takes precedence in root election */ - int32_t this_var = UINT8_MAX; - - /* Keep track of the subject variable that occurs the most. In the absence of - * this (.) the variable with the most occurrences will be elected root. */ - int32_t max_occur = 0; - int32_t max_occur_var = UINT8_MAX; - - /* Step 1: find all possible roots */ - ecs_term_t *terms = rule->filter.terms; - int32_t i, term_count = rule->filter.term_count; - - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; - - /* Evaluate the subject. The predicate and object are not evaluated, - * since they never can be elected as root. */ - if (term_id_is_variable(&term->subj)) { - const char *subj_name = term_id_var_name(&term->subj); - - ecs_rule_var_t *subj = find_variable( - rule, EcsRuleVarKindTable, subj_name); - if (!subj) { - subj = create_variable(rule, EcsRuleVarKindTable, subj_name); - if (subject_count >= ECS_RULE_MAX_VAR_COUNT) { - rule_error(rule, "too many variables in rule"); - goto error; - } - - /* Make sure that variable name in term array matches with the - * rule name. */ - ecs_os_strset(&term->subj.name, subj->name); - } + ecs_table_cache_iter_t it; + ecs_query_table_t *qt; - if (++ subj->occurs > max_occur) { - max_occur = subj->occurs; - max_occur_var = subj->id; - } + if (flecs_table_cache_iter(&query->cache, &it)) { + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + query_table_free(query, qt); } } - rule->subj_var_count = rule->var_count; - - ensure_all_variables(rule); + if (flecs_table_cache_empty_iter(&query->cache, &it)) { + while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { + query_table_free(query, qt); + } + } - /* Variables in a term with a literal subject have depth 0 */ - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; + ecs_table_cache_fini(&query->cache); +} - if (term->subj.var == EcsVarIsEntity) { - ecs_rule_var_t - *pred = term_pred(rule, term), - *obj = term_obj(rule, term); +void ecs_query_fini( + ecs_query_t *query) +{ + ecs_poly_assert(query, ecs_query_t); + ecs_world_t *world = query->world; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - if (pred) { - pred->depth = 0; - } - if (obj) { - obj->depth = 0; - } - } + if (!world->is_fini) { + ecs_delete(world, query->observer); } - /* Elect a root. This is either this (.) or the variable with the most - * occurrences. */ - int32_t root_var = this_var; - if (root_var == UINT8_MAX) { - root_var = max_occur_var; - if (root_var == UINT8_MAX) { - /* If no subject variables have been found, the rule expression only - * operates on a fixed set of entities, in which case no root - * election is required. */ - goto done; + if (query->group_by_ctx_free) { + if (query->group_by_ctx) { + query->group_by_ctx_free(query->group_by_ctx); } } - ecs_rule_var_t *root = &rule->vars[root_var]; - root->depth = get_variable_depth(rule, root, root, 0); - - /* Verify that there are no unconstrained variables. Unconstrained variables - * are variables that are unreachable from the root. */ - for (i = 0; i < rule->subj_var_count; i ++) { - if (rule->vars[i].depth == UINT8_MAX) { - rule_error(rule, "unconstrained variable '%s'", - rule->vars[i].name); - goto error; - } + if ((query->flags & EcsQueryIsSubquery) && + !(query->flags & EcsQueryIsOrphaned)) + { + remove_subquery(query->parent, query); } - /* For each Not term, verify that variables are known */ - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; - if (term->oper != EcsNot) { - continue; - } + notify_subqueries(world, query, &(ecs_query_event_t){ + .kind = EcsQueryOrphan + }); - ecs_rule_var_t - *pred = term_pred(rule, term), - *obj = term_obj(rule, term); + unregister_monitors(world, query); - if (!pred && term_id_is_variable(&term->pred)) { - rule_error(rule, "missing predicate variable '%s'", - term_id_var_name(&term->pred)); - goto error; - } - if (!obj && term_id_is_variable(&term->obj)) { - rule_error(rule, "missing object variable '%s'", - term_id_var_name(&term->obj)); - goto error; - } - } + table_cache_free(query); - /* Order variables by depth, followed by occurrence. The variable - * array will later be used to lead the iteration over the terms, and - * determine which operations get inserted first. */ - int32_t var_count = rule->var_count; - ecs_qsort_t(rule->vars, var_count, ecs_rule_var_t, compare_variable); + ecs_map_fini(&query->groups); - /* Iterate variables to correct ids after sort */ - for (i = 0; i < rule->var_count; i ++) { - rule->vars[i].id = i; - } + ecs_vector_free(query->subqueries); + ecs_vector_free(query->table_slices); + ecs_filter_fini(&query->filter); + + ecs_poly_fini(query, ecs_query_t); -done: - return 0; + /* Remove query from storage */ + flecs_sparse_remove(world->queries, query->id); error: - return -1; + return; } -/* Get entity variable from table variable */ -static -ecs_rule_var_t* to_entity( - ecs_rule_t *rule, - ecs_rule_var_t *var) +const ecs_filter_t* ecs_query_get_filter( + ecs_query_t *query) { - if (!var) { - return NULL; - } - - ecs_rule_var_t *evar = NULL; - if (var->kind == EcsRuleVarKindTable) { - evar = find_variable(rule, EcsRuleVarKindEntity, var->name); - } else { - evar = var; - } - - return evar; + ecs_poly_assert(query, ecs_query_t); + return &query->filter; } -/* Ensure that if a table variable has been written, the corresponding entity - * variable is populated. The function will return the most specific, populated - * variable. */ -static -ecs_rule_var_t* most_specific_var( - ecs_rule_t *rule, - ecs_rule_var_t *var, - bool *written, - bool create) +/* Create query iterator */ +ecs_iter_t ecs_query_iter( + const ecs_world_t *stage, + ecs_query_t *query) { - if (!var) { - return NULL; - } + ecs_poly_assert(query, ecs_query_t); + ecs_check(!(query->flags & EcsQueryIsOrphaned), + ECS_INVALID_PARAMETER, NULL); - ecs_rule_var_t *tvar, *evar = to_entity(rule, var); - if (!evar) { - return var; - } + query->constraints_satisfied = satisfy_constraints(query->world, &query->filter); - if (var->kind == EcsRuleVarKindTable) { - tvar = var; - } else { - tvar = find_variable(rule, EcsRuleVarKindTable, var->name); - } + ecs_world_t *world = (ecs_world_t*)ecs_get_world(stage); - /* If variable is used as predicate or object, it should have been - * registered as an entity. */ - ecs_assert(evar != NULL, ECS_INTERNAL_ERROR, NULL); + flecs_process_pending_tables(world); - /* Usually table variables are resolved before they are used as a predicate - * or object, but in the case of cyclic dependencies this is not guaranteed. - * Only insert an each instruction of the table variable has been written */ - if (tvar && written[tvar->id]) { - /* If the variable has been written as a table but not yet - * as an entity, insert an each operation that yields each - * entity in the table. */ - if (evar) { - if (written[evar->id]) { - return evar; - } else if (create) { - ecs_rule_op_t *op = create_operation(rule); - op->kind = EcsRuleEach; - op->on_pass = rule->operation_count; - op->on_fail = rule->operation_count - 2; - op->frame = rule->frame_count; - op->has_in = true; - op->has_out = true; - op->r_in = tvar->id; - op->r_out = evar->id; + sort_tables(world, query); - /* Entity will either be written or has been written */ - written[evar->id] = true; + if (!world->is_readonly && query->flags & EcsQueryHasRefs) { + flecs_eval_component_monitors(world); + } - push_frame(rule); + query->prev_match_count = query->match_count; - return evar; - } else { - return tvar; - } - } - } else if (evar && written[evar->id]) { - return evar; + int32_t table_count; + if (query->table_slices) { + table_count = ecs_vector_count(query->table_slices); + } else { + table_count = ecs_query_table_count(query); } - return var; -} + ecs_query_iter_t it = { + .query = query, + .node = query->list.first + }; -/* Get most specific known variable */ -static -ecs_rule_var_t *get_most_specific_var( - ecs_rule_t *rule, - ecs_rule_var_t *var, - bool *written) -{ - return most_specific_var(rule, var, written, false); + if (query->order_by && query->list.count) { + it.node = ecs_vector_first(query->table_slices, ecs_query_table_node_t); + } + + return (ecs_iter_t){ + .real_world = world, + .world = (ecs_world_t*)stage, + .terms = query->filter.terms, + .term_count = query->filter.term_count_actual, + .table_count = table_count, + .is_filter = query->filter.filter, + .is_instanced = query->filter.instanced, + .priv.iter.query = it, + .next = ecs_query_next, + }; +error: + return (ecs_iter_t){ 0 }; } -/* Get or create most specific known variable. This will populate an entity - * variable if a table variable is known but the entity variable isn't. */ static -ecs_rule_var_t *ensure_most_specific_var( - ecs_rule_t *rule, - ecs_rule_var_t *var, - bool *written) +int find_smallest_column( + ecs_table_t *table, + ecs_query_table_match_t *table_data, + ecs_vector_t *sparse_columns) { - return most_specific_var(rule, var, written, true); -} + flecs_sparse_column_t *sparse_column_array = + ecs_vector_first(sparse_columns, flecs_sparse_column_t); + int32_t i, count = ecs_vector_count(sparse_columns); + int32_t min = INT_MAX, index = 0; + + for (i = 0; i < count; i ++) { + /* The array with sparse queries for the matched table */ + flecs_sparse_column_t *sparse_column = &sparse_column_array[i]; + + /* Pointer to the switch column struct of the table */ + ecs_sw_column_t *sc = sparse_column->sw_column; + + /* If the sparse column pointer hadn't been retrieved yet, do it now */ + if (!sc) { + /* Get the table column index from the signature column index */ + int32_t table_column_index = table_data->columns[ + sparse_column->signature_column_index]; + + /* Translate the table column index to switch column index */ + table_column_index -= table->sw_column_offset; + ecs_assert(table_column_index >= 1, ECS_INTERNAL_ERROR, NULL); + /* Get the sparse column */ + ecs_data_t *data = &table->storage; + sc = sparse_column->sw_column = + &data->sw_columns[table_column_index - 1]; + } -/* Ensure that an entity variable is written before using it */ -static -ecs_rule_var_t* ensure_entity_written( - ecs_rule_t *rule, - ecs_rule_var_t *var, - bool *written) -{ - if (!var) { - return NULL; + /* Find the smallest column */ + ecs_switch_t *sw = sc->data; + int32_t case_count = flecs_switch_case_count(sw, sparse_column->sw_case); + if (case_count < min) { + min = case_count; + index = i + 1; + } } - /* Ensure we're working with the most specific version of subj we can get */ - ecs_rule_var_t *evar = ensure_most_specific_var(rule, var, written); - - /* The post condition of this function is that there is an entity variable, - * and that it is written. Make sure that the result is an entity */ - ecs_assert(evar != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(evar->kind == EcsRuleVarKindEntity, ECS_INTERNAL_ERROR, NULL); - - /* Make sure the variable has been written */ - ecs_assert(written[evar->id] == true, ECS_INTERNAL_ERROR, NULL); - - return evar; + return index; } +typedef struct { + int32_t first; + int32_t count; +} query_iter_cursor_t; + static -ecs_rule_op_t* insert_operation( - ecs_rule_t *rule, - int32_t term_index, - bool *written) +int sparse_column_next( + ecs_table_t *table, + ecs_query_table_match_t *matched_table, + ecs_vector_t *sparse_columns, + ecs_query_iter_t *iter, + query_iter_cursor_t *cur, + bool filter) { - ecs_rule_pair_t pair = {0}; + bool first_iteration = false; + int32_t sparse_smallest; - /* Parse the term's type into a pair. A pair extracts the ids from - * the term, and replaces variables with wildcards which can then - * be matched against actual relationships. A pair retains the - * information about the variables, so that when a match happens, - * the pair can be used to reify the variable. */ - if (term_index != -1) { - ecs_term_t *term = &rule->filter.terms[term_index]; + if (!(sparse_smallest = iter->sparse_smallest)) { + sparse_smallest = iter->sparse_smallest = find_smallest_column( + table, matched_table, sparse_columns); + first_iteration = true; + } - pair = term_to_pair(rule, term); + sparse_smallest -= 1; - /* If the pair contains entity variables that have not yet been written, - * insert each instructions in case their tables are known. Variables in - * a pair that are truly unknown will be populated by the operation, - * but an operation should never overwrite an entity variable if the - * corresponding table variable has already been resolved. */ - if (pair.reg_mask & RULE_PAIR_PREDICATE) { - ecs_rule_var_t *pred = &rule->vars[pair.pred.reg]; - pred = get_most_specific_var(rule, pred, written); - pair.pred.reg = pred->id; - } + flecs_sparse_column_t *columns = ecs_vector_first( + sparse_columns, flecs_sparse_column_t); + flecs_sparse_column_t *column = &columns[sparse_smallest]; + ecs_switch_t *sw, *sw_smallest = column->sw_column->data; + ecs_entity_t case_smallest = column->sw_case; - if (pair.reg_mask & RULE_PAIR_OBJECT) { - ecs_rule_var_t *obj = &rule->vars[pair.obj.reg]; - obj = get_most_specific_var(rule, obj, written); - pair.obj.reg = obj->id; + /* Find next entity to iterate in sparse column */ + int32_t first, sparse_first = iter->sparse_first; + + if (!filter) { + if (first_iteration) { + first = flecs_switch_first(sw_smallest, case_smallest); + } else { + first = flecs_switch_next(sw_smallest, sparse_first); } } else { - /* Not all operations have a filter (like Each) */ + int32_t cur_first = cur->first, cur_count = cur->count; + first = cur_first; + while (flecs_switch_get(sw_smallest, first) != case_smallest) { + first ++; + if (first >= (cur_first + cur_count)) { + first = -1; + break; + } + } } - ecs_rule_op_t *op = create_operation(rule); - op->on_pass = rule->operation_count; - op->on_fail = rule->operation_count - 2; - op->frame = rule->frame_count; - op->filter = pair; + if (first == -1) { + goto done; + } - /* Store corresponding signature term so we can correlate and - * store the table columns with signature columns. */ - op->term = term_index; + /* Check if entity matches with other sparse columns, if any */ + int32_t i, count = ecs_vector_count(sparse_columns); + do { + for (i = 0; i < count; i ++) { + if (i == sparse_smallest) { + /* Already validated this one */ + continue; + } - return op; -} + column = &columns[i]; + sw = column->sw_column->data; -/* Insert first operation, which is always Input. This creates an entry in - * the register stack for the initial state. */ -static -void insert_input( - ecs_rule_t *rule) -{ - ecs_rule_op_t *op = create_operation(rule); - op->kind = EcsRuleInput; + if (flecs_switch_get(sw, first) != column->sw_case) { + first = flecs_switch_next(sw_smallest, first); + if (first == -1) { + goto done; + } + } + } + } while (i != count); - /* The first time Input is evaluated it goes to the next/first operation */ - op->on_pass = 1; + cur->first = iter->sparse_first = first; + cur->count = 1; - /* When Input is evaluated with redo = true it will return false, which will - * finish the program as op becomes -1. */ - op->on_fail = -1; + return 0; +done: + /* Iterated all elements in the sparse list, we should move to the + * next matched table. */ + iter->sparse_smallest = 0; + iter->sparse_first = 0; - push_frame(rule); + return -1; } -/* Insert last operation, which is always Yield. When the program hits Yield, - * data is returned to the application. */ +#define BS_MAX ((uint64_t)0xFFFFFFFFFFFFFFFF) + static -void insert_yield( - ecs_rule_t *rule) +int bitset_column_next( + ecs_table_t *table, + ecs_vector_t *bitset_columns, + ecs_query_iter_t *iter, + query_iter_cursor_t *cur) { - ecs_rule_op_t *op = create_operation(rule); - op->kind = EcsRuleYield; - op->has_in = true; - op->on_fail = rule->operation_count - 2; - /* Yield can only "fail" since it is the end of the program */ + /* Precomputed single-bit test */ + static const uint64_t bitmask[64] = { + (uint64_t)1 << 0, (uint64_t)1 << 1, (uint64_t)1 << 2, (uint64_t)1 << 3, + (uint64_t)1 << 4, (uint64_t)1 << 5, (uint64_t)1 << 6, (uint64_t)1 << 7, + (uint64_t)1 << 8, (uint64_t)1 << 9, (uint64_t)1 << 10, (uint64_t)1 << 11, + (uint64_t)1 << 12, (uint64_t)1 << 13, (uint64_t)1 << 14, (uint64_t)1 << 15, + (uint64_t)1 << 16, (uint64_t)1 << 17, (uint64_t)1 << 18, (uint64_t)1 << 19, + (uint64_t)1 << 20, (uint64_t)1 << 21, (uint64_t)1 << 22, (uint64_t)1 << 23, + (uint64_t)1 << 24, (uint64_t)1 << 25, (uint64_t)1 << 26, (uint64_t)1 << 27, + (uint64_t)1 << 28, (uint64_t)1 << 29, (uint64_t)1 << 30, (uint64_t)1 << 31, + (uint64_t)1 << 32, (uint64_t)1 << 33, (uint64_t)1 << 34, (uint64_t)1 << 35, + (uint64_t)1 << 36, (uint64_t)1 << 37, (uint64_t)1 << 38, (uint64_t)1 << 39, + (uint64_t)1 << 40, (uint64_t)1 << 41, (uint64_t)1 << 42, (uint64_t)1 << 43, + (uint64_t)1 << 44, (uint64_t)1 << 45, (uint64_t)1 << 46, (uint64_t)1 << 47, + (uint64_t)1 << 48, (uint64_t)1 << 49, (uint64_t)1 << 50, (uint64_t)1 << 51, + (uint64_t)1 << 52, (uint64_t)1 << 53, (uint64_t)1 << 54, (uint64_t)1 << 55, + (uint64_t)1 << 56, (uint64_t)1 << 57, (uint64_t)1 << 58, (uint64_t)1 << 59, + (uint64_t)1 << 60, (uint64_t)1 << 61, (uint64_t)1 << 62, (uint64_t)1 << 63 + }; - /* Find variable associated with this. It is possible that the variable - * exists both as a table and as an entity. This can happen when a rule - * first selects a table for this, but then subsequently needs to evaluate - * each entity in that table. In that case the yield instruction should - * return the entity, so look for that first. */ - ecs_rule_var_t *var = find_variable(rule, EcsRuleVarKindEntity, "."); - if (!var) { - var = find_variable(rule, EcsRuleVarKindTable, "."); - } + /* Precomputed test to verify if remainder of block is set (or not) */ + static const uint64_t bitmask_remain[64] = { + BS_MAX, BS_MAX - (BS_MAX >> 63), BS_MAX - (BS_MAX >> 62), + BS_MAX - (BS_MAX >> 61), BS_MAX - (BS_MAX >> 60), BS_MAX - (BS_MAX >> 59), + BS_MAX - (BS_MAX >> 58), BS_MAX - (BS_MAX >> 57), BS_MAX - (BS_MAX >> 56), + BS_MAX - (BS_MAX >> 55), BS_MAX - (BS_MAX >> 54), BS_MAX - (BS_MAX >> 53), + BS_MAX - (BS_MAX >> 52), BS_MAX - (BS_MAX >> 51), BS_MAX - (BS_MAX >> 50), + BS_MAX - (BS_MAX >> 49), BS_MAX - (BS_MAX >> 48), BS_MAX - (BS_MAX >> 47), + BS_MAX - (BS_MAX >> 46), BS_MAX - (BS_MAX >> 45), BS_MAX - (BS_MAX >> 44), + BS_MAX - (BS_MAX >> 43), BS_MAX - (BS_MAX >> 42), BS_MAX - (BS_MAX >> 41), + BS_MAX - (BS_MAX >> 40), BS_MAX - (BS_MAX >> 39), BS_MAX - (BS_MAX >> 38), + BS_MAX - (BS_MAX >> 37), BS_MAX - (BS_MAX >> 36), BS_MAX - (BS_MAX >> 35), + BS_MAX - (BS_MAX >> 34), BS_MAX - (BS_MAX >> 33), BS_MAX - (BS_MAX >> 32), + BS_MAX - (BS_MAX >> 31), BS_MAX - (BS_MAX >> 30), BS_MAX - (BS_MAX >> 29), + BS_MAX - (BS_MAX >> 28), BS_MAX - (BS_MAX >> 27), BS_MAX - (BS_MAX >> 26), + BS_MAX - (BS_MAX >> 25), BS_MAX - (BS_MAX >> 24), BS_MAX - (BS_MAX >> 23), + BS_MAX - (BS_MAX >> 22), BS_MAX - (BS_MAX >> 21), BS_MAX - (BS_MAX >> 20), + BS_MAX - (BS_MAX >> 19), BS_MAX - (BS_MAX >> 18), BS_MAX - (BS_MAX >> 17), + BS_MAX - (BS_MAX >> 16), BS_MAX - (BS_MAX >> 15), BS_MAX - (BS_MAX >> 14), + BS_MAX - (BS_MAX >> 13), BS_MAX - (BS_MAX >> 12), BS_MAX - (BS_MAX >> 11), + BS_MAX - (BS_MAX >> 10), BS_MAX - (BS_MAX >> 9), BS_MAX - (BS_MAX >> 8), + BS_MAX - (BS_MAX >> 7), BS_MAX - (BS_MAX >> 6), BS_MAX - (BS_MAX >> 5), + BS_MAX - (BS_MAX >> 4), BS_MAX - (BS_MAX >> 3), BS_MAX - (BS_MAX >> 2), + BS_MAX - (BS_MAX >> 1) + }; - /* If there is no this, there is nothing to yield. In that case the rule - * simply returns true or false. */ - if (!var) { - op->r_in = UINT8_MAX; - } else { - op->r_in = var->id; - } + int32_t i, count = ecs_vector_count(bitset_columns); + flecs_bitset_column_t *columns = ecs_vector_first( + bitset_columns, flecs_bitset_column_t); + int32_t bs_offset = table->bs_column_offset; - op->frame = push_frame(rule); -} + int32_t first = iter->bitset_first; + int32_t last = 0; -/* Return superset/subset including the root */ -static -void insert_reflexive_set( - ecs_rule_t *rule, - ecs_rule_op_kind_t op_kind, - ecs_rule_var_t *out, - const ecs_rule_pair_t pair, - int32_t c, - bool *written, - bool reflexive) -{ - ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); + for (i = 0; i < count; i ++) { + flecs_bitset_column_t *column = &columns[i]; + ecs_bs_column_t *bs_column = columns[i].bs_column; - ecs_rule_var_t *pred = pair_pred(rule, &pair); - ecs_rule_var_t *obj = pair_obj(rule, &pair); + if (!bs_column) { + int32_t index = column->column_index; + ecs_assert((index - bs_offset >= 0), ECS_INTERNAL_ERROR, NULL); + bs_column = &table->storage.bs_columns[index - bs_offset]; + columns[i].bs_column = bs_column; + } + + ecs_bitset_t *bs = &bs_column->data; + int32_t bs_elem_count = bs->count; + int32_t bs_block = first >> 6; + int32_t bs_block_count = ((bs_elem_count - 1) >> 6) + 1; - int32_t setjmp_lbl = rule->operation_count; - int32_t store_lbl = setjmp_lbl + 1; - int32_t set_lbl = setjmp_lbl + 2; - int32_t next_op = setjmp_lbl + 4; - int32_t prev_op = setjmp_lbl - 1; + if (bs_block >= bs_block_count) { + goto done; + } - /* Insert 4 operations at once, so we don't have to worry about how - * the instruction array reallocs. If operation is not reflexive, we only - * need to insert the set operation. */ - if (reflexive) { - insert_operation(rule, -1, written); - insert_operation(rule, -1, written); - insert_operation(rule, -1, written); - } + uint64_t *data = bs->data; + int32_t bs_start = first & 0x3F; - ecs_rule_op_t *op = insert_operation(rule, -1, written); - ecs_rule_op_t *setjmp = &rule->operations[setjmp_lbl]; - ecs_rule_op_t *store = &rule->operations[store_lbl]; - ecs_rule_op_t *set = &rule->operations[set_lbl]; - ecs_rule_op_t *jump = op; + /* Step 1: find the first non-empty block */ + uint64_t v = data[bs_block]; + uint64_t remain = bitmask_remain[bs_start]; + while (!(v & remain)) { + /* If no elements are remaining, move to next block */ + if ((++bs_block) >= bs_block_count) { + /* No non-empty blocks left */ + goto done; + } - if (!reflexive) { - set_lbl = setjmp_lbl; - set = op; - setjmp = NULL; - store = NULL; - jump = NULL; - next_op = set_lbl + 1; - prev_op = set_lbl - 1; - } + bs_start = 0; + remain = BS_MAX; /* Test the full block */ + v = data[bs_block]; + } - /* The SetJmp operation stores a conditional jump label that either - * points to the Store or *Set operation */ - if (reflexive) { - setjmp->kind = EcsRuleSetJmp; - setjmp->on_pass = store_lbl; - setjmp->on_fail = set_lbl; - } + /* Step 2: find the first non-empty element in the block */ + while (!(v & bitmask[bs_start])) { + bs_start ++; - /* The Store operation yields the root of the subtree. After yielding, - * this operation will fail and return to SetJmp, which will cause it - * to switch to the *Set operation. */ - if (reflexive) { - store->kind = EcsRuleStore; - store->on_pass = next_op; - store->on_fail = setjmp_lbl; - store->has_in = true; - store->has_out = true; - store->r_out = out->id; - store->term = c; + /* Block was not empty, so bs_start must be smaller than 64 */ + ecs_assert(bs_start < 64, ECS_INTERNAL_ERROR, NULL); + } + + /* Step 3: Find number of contiguous enabled elements after start */ + int32_t bs_end = bs_start, bs_block_end = bs_block; + + remain = bitmask_remain[bs_end]; + while ((v & remain) == remain) { + bs_end = 0; + bs_block_end ++; - if (!pred) { - store->filter.pred = pair.pred; - } else { - store->filter.pred.reg = pred->id; - store->filter.reg_mask |= RULE_PAIR_PREDICATE; + if (bs_block_end == bs_block_count) { + break; + } + + v = data[bs_block_end]; + remain = BS_MAX; /* Test the full block */ } - /* If the object of the filter is not a variable, store literal */ - if (!obj) { - store->r_in = UINT8_MAX; - store->subject = ecs_get_alive(rule->world, pair.obj.ent); - store->filter.obj = pair.obj; - } else { - store->r_in = obj->id; - store->filter.obj.reg = obj->id; - store->filter.reg_mask |= RULE_PAIR_OBJECT; + /* Step 4: find remainder of enabled elements in current block */ + if (bs_block_end != bs_block_count) { + while ((v & bitmask[bs_end])) { + bs_end ++; + } } - } - /* This is either a SubSet or SuperSet operation */ - set->kind = op_kind; - set->on_pass = next_op; - set->on_fail = prev_op; - set->has_out = true; - set->r_out = out->id; - set->term = c; + /* Block was not 100% occupied, so bs_start must be smaller than 64 */ + ecs_assert(bs_end < 64, ECS_INTERNAL_ERROR, NULL); - /* Predicate can be a variable if it's non-final */ - if (!pred) { - set->filter.pred = pair.pred; - } else { - set->filter.pred.reg = pred->id; - set->filter.reg_mask |= RULE_PAIR_PREDICATE; - } + /* Step 5: translate to element start/end and make sure that each column + * range is a subset of the previous one. */ + first = bs_block * 64 + bs_start; + int32_t cur_last = bs_block_end * 64 + bs_end; + + /* No enabled elements found in table */ + if (first == cur_last) { + goto done; + } - if (!obj) { - set->filter.obj = pair.obj; - } else { - set->filter.obj.reg = obj->id; - set->filter.reg_mask |= RULE_PAIR_OBJECT; - } + /* If multiple bitsets are evaluated, make sure each subsequent range + * is equal or a subset of the previous range */ + if (i) { + /* If the first element of a subsequent bitset is larger than the + * previous last value, start over. */ + if (first >= last) { + i = -1; + continue; + } - if (reflexive) { - /* The jump operation jumps to either the store or subset operation, - * depending on whether the store operation already yielded. The - * operation is inserted last, so that the on_fail label of the next - * operation will point to it */ - jump->kind = EcsRuleJump; + /* Make sure the last element of the range doesn't exceed the last + * element of the previous range. */ + if (cur_last > last) { + cur_last = last; + } + } + + last = cur_last; + int32_t elem_count = last - first; + + /* Make sure last element doesn't exceed total number of elements in + * the table */ + if (elem_count > (bs_elem_count - first)) { + elem_count = (bs_elem_count - first); + if (!elem_count) { + iter->bitset_first = 0; + goto done; + } + } - /* The pass/fail labels of the Jump operation are not used, since it - * jumps to a variable location. Instead, the pass label is (ab)used to - * store the label of the SetJmp operation, so that the jump can access - * the label it needs to jump to from the setjmp op_ctx. */ - jump->on_pass = setjmp_lbl; - jump->on_fail = -1; + cur->first = first; + cur->count = elem_count; + iter->bitset_first = first; } + + /* Keep track of last processed element for iteration */ + iter->bitset_first = last; - written[out->id] = true; + return 0; +done: + iter->sparse_smallest = 0; + iter->sparse_first = 0; + return -1; } static -ecs_rule_var_t* store_reflexive_set( - ecs_rule_t *rule, - ecs_rule_op_kind_t op_kind, - ecs_rule_pair_t *pair, - bool *written, - bool reflexive, - bool as_entity) +void mark_columns_dirty( + ecs_query_t *query, + ecs_query_table_match_t *table_data) { - /* Ensure we're using the most specific version of obj */ - ecs_rule_var_t *obj = pair_obj(rule, pair); - if (obj) { - pair->obj.reg = obj->id; - } - - /* The subset operation returns tables */ - ecs_rule_var_kind_t var_kind = EcsRuleVarKindTable; - if (op_kind == EcsSuperSet) { - var_kind = EcsRuleVarKindEntity; - } - - /* Create anonymous variable for storing the set */ - ecs_rule_var_t *av = create_anonymous_variable(rule, var_kind); - int32_t ave_id = 0, av_id = av->id; + ecs_table_t *table = table_data->table; - /* If the variable kind is a table, also create an entity variable as the - * result of the set operation should be returned as an entity */ - if (var_kind == EcsRuleVarKindTable && as_entity) { - create_variable(rule, EcsRuleVarKindEntity, av->name); - av = &rule->vars[av_id]; - ave_id = av_id + 1; - } + if (table && table->dirty_state) { + ecs_term_t *terms = query->filter.terms; + int32_t i, count = query->filter.term_count_actual; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + int32_t ti = term->index; - /* Generate the operations */ - insert_reflexive_set(rule, op_kind, av, *pair, -1, written, reflexive); + if (term->inout == EcsIn || term->inout == EcsInOutFilter) { + /* Don't mark readonly terms dirty */ + continue; + } - /* Make sure to return entity variable, and that it is populated */ - if (as_entity) { - return ensure_entity_written(rule, &rule->vars[ave_id], written); - } else { - return &rule->vars[av_id]; - } -} + if (table_data->subjects[ti] != 0) { + /* Don't mark table dirty if term is not from the table */ + continue; + } -static -bool is_known( - ecs_rule_var_t *var, - bool *written) -{ - if (!var) { - return true; - } else { - return written[var->id]; + int32_t index = table_data->columns[ti]; + if (index <= 0) { + /* If term is not set, there's nothing to mark dirty */ + continue; + } + + /* Potential candidate for marking table dirty, if a component */ + int32_t storage_index = ecs_table_type_to_storage_index( + table, index - 1); + if (storage_index >= 0) { + table->dirty_state[storage_index + 1] ++; + } + } } } -static -bool is_pair_known( - ecs_rule_t *rule, - ecs_rule_pair_t *pair, - bool *written) +bool ecs_query_next( + ecs_iter_t *it) { - ecs_rule_var_t *pred_var = pair_pred(rule, pair); - if (!is_known(pred_var, written) || pair->pred.ent == EcsWildcard) { - return false; - } + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); - ecs_rule_var_t *obj_var = pair_obj(rule, pair); - if (!is_known(obj_var, written) || pair->obj.ent == EcsWildcard) { - return false; + if (flecs_iter_next_row(it)) { + return true; } - return true; + return flecs_iter_next_instanced(it, ecs_query_next_instanced(it)); +error: + return false; } -static -void set_input_to_subj( - ecs_rule_t *rule, - ecs_rule_op_t *op, - ecs_term_t *term, - ecs_rule_var_t *var) +bool ecs_query_next_instanced( + ecs_iter_t *it) { - (void)rule; - - op->has_in = true; - if (!var) { - op->r_in = UINT8_MAX; - op->subject = term->subj.entity; + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); - /* Invalid entities should have been caught during parsing */ - ecs_assert(ecs_is_valid(rule->world, op->subject), - ECS_INTERNAL_ERROR, NULL); - } else { - op->r_in = var->id; - } -} + ecs_query_iter_t *iter = &it->priv.iter.query; + ecs_query_t *query = iter->query; + ecs_world_t *world = query->world; + ecs_flags32_t flags = query->flags; + (void)world; -static -void set_output_to_subj( - ecs_rule_t *rule, - ecs_rule_op_t *op, - ecs_term_t *term, - ecs_rule_var_t *var) -{ - (void)rule; + it->is_valid = true; - op->has_out = true; - if (!var) { - op->r_out = UINT8_MAX; - op->subject = term->subj.entity; + ecs_poly_assert(world, ecs_world_t); - /* Invalid entities should have been caught during parsing */ - ecs_assert(ecs_is_valid(rule->world, op->subject), - ECS_INTERNAL_ERROR, NULL); - } else { - op->r_out = var->id; + if (!query->constraints_satisfied) { + goto done; } -} - -static -void insert_select_or_with( - ecs_rule_t *rule, - int32_t c, - ecs_term_t *term, - ecs_rule_var_t *subj, - ecs_rule_pair_t *pair, - bool *written) -{ - ecs_rule_op_t *op; - bool eval_subject_supersets = false; - /* Find any entity and/or table variables for subject */ - ecs_rule_var_t *tvar = NULL, *evar = to_entity(rule, subj), *var = evar; - if (subj && subj->kind == EcsRuleVarKindTable) { - tvar = subj; - if (!evar) { - var = tvar; + query_iter_cursor_t cur; + ecs_query_table_node_t *node, *next, *prev; + if ((prev = iter->prev)) { + /* Match has been iterated, update monitor for change tracking */ + if (flags & EcsQueryHasMonitor) { + sync_match_monitor(query, prev->match); + } + if (flags & EcsQueryHasOutColumns) { + mark_columns_dirty(query, prev->match); } } - int32_t lbl_start = rule->operation_count; - ecs_rule_pair_t filter; - if (pair) { - filter = *pair; - } else { - filter = term_to_pair(rule, term); - } - - /* Only insert implicit IsA if filter isn't already an IsA */ - if (!filter.transitive || filter.pred.ent != EcsIsA) { - if (!var) { - ecs_rule_pair_t isa_pair = { - .pred.ent = EcsIsA, - .obj.ent = term->subj.entity - }; + iter->skip_count = 0; - evar = subj = store_reflexive_set(rule, EcsRuleSuperSet, &isa_pair, - written, true, true); - tvar = NULL; - eval_subject_supersets = true; + for (node = iter->node; node != NULL; node = next) { + ecs_query_table_match_t *match = node->match; + ecs_table_t *table = match->table; - } else if (ecs_id_is_wildcard(term->id)) { - ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); + next = node->next; - op = insert_operation(rule, -1, written); + if (table) { + cur.first = node->offset; + cur.count = node->count; + if (!cur.count) { + cur.count = ecs_table_count(table); - if (!is_known(subj, written)) { - op->kind = EcsRuleSelect; - set_output_to_subj(rule, op, term, subj); - written[subj->id] = true; - } else { - op->kind = EcsRuleWith; - set_input_to_subj(rule, op, term, subj); + /* List should never contain empty tables */ + ecs_assert(cur.count != 0, ECS_INTERNAL_ERROR, NULL); } - ecs_rule_pair_t isa_pair = { - .pred.ent = EcsIsA, - .obj.reg = subj->id, - .reg_mask = RULE_PAIR_OBJECT - }; + ecs_vector_t *bitset_columns = match->bitset_columns; + ecs_vector_t *sparse_columns = match->sparse_columns; - op->filter = filter; - if (op->filter.reg_mask & RULE_PAIR_PREDICATE) { - op->filter.pred.ent = EcsWildcard; - } - if (op->filter.reg_mask & RULE_PAIR_OBJECT) { - op->filter.obj.ent = EcsWildcard; - } - op->filter.reg_mask = 0; + if (bitset_columns || sparse_columns) { + bool found = false; - push_frame(rule); + do { + found = false; - tvar = subj = store_reflexive_set(rule, EcsRuleSuperSet, &isa_pair, - written, true, false); + if (bitset_columns) { + if (bitset_column_next(table, bitset_columns, iter, + &cur) == -1) + { + /* No more enabled components for table */ + iter->bitset_first = 0; + break; + } else { + found = true; + next = node; + } + } - evar = NULL; + if (sparse_columns) { + if (sparse_column_next(table, match, + sparse_columns, iter, &cur, found) == -1) + { + /* No more elements in sparse column */ + if (found) { + /* Try again */ + next = node->next; + found = false; + } else { + /* Nothing found */ + iter->bitset_first = 0; + break; + } + } else { + found = true; + next = node; + iter->bitset_first = cur.first + cur.count; + } + } + } while (!found); + + if (!found) { + continue; + } + } + } else { + cur.count = 0; + cur.first = 0; } - } - /* If no pair is provided, create operation from specified term */ - if (!pair) { - op = insert_operation(rule, c, written); + it->ids = match->ids; + it->columns = match->columns; + it->subjects = match->subjects; + it->sizes = match->sizes; + it->references = match->references; + it->instance_count = 0; - /* If an explicit pair is provided, override the default one from the - * term. This allows for using a predicate or object variable different - * from what is in the term. One application of this is to substitute a - * predicate with its subsets, if it is non final */ - } else { - op = insert_operation(rule, -1, written); - op->filter = *pair; + flecs_iter_init(it); + flecs_iter_populate_data(world, it, match->table, cur.first, cur.count, + it->ptrs, NULL); - /* Assign the term id, so that the operation will still be correctly - * associated with the correct expression term. */ - op->term = c; + iter->node = next; + iter->prev = node; + goto yield; } - /* If entity variable is known and resolved, create with for it */ - if (evar && is_known(evar, written)) { - op->kind = EcsRuleWith; - op->r_in = evar->id; - set_input_to_subj(rule, op, term, subj); +done: +error: + ecs_iter_fini(it); + return false; + +yield: + return true; +} - /* If table variable is known and resolved, create with for it */ - } else if (tvar && is_known(tvar, written)) { - op->kind = EcsRuleWith; - op->r_in = tvar->id; - set_input_to_subj(rule, op, term, subj); +bool ecs_query_changed( + ecs_query_t *query, + const ecs_iter_t *it) +{ + if (it) { + ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - /* If subject is neither table nor entitiy, with operates on literal */ - } else if (!tvar && !evar) { - op->kind = EcsRuleWith; - set_input_to_subj(rule, op, term, subj); + ecs_query_table_match_t *qt = + (ecs_query_table_match_t*)it->priv.iter.query.prev; + ecs_assert(qt != NULL, ECS_INVALID_PARAMETER, NULL); - /* If subject is table or entity but not known, use select */ - } else { - ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); - op->kind = EcsRuleSelect; - set_output_to_subj(rule, op, term, subj); - written[subj->id] = true; - } + if (!query) { + query = it->priv.iter.query.query; + } else { + ecs_check(query == it->priv.iter.query.query, + ECS_INVALID_PARAMETER, NULL); + } - /* If supersets of subject are being evaluated, and we're looking for a - * specific filter, stop as soon as the filter has been matched. */ - if (eval_subject_supersets && is_pair_known(rule, &op->filter, written)) { - op = insert_operation(rule, -1, written); + ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_poly_assert(query, ecs_query_t); - /* When the next operation returns, it will first hit SetJmp with a redo - * which will switch the jump label to the previous operation */ - op->kind = EcsRuleSetJmp; - op->on_pass = rule->operation_count; - op->on_fail = lbl_start - 1; + flecs_process_pending_tables(it->real_world); + + return check_match_monitor(query, qt); } - if (op->filter.reg_mask & RULE_PAIR_PREDICATE) { - written[op->filter.pred.reg] = true; + ecs_poly_assert(query, ecs_query_t); + ecs_check(!(query->flags & EcsQueryIsOrphaned), + ECS_INVALID_PARAMETER, NULL); + + flecs_process_pending_tables(query->world); + + if (!(query->flags & EcsQueryHasMonitor)) { + query->flags |= EcsQueryHasMonitor; + init_query_monitors(query); + return true; /* Monitors didn't exist yet */ } - if (op->filter.reg_mask & RULE_PAIR_OBJECT) { - written[op->filter.obj.reg] = true; + if (query->match_count != query->prev_match_count) { + return true; } + + return check_query_monitor(query); +error: + return false; } -static -void prepare_predicate( - ecs_rule_t *rule, - ecs_rule_pair_t *pair, - int32_t term, - bool *written) +void ecs_query_skip( + ecs_iter_t *it) { - /* If pair is not final, resolve term for all IsA relationships of the - * predicate. Note that if the pair has final set to true, it is guaranteed - * that the predicate can be used in an IsA query */ - if (!pair->final) { - ecs_rule_pair_t isa_pair = { - .pred.ent = EcsIsA, - .obj.ent = pair->pred.ent - }; - - ecs_rule_var_t *pred = store_reflexive_set(rule, EcsRuleSubSet, - &isa_pair, written, true, true); - - pair->pred.reg = pred->id; - pair->reg_mask |= RULE_PAIR_PREDICATE; + ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); + ecs_assert(it->is_valid, ECS_INVALID_PARAMETER, NULL); - if (term != -1) { - rule->term_vars[term].pred = pred->id; + if (it->instance_count > it->count) { + it->priv.iter.query.skip_count ++; + if (it->priv.iter.query.skip_count == it->instance_count) { + /* For non-instanced queries, make sure all entities are skipped */ + it->priv.iter.query.prev = NULL; } + } else { + it->priv.iter.query.prev = NULL; } } -static -void insert_term_2( - ecs_rule_t *rule, - ecs_term_t *term, - ecs_rule_pair_t *filter, - int32_t c, - bool *written) +bool ecs_query_orphaned( + ecs_query_t *query) { - int32_t subj_id = -1, obj_id = -1; - ecs_rule_var_t *subj = term_subj(rule, term); - if ((subj = get_most_specific_var(rule, subj, written))) { - subj_id = subj->id; - } + ecs_poly_assert(query, ecs_query_t); + return query->flags & EcsQueryIsOrphaned; +} - ecs_rule_var_t *obj = term_obj(rule, term); - if ((obj = get_most_specific_var(rule, obj, written))) { - obj_id = obj->id; - } +#include - bool subj_known = is_known(subj, written); - bool same_obj_subj = false; - if (subj && obj) { - same_obj_subj = !ecs_os_strcmp(subj->name, obj->name); +#define INIT_CACHE(it, f, term_count)\ + if (!it->f && term_count) {\ + if (term_count <= ECS_TERM_CACHE_SIZE) {\ + it->f = it->priv.cache.f;\ + it->priv.cache.f##_alloc = false;\ + } else {\ + it->f = ecs_os_calloc(ECS_SIZEOF(*(it->f)) * term_count);\ + it->priv.cache.f##_alloc = true;\ + }\ } - if (!filter->transitive) { - insert_select_or_with(rule, c, term, subj, filter, written); - if (subj) subj = &rule->vars[subj_id]; - if (obj) obj = &rule->vars[obj_id]; - - } else if (filter->transitive) { - if (subj_known) { - if (is_known(obj, written)) { - if (filter->obj.ent != EcsWildcard) { - ecs_rule_var_t *obj_subsets = store_reflexive_set( - rule, EcsRuleSubSet, filter, written, true, true); - - if (subj) { - subj = &rule->vars[subj_id]; - } - - rule->term_vars[c].obj = obj_subsets->id; - - ecs_rule_pair_t pair = *filter; - pair.obj.reg = obj_subsets->id; - pair.reg_mask |= RULE_PAIR_OBJECT; - - insert_select_or_with(rule, c, term, subj, &pair, written); - } else { - insert_select_or_with(rule, c, term, subj, filter, written); - } - } else { - ecs_assert(obj != NULL, ECS_INTERNAL_ERROR, NULL); - - /* If subject is literal, find supersets for subject */ - if (subj == NULL || subj->kind == EcsRuleVarKindEntity) { - obj = to_entity(rule, obj); - - ecs_rule_pair_t set_pair = *filter; - set_pair.reg_mask &= RULE_PAIR_PREDICATE; - - if (subj) { - set_pair.obj.reg = subj->id; - set_pair.reg_mask |= RULE_PAIR_OBJECT; - } else { - set_pair.obj.ent = term->subj.entity; - } - - insert_reflexive_set(rule, EcsRuleSuperSet, obj, set_pair, - c, written, filter->reflexive); - - /* If subject is variable, first find matching pair for the - * evaluated entity(s) and return supersets */ - } else { - ecs_rule_var_t *av = create_anonymous_variable( - rule, EcsRuleVarKindEntity); - - subj = &rule->vars[subj_id]; - obj = &rule->vars[obj_id]; - obj = to_entity(rule, obj); - - ecs_rule_pair_t set_pair = *filter; - set_pair.obj.reg = av->id; - set_pair.reg_mask |= RULE_PAIR_OBJECT; +#define FINI_CACHE(it, f)\ + if (it->f) {\ + if (it->priv.cache.f##_alloc) {\ + ecs_os_free((void*)it->f);\ + }\ + } - /* Insert with to find initial object for relation */ - insert_select_or_with( - rule, c, term, subj, &set_pair, written); +void flecs_iter_init( + ecs_iter_t *it) +{ + INIT_CACHE(it, ids, it->term_count); + INIT_CACHE(it, subjects, it->term_count); + INIT_CACHE(it, match_indices, it->term_count); + INIT_CACHE(it, columns, it->term_count); + + if (!it->is_filter) { + INIT_CACHE(it, sizes, it->term_count); + INIT_CACHE(it, ptrs, it->term_count); + } else { + it->sizes = NULL; + it->ptrs = NULL; + } - push_frame(rule); + it->is_valid = true; +} - /* Find supersets for returned initial object. Make sure - * this is always reflexive since it needs to return the - * object from the pair that the entity has itself. */ - insert_reflexive_set(rule, EcsRuleSuperSet, obj, set_pair, - c, written, true); - } - } +void ecs_iter_fini( + ecs_iter_t *it) +{ + ecs_check(it->is_valid == true, ECS_INVALID_PARAMETER, NULL); + it->is_valid = false; - /* subj is not known */ - } else { - ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); + if (it->fini) { + it->fini(it); + } - if (is_known(obj, written)) { - ecs_rule_pair_t set_pair = *filter; - set_pair.reg_mask &= RULE_PAIR_PREDICATE; /* clear object mask */ + FINI_CACHE(it, ids); + FINI_CACHE(it, columns); + FINI_CACHE(it, subjects); + FINI_CACHE(it, sizes); + FINI_CACHE(it, ptrs); + FINI_CACHE(it, match_indices); +error: + return; +} - if (obj) { - set_pair.obj.reg = obj->id; - set_pair.reg_mask |= RULE_PAIR_OBJECT; - } else { - set_pair.obj.ent = term->obj.entity; - } +static +bool flecs_iter_populate_term_data( + ecs_world_t *world, + ecs_iter_t *it, + int32_t t, + int32_t column, + void **ptr_out, + ecs_size_t *size_out) +{ + bool is_shared = false; - if (obj) { - rule->term_vars[c].obj = obj->id; - } else { - ecs_rule_var_t *av = create_anonymous_variable(rule, - EcsRuleVarKindEntity); - rule->term_vars[c].obj = av->id; - written[av->id] = true; - } + if (!column) { + /* Term has no data. This includes terms that have Not operators. */ + goto no_data; + } - insert_reflexive_set(rule, EcsRuleSubSet, subj, set_pair, c, - written, filter->reflexive); - } else if (subj == obj) { - insert_select_or_with(rule, c, term, subj, filter, written); - } else { - ecs_assert(obj != NULL, ECS_INTERNAL_ERROR, NULL); + if (!it->terms) { + goto no_data; + } - ecs_rule_var_t *av = NULL; - if (!filter->reflexive) { - av = create_anonymous_variable(rule, EcsRuleVarKindEntity); - } + /* Filter terms may match with data but don't return it */ + if (it->terms[t].inout == EcsInOutFilter) { + goto no_data; + } - subj = &rule->vars[subj_id]; - obj = &rule->vars[obj_id]; - obj = to_entity(rule, obj); + ecs_table_t *table; + ecs_vector_t *vec; + ecs_size_t size; + ecs_size_t align; + int32_t row; - /* Insert instruction to find all subjects and objects */ - ecs_rule_op_t *op = insert_operation(rule, -1, written); - op->kind = EcsRuleSelect; - set_output_to_subj(rule, op, term, subj); - op->filter.pred = filter->pred; + if (column < 0) { + is_shared = true; - if (filter->reflexive) { - op->filter.obj.ent = EcsWildcard; - op->filter.reg_mask = filter->reg_mask & RULE_PAIR_PREDICATE; - } else { - op->filter.obj.reg = av->id; - op->filter.reg_mask = filter->reg_mask | RULE_PAIR_OBJECT; - written[av->id] = true; - } + /* Data is not from This */ + if (it->references) { + /* Iterator provides cached references for non-This terms */ + ecs_ref_t *ref = &it->references[-column - 1]; + if (ptr_out) ptr_out[0] = (void*)ecs_get_ref_id( + world, ref, ref->entity, ref->component); - written[subj->id] = true; + /* If cached references were provided, the code that populated + * the iterator also had a chance to cache sizes, so size array + * should already have been assigned. This saves us from having + * to do additional lookups to find the component size. */ + ecs_assert(size_out == NULL, ECS_INTERNAL_ERROR, NULL); + return true; + } else { + ecs_entity_t subj = it->subjects[t]; + ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL); - /* Create new frame for operations that create reflexive set */ - push_frame(rule); + /* Don't use ecs_get_id directly. Instead, go directly to the + * storage so that we can get both the pointer and size */ + ecs_record_t *r = ecs_eis_get(world, subj); + ecs_assert(r != NULL && r->table != NULL, ECS_INTERNAL_ERROR, NULL); - /* Insert superset instruction to find all supersets */ - if (filter->reflexive) { - subj = ensure_most_specific_var(rule, subj, written); - ecs_assert(subj->kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(written[subj->id] == true, - ECS_INTERNAL_ERROR, NULL); + row = ECS_RECORD_TO_ROW(r->row); + table = r->table; - ecs_rule_pair_t super_filter = {0}; - super_filter.pred = filter->pred; - super_filter.obj.reg = subj->id; - super_filter.reg_mask = filter->reg_mask | RULE_PAIR_OBJECT; + ecs_id_t id = it->ids[t]; + ecs_table_t *s_table = table->storage_table; + ecs_table_record_t *tr; - insert_reflexive_set(rule, EcsRuleSuperSet, obj, - super_filter, c, written, true); + if (!s_table || !(tr = flecs_get_table_record(world, s_table, id))){ + /* The entity has no components or the id is not a component */ + + ecs_id_t term_id = it->terms[t].id; + if (ECS_HAS_ROLE(term_id, SWITCH) || ECS_HAS_ROLE(term_id, CASE)) { + /* Edge case: if this is a switch. Find switch column in + * actual table, as its not in the storage table */ + tr = flecs_get_table_record(world, table, id); + ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL); + column = tr->column; + goto has_switch; } else { - insert_reflexive_set(rule, EcsRuleSuperSet, obj, - op->filter, c, written, true); + goto no_data; } } + + /* We now have row and column, so we can get the storage for the id + * which gives us the pointer and size */ + column = tr->column; + ecs_column_t *s = &table->storage.columns[column]; + size = s->size; + align = s->alignment; + vec = s->data; + /* Fallthrough to has_data */ + } + } else { + /* Data is from This, use table from iterator */ + table = it->table; + if (!table || !ecs_table_count(table)) { + goto no_data; } - } - if (same_obj_subj) { - /* Can't have relation with same variables that is acyclic and not - * reflexive, this should've been caught earlier. */ - ecs_assert(!filter->acyclic || filter->reflexive, - ECS_INTERNAL_ERROR, NULL); + row = it->offset; + + int32_t storage_column = ecs_table_type_to_storage_index( + table, column - 1); + if (storage_column == -1) { + ecs_id_t id = it->terms[t].id; + if (ECS_HAS_ROLE(id, SWITCH) || ECS_HAS_ROLE(id, CASE)) { + goto has_switch; + } + goto no_data; + } - /* If relation is reflexive and entity has an instance of R, no checks - * are needed because R(X, X) is always true. */ - if (!filter->reflexive) { - push_frame(rule); + ecs_column_t *s = &table->storage.columns[storage_column]; + size = s->size; + align = s->alignment; + vec = s->data; + /* Fallthrough to has_data */ + } - /* Insert check if the (R, X) pair that was found matches with one - * of the entities in the table with the pair. */ - ecs_rule_op_t *op = insert_operation(rule, -1, written); - obj = get_most_specific_var(rule, obj, written); - ecs_assert(obj->kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(written[subj->id] == true, ECS_INTERNAL_ERROR, NULL); - ecs_assert(written[obj->id] == true, ECS_INTERNAL_ERROR, NULL); - - set_input_to_subj(rule, op, term, subj); - op->filter.obj.reg = obj->id; - op->filter.reg_mask = RULE_PAIR_OBJECT; +has_data: + if (ptr_out) ptr_out[0] = ecs_vector_get_t(vec, size, align, row); + if (size_out) size_out[0] = size; + return is_shared; - if (subj->kind == EcsRuleVarKindTable) { - op->kind = EcsRuleInTable; - } else { - op->kind = EcsRuleEq; - } - } +has_switch: { + /* Edge case: if column is a switch we should return the vector with case + * identifiers. Will be replaced in the future with pluggable storage */ + ecs_switch_t *sw = table->storage.sw_columns[ + (column - 1) - table->sw_column_offset].data; + vec = flecs_switch_values(sw); + size = ECS_SIZEOF(ecs_entity_t); + align = ECS_ALIGNOF(ecs_entity_t); + goto has_data; } -} -static -void insert_term_1( - ecs_rule_t *rule, - ecs_term_t *term, - ecs_rule_pair_t *filter, - int32_t c, - bool *written) -{ - ecs_rule_var_t *subj = term_subj(rule, term); - subj = get_most_specific_var(rule, subj, written); - insert_select_or_with(rule, c, term, subj, filter, written); +no_data: + if (ptr_out) ptr_out[0] = NULL; + if (size_out) size_out[0] = 0; + return false; } -static -void insert_term( - ecs_rule_t *rule, - ecs_term_t *term, - int32_t c, - bool *written) +void flecs_iter_populate_data( + ecs_world_t *world, + ecs_iter_t *it, + ecs_table_t *table, + int32_t offset, + int32_t count, + void **ptrs, + ecs_size_t *sizes) { - bool obj_set = obj_is_set(term); - - ensure_most_specific_var(rule, term_pred(rule, term), written); - if (obj_set) { - ensure_most_specific_var(rule, term_obj(rule, term), written); - } - - /* If term has Not operator, prepend Not which turns a fail into a pass */ - int32_t prev = rule->operation_count; - ecs_rule_op_t *not_pre; - if (term->oper == EcsNot) { - not_pre = insert_operation(rule, -1, written); - not_pre->kind = EcsRuleNot; - not_pre->has_in = false; - not_pre->has_out = false; + if (it->table) { + it->frame_offset += ecs_table_count(it->table); } - ecs_rule_pair_t filter = term_to_pair(rule, term); - prepare_predicate(rule, &filter, c, written); + it->table = table; + it->offset = offset; + it->count = count; - if (subj_is_set(term) && !obj_set) { - insert_term_1(rule, term, &filter, c, written); - } else if (obj_set) { - insert_term_2(rule, term, &filter, c, written); + if (table) { + it->type = it->table->type; + if (!count) { + count = it->count = ecs_table_count(table); + } + if (count) { + it->entities = ecs_vector_get( + table->storage.entities, ecs_entity_t, offset); + } else { + it->entities = NULL; + } } - /* If term has Not operator, append Not which turns a pass into a fail */ - if (term->oper == EcsNot) { - ecs_rule_op_t *not_post = insert_operation(rule, -1, written); - not_post->kind = EcsRuleNot; - not_post->has_in = false; - not_post->has_out = false; - - not_post->on_pass = prev - 1; - not_post->on_fail = prev - 1; - not_pre = &rule->operations[prev]; - not_pre->on_fail = rule->operation_count; + if (it->is_filter) { + it->has_shared = false; + return; } - if (term->oper == EcsOptional) { - /* Insert Not instruction that ensures that the optional term is only - * executed once */ - ecs_rule_op_t *jump = insert_operation(rule, -1, written); - jump->kind = EcsRuleNot; - jump->has_in = false; - jump->has_out = false; - jump->on_pass = rule->operation_count; - jump->on_fail = prev - 1; + int t, term_count = it->term_count; + bool has_shared = false; - /* Find exit instruction for optional term, and make the fail label - * point to the Not operation, so that even when the operation fails, - * it won't discard the result */ - int i, min_fail = -1, exit_op = -1; - for (i = prev; i < rule->operation_count; i ++) { - ecs_rule_op_t *op = &rule->operations[i]; - if (min_fail == -1 || (op->on_fail >= 0 && op->on_fail < min_fail)){ - min_fail = op->on_fail; - exit_op = i; + if (ptrs && sizes) { + for (t = 0; t < term_count; t ++) { + int32_t column = it->columns[t]; + has_shared |= flecs_iter_populate_term_data(world, it, t, column, + &ptrs[t], + &sizes[t]); + } + } else { + for (t = 0; t < term_count; t ++) { + int32_t column = it->columns[t]; + void **ptr = NULL; + if (ptrs) { + ptr = &ptrs[t]; + } + ecs_size_t *size = NULL; + if (sizes) { + size = &sizes[t]; } + has_shared |= flecs_iter_populate_term_data(world, it, t, column, + ptr, size); } - - ecs_assert(exit_op != -1, ECS_INTERNAL_ERROR, NULL); - ecs_rule_op_t *op = &rule->operations[exit_op]; - op->on_fail = rule->operation_count - 1; } - push_frame(rule); + it->has_shared = has_shared; } -/* Create program from operations that will execute the query */ -static -void compile_program( - ecs_rule_t *rule) +bool flecs_iter_next_row( + ecs_iter_t *it) { - /* Trace which variables have been written while inserting instructions. - * This determines which instruction needs to be inserted */ - bool written[ECS_RULE_MAX_VAR_COUNT] = { false }; + ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_term_t *terms = rule->filter.terms; - int32_t v, c, term_count = rule->filter.term_count; - ecs_rule_op_t *op; + bool is_instanced = it->is_instanced; + if (!is_instanced) { + int32_t instance_count = it->instance_count; + int32_t count = it->count; + int32_t offset = it->offset; - /* Insert input, which is always the first instruction */ - insert_input(rule); + if (instance_count > count && offset < (instance_count - 1)) { + ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL); + int t, term_count = it->term_count; - /* First insert all instructions that do not have a variable subject. Such - * instructions iterate the type of an entity literal and are usually good - * candidates for quickly narrowing down the set of potential results. */ - for (c = 0; c < term_count; c ++) { - ecs_term_t *term = &terms[c]; - if (skip_term(term)) { - continue; - } + for (t = 0; t < term_count; t ++) { + int32_t column = it->columns[t]; + if (column >= 0) { + void *ptr = it->ptrs[t]; + if (ptr) { + it->ptrs[t] = ECS_OFFSET(ptr, it->sizes[t]); + } + } + } - if (term->oper == EcsOptional) { - continue; - } + if (it->entities) { + it->entities ++; + } + it->offset ++; - ecs_rule_var_t* subj = term_subj(rule, term); - if (subj) { - continue; + return true; } - - insert_term(rule, term, c, written); } - /* Insert variables based on dependency order */ - for (v = 0; v < rule->subj_var_count; v ++) { - ecs_rule_var_t *var = &rule->vars[v]; - - ecs_assert(var->kind == EcsRuleVarKindTable, ECS_INTERNAL_ERROR, NULL); - - for (c = 0; c < term_count; c ++) { - ecs_term_t *term = &terms[c]; - if (skip_term(term)) { - continue; - } - - if (term->oper == EcsOptional) { - continue; - } + return false; +} - /* Only process columns for which variable is subject */ - ecs_rule_var_t* subj = term_subj(rule, term); - if (subj != var) { - continue; - } +bool flecs_iter_next_instanced( + ecs_iter_t *it, + bool result) +{ + it->instance_count = it->count; + if (result && !it->is_instanced && it->count && it->has_shared) { + it->count = 1; + } + return result; +} - insert_term(rule, term, c, written); +/* --- Public API --- */ - var = &rule->vars[v]; - } - } +void* ecs_term_w_size( + const ecs_iter_t *it, + size_t size, + int32_t term) +{ + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(!size || ecs_term_size(it, term) == size || + (!ecs_term_size(it, term) && (!it->ptrs || !it->ptrs[term - 1])), + ECS_INVALID_PARAMETER, NULL); - /* Insert terms with Not operators */ - for (c = 0; c < term_count; c ++) { - ecs_term_t *term = &terms[c]; - if (term->oper != EcsNot) { - continue; - } + (void)size; - insert_term(rule, term, c, written); + if (!term) { + return it->entities; } - /* Insert terms with Optional operators last, as optional terms cannot - * eliminate results, and would just add overhead to evaluation of - * non-matching entities. */ - for (c = 0; c < term_count; c ++) { - ecs_term_t *term = &terms[c]; - if (term->oper != EcsOptional) { - continue; - } - - insert_term(rule, term, c, written); + if (!it->ptrs) { + return NULL; } - /* Verify all subject variables have been written. Subject variables are of - * the table type, and a select/subset should have been inserted for each */ - for (v = 0; v < rule->subj_var_count; v ++) { - if (!written[v]) { - /* If the table variable hasn't been written, this can only happen - * if an instruction wrote the variable before a select/subset could - * have been inserted for it. Make sure that this is the case by - * testing if an entity variable exists and whether it has been - * written. */ - ecs_rule_var_t *var = find_variable( - rule, EcsRuleVarKindEntity, rule->vars[v].name); - ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(written[var->id], ECS_INTERNAL_ERROR, var->name); - (void)var; - } - } + return it->ptrs[term - 1]; +error: + return NULL; +} - /* Make sure that all entity variables are written. With the exception of - * the this variable, which can be returned as a table, other variables need - * to be available as entities. This ensures that all permutations for all - * variables are correctly returned by the iterator. When an entity variable - * hasn't been written yet at this point, it is because it only constrained - * through a common predicate or object. */ - for (; v < rule->var_count; v ++) { - if (!written[v]) { - ecs_rule_var_t *var = &rule->vars[v]; - ecs_assert(var->kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); +bool ecs_term_is_readonly( + const ecs_iter_t *it, + int32_t term_index) +{ + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(term_index > 0, ECS_INVALID_PARAMETER, NULL); - ecs_rule_var_t *table_var = find_variable( - rule, EcsRuleVarKindTable, var->name); - - /* A table variable must exist if the variable hasn't been resolved - * yet. If there doesn't exist one, this could indicate an - * unconstrained variable which should have been caught earlier */ - ecs_assert(table_var != NULL, ECS_INTERNAL_ERROR, var->name); + ecs_term_t *term = &it->terms[term_index - 1]; + ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); + + if (term->inout == EcsIn) { + return true; + } else { + ecs_term_id_t *subj = &term->subj; - /* Insert each operation that takes the table variable as input, and - * yields each entity in the table */ - op = insert_operation(rule, -1, written); - op->kind = EcsRuleEach; - op->r_in = table_var->id; - op->r_out = var->id; - op->frame = rule->frame_count; - op->has_in = true; - op->has_out = true; - written[var->id] = true; - - push_frame(rule); + if (term->inout == EcsInOutDefault) { + if (subj->entity != EcsThis) { + return true; + } + + if (!(subj->set.mask & EcsSelf)) { + return true; + } } - } + } - /* Insert yield, which is always the last operation */ - insert_yield(rule); +error: + return false; } -static -void create_variable_name_array( - ecs_rule_t *rule) +bool ecs_term_is_writeonly( + const ecs_iter_t *it, + int32_t term_index) { - if (rule->var_count) { - int i; - for (i = 0; i < rule->var_count; i ++) { - ecs_rule_var_t *var = &rule->vars[i]; + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(term_index > 0, ECS_INVALID_PARAMETER, NULL); - if (var->kind != EcsRuleVarKindEntity) { - /* Table variables are hidden for applications. */ - rule->var_names[var->id] = NULL; - } else { - rule->var_names[var->id] = var->name; - } - } + ecs_term_t *term = &it->terms[term_index - 1]; + ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); + + if (term->inout == EcsOut) { + return true; } + +error: + return false; } -static -void create_variable_cross_references( - ecs_rule_t *rule) +int32_t ecs_iter_find_column( + const ecs_iter_t *it, + ecs_entity_t component) { - if (rule->var_count) { - int i; - for (i = 0; i < rule->var_count; i ++) { - ecs_rule_var_t *var = &rule->vars[i]; - if (var->kind == EcsRuleVarKindEntity) { - ecs_rule_var_t *tvar = find_variable( - rule, EcsRuleVarKindTable, var->name); - if (tvar) { - var->other = tvar->id; - } else { - var->other = -1; - } - } else { - ecs_rule_var_t *evar = find_variable( - rule, EcsRuleVarKindEntity, var->name); - if (evar) { - var->other = evar->id; - } else { - var->other = -1; - } - } + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); + return ecs_search(it->real_world, it->table, component, 0); +error: + return -1; +} + +bool ecs_term_is_set( + const ecs_iter_t *it, + int32_t index) +{ + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + + int32_t column = it->columns[index - 1]; + if (!column) { + return false; + } else if (column < 0) { + if (it->references) { + column = -column - 1; + ecs_ref_t *ref = &it->references[column]; + return ref->entity != 0; + } else { + return true; } } + + return true; +error: + return false; } -/* Implementation for iterable mixin */ -static -void rule_iter_init( - const ecs_world_t *world, - const ecs_poly_t *poly, - ecs_iter_t *iter, - ecs_term_t *filter) +void* ecs_iter_column_w_size( + const ecs_iter_t *it, + size_t size, + int32_t index) { - ecs_poly_assert(poly, ecs_rule_t); - - if (filter) { - iter[1] = ecs_rule_iter(world, (ecs_rule_t*)poly); - iter[0] = ecs_term_chain_iter(&iter[1], filter); - } else { - iter[0] = ecs_rule_iter(world, (ecs_rule_t*)poly); + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); + (void)size; + + ecs_table_t *table = it->table; + int32_t storage_index = ecs_table_type_to_storage_index(table, index); + if (storage_index == -1) { + return NULL; } + + ecs_column_t *columns = table->storage.columns; + ecs_column_t *column = &columns[storage_index]; + ecs_check(!size || (ecs_size_t)size == column->size, + ECS_INVALID_PARAMETER, NULL); + + void *ptr = ecs_vector_first_t( + column->data, column->size, column->alignment); + + return ECS_OFFSET(ptr, column->size * it->offset); +error: + return NULL; } -static -int32_t find_term_var_id( - ecs_rule_t *rule, - ecs_term_id_t *term_id) +size_t ecs_iter_column_size( + const ecs_iter_t *it, + int32_t index) { - if (term_id_is_variable(term_id)) { - const char *var_name = term_id_var_name(term_id); - ecs_rule_var_t *var = find_variable( - rule, EcsRuleVarKindEntity, var_name); - if (var) { - return var->id; - } else { - /* If this is Any look for table variable. Since Any is only - * required to return a single result, there is no need to - * insert an each instruction for a matching table. */ - if (term_id->entity == EcsAny) { - var = find_variable( - rule, EcsRuleVarKindTable, var_name); - if (var) { - return var->id; - } - } - } + ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_table_t *table = it->table; + int32_t storage_index = ecs_table_type_to_storage_index(table, index); + if (storage_index == -1) { + return 0; } + + ecs_column_t *columns = table->storage.columns; + ecs_column_t *column = &columns[storage_index]; - return -1; + return flecs_ito(size_t, column->size); +error: + return 0; } -ecs_rule_t* ecs_rule_init( - ecs_world_t *world, - const ecs_filter_desc_t *desc) +char* ecs_iter_str( + const ecs_iter_t *it) { - ecs_rule_t *result = ecs_poly_new(ecs_rule_t); + ecs_world_t *world = it->world; + ecs_strbuf_t buf = ECS_STRBUF_INIT; + int i; - /* Parse the signature expression. This initializes the columns array which - * contains the information about which components/pairs are requested. */ - if (ecs_filter_init(world, &result->filter, desc)) { - goto error; + if (it->term_count) { + ecs_strbuf_list_push(&buf, "term: ", ","); + for (i = 0; i < it->term_count; i ++) { + ecs_id_t id = ecs_term_id(it, i + 1); + char *str = ecs_id_str(world, id); + ecs_strbuf_list_appendstr(&buf, str); + ecs_os_free(str); + } + ecs_strbuf_list_pop(&buf, "\n"); + + ecs_strbuf_list_push(&buf, "subj: ", ","); + for (i = 0; i < it->term_count; i ++) { + ecs_entity_t subj = ecs_term_source(it, i + 1); + char *str = ecs_get_fullpath(world, subj); + ecs_strbuf_list_appendstr(&buf, str); + ecs_os_free(str); + } + ecs_strbuf_list_pop(&buf, "\n"); } - result->world = world; + if (it->variable_count) { + int32_t actual_count = 0; + for (i = 0; i < it->variable_count; i ++) { + const char *var_name = it->variable_names[i]; + if (!var_name || var_name[0] == '_' || var_name[0] == '.') { + /* Skip anonymous variables */ + continue; + } - /* Rule has no terms */ - if (!result->filter.term_count) { - rule_error(result, "rule has no terms"); - goto error; - } + ecs_entity_t var = it->variables[i]; + if (!var) { + /* Skip table variables */ + continue; + } - ecs_term_t *terms = result->filter.terms; - int32_t i, term_count = result->filter.term_count; + if (!actual_count) { + ecs_strbuf_list_push(&buf, "vars: ", ","); + } - /* Make sure rule doesn't just have Not terms */ - for (i = 0; i < term_count; i++) { - ecs_term_t *term = &terms[i]; - if (term->oper != EcsNot) { - break; - } - } - if (i == term_count) { - rule_error(result, "rule cannot only have terms with Not operator"); - goto error; - } + char *str = ecs_get_fullpath(world, var); + ecs_strbuf_list_append(&buf, "%s=%s", var_name, str); + ecs_os_free(str); - /* Find all variables & resolve dependencies */ - if (scan_variables(result) != 0) { - goto error; + actual_count ++; + } + if (actual_count) { + ecs_strbuf_list_pop(&buf, "\n"); + } } - /* Create lookup array for subject variables */ - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; - ecs_rule_term_vars_t *vars = &result->term_vars[i]; - vars->pred = find_term_var_id(result, &term->pred); - vars->subj = find_term_var_id(result, &term->subj); - vars->obj = find_term_var_id(result, &term->obj); + if (it->count) { + ecs_strbuf_appendstr(&buf, "this:\n"); + for (i = 0; i < it->count; i ++) { + ecs_entity_t e = it->entities[i]; + char *str = ecs_get_fullpath(world, e); + ecs_strbuf_appendstr(&buf, " - "); + ecs_strbuf_appendstr(&buf, str); + ecs_strbuf_appendstr(&buf, "\n"); + ecs_os_free(str); + } } - /* Generate the opcode array */ - compile_program(result); - - /* Create array with variable names so this can be easily accessed by - * iterators without requiring access to the ecs_rule_t */ - create_variable_name_array(result); - - /* Create cross-references between variables so it's easy to go from entity - * to table variable and vice versa */ - create_variable_cross_references(result); + return ecs_strbuf_get(&buf); +} - result->iterable.init = rule_iter_init; +void ecs_iter_poly( + const ecs_world_t *world, + const ecs_poly_t *poly, + ecs_iter_t *iter_out, + ecs_term_t *filter) +{ + ecs_iterable_t *iterable = ecs_get_iterable(poly); + iterable->init(world, poly, iter_out, filter); +} - return result; +bool ecs_iter_next( + ecs_iter_t *iter) +{ + ecs_check(iter != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(iter->next != NULL, ECS_INVALID_PARAMETER, NULL); + return iter->next(iter); error: - ecs_rule_fini(result); - return NULL; + return false; } -void ecs_rule_fini( - ecs_rule_t *rule) +bool ecs_iter_count( + ecs_iter_t *it) { - int32_t i; - for (i = 0; i < rule->var_count; i ++) { - ecs_os_free(rule->vars[i].name); + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + int32_t count = 0; + while (ecs_iter_next(it)) { + count += it->count; } - - ecs_filter_fini(&rule->filter); - - ecs_os_free(rule->operations); - ecs_os_free(rule); + return count; +error: + return 0; } -const ecs_filter_t* ecs_rule_get_filter( - const ecs_rule_t *rule) +bool ecs_iter_is_true( + ecs_iter_t *it) { - return &rule->filter; + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + bool result = ecs_iter_next(it); + if (result) { + ecs_iter_fini(it); + } + return result; +error: + return false; } -/* Quick convenience function to get a variable from an id */ -static -ecs_rule_var_t* get_variable( - const ecs_rule_t *rule, +ecs_entity_t ecs_iter_get_var( + ecs_iter_t *it, int32_t var_id) { - if (var_id == UINT8_MAX) { - return NULL; - } - - return (ecs_rule_var_t*)&rule->vars[var_id]; + ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL); + return it->variables[var_id]; +error: + return 0; } -/* Convert the program to a string. This can be useful to analyze how a rule is - * being evaluated. */ -char* ecs_rule_str( - ecs_rule_t *rule) +ecs_iter_t ecs_page_iter( + const ecs_iter_t *it, + int32_t offset, + int32_t limit) { - ecs_check(rule != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_world_t *world = rule->world; - ecs_strbuf_t buf = ECS_STRBUF_INIT; - char filter_expr[256]; + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL); - int32_t i, count = rule->operation_count; - for (i = 1; i < count; i ++) { - ecs_rule_op_t *op = &rule->operations[i]; - ecs_rule_pair_t pair = op->filter; - ecs_entity_t pred = pair.pred.ent; - ecs_entity_t obj = pair.obj.ent; - const char *pred_name = NULL, *obj_name = NULL; - char *pred_name_alloc = NULL, *obj_name_alloc = NULL; + ecs_iter_t result = *it; + result.priv.iter.page = (ecs_page_iter_t){ + .offset = offset, + .limit = limit, + .remaining = limit + }; + result.next = ecs_page_next; + result.chain_it = (ecs_iter_t*)it; - if (pair.reg_mask & RULE_PAIR_PREDICATE) { - ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_rule_var_t *type_var = &rule->vars[pair.pred.reg]; - pred_name = type_var->name; - } else if (pred) { - pred_name_alloc = ecs_get_fullpath(world, ecs_get_alive(world, pred)); - pred_name = pred_name_alloc; + return result; +error: + return (ecs_iter_t){ 0 }; +} + +static +void offset_iter( + ecs_iter_t *it, + int32_t offset) +{ + it->entities = &it->entities[offset]; + + int32_t t, term_count = it->term_count; + for (t = 0; t < term_count; t ++) { + void *ptrs = it->ptrs[t]; + if (!ptrs) { + continue; } - if (pair.reg_mask & RULE_PAIR_OBJECT) { - ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_rule_var_t *obj_var = &rule->vars[pair.obj.reg]; - obj_name = obj_var->name; - } else if (obj) { - obj_name_alloc = ecs_get_fullpath(world, ecs_get_alive(world, obj)); - obj_name = obj_name_alloc; - } else if (pair.obj_0) { - obj_name = "0"; + if (it->subjects[t]) { + continue; } - ecs_strbuf_append(&buf, "%2d: [S:%2d, P:%2d, F:%2d, T:%2d] ", i, - op->frame, op->on_pass, op->on_fail, op->term); + it->ptrs[t] = ECS_OFFSET(ptrs, offset * it->sizes[t]); + } +} - bool has_filter = false; +static +bool ecs_page_next_instanced( + ecs_iter_t *it) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL); - switch(op->kind) { - case EcsRuleSelect: - ecs_strbuf_append(&buf, "select "); - has_filter = true; - break; - case EcsRuleWith: - ecs_strbuf_append(&buf, "with "); - has_filter = true; - break; - case EcsRuleStore: - ecs_strbuf_append(&buf, "store "); - break; - case EcsRuleSuperSet: - ecs_strbuf_append(&buf, "superset "); - has_filter = true; - break; - case EcsRuleSubSet: - ecs_strbuf_append(&buf, "subset "); - has_filter = true; - break; - case EcsRuleEach: - ecs_strbuf_append(&buf, "each "); - break; - case EcsRuleSetJmp: - ecs_strbuf_append(&buf, "setjmp "); - break; - case EcsRuleJump: - ecs_strbuf_append(&buf, "jump "); - break; - case EcsRuleNot: - ecs_strbuf_append(&buf, "not "); - break; - case EcsRuleInTable: - ecs_strbuf_append(&buf, "intable "); - has_filter = true; - break; - case EcsRuleEq: - ecs_strbuf_append(&buf, "eq "); - has_filter = true; - break; - case EcsRuleYield: - ecs_strbuf_append(&buf, "yield "); - break; - default: - continue; + ecs_iter_t *chain_it = it->chain_it; + bool instanced = it->is_instanced; + + do { + if (!ecs_iter_next(chain_it)) { + goto done; } - if (op->has_out) { - ecs_rule_var_t *r_out = get_variable(rule, op->r_out); - if (r_out) { - ecs_strbuf_append(&buf, "O:%s%s ", - r_out->kind == EcsRuleVarKindTable ? "t" : "", - r_out->name); - } else if (op->subject) { - char *subj_path = ecs_get_fullpath(world, op->subject); - ecs_strbuf_append(&buf, "O:%s ", subj_path); - ecs_os_free(subj_path); - } + ecs_page_iter_t *iter = &it->priv.iter.page; + + /* Copy everything up to the private iterator data */ + ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv)); + it->is_instanced = instanced; + + if (!chain_it->table) { + goto yield; /* Task query */ } - if (op->has_in) { - ecs_rule_var_t *r_in = get_variable(rule, op->r_in); - if (r_in) { - ecs_strbuf_append(&buf, "I:%s%s ", - r_in->kind == EcsRuleVarKindTable ? "t" : "", - r_in->name); + int32_t offset = iter->offset; + int32_t limit = iter->limit; + if (!(offset || limit)) { + if (it->count) { + goto yield; + } else { + goto done; } - if (op->subject) { - char *subj_path = ecs_get_fullpath(world, op->subject); - ecs_strbuf_append(&buf, "I:%s ", subj_path); - ecs_os_free(subj_path); + } + + int32_t count = it->count; + int32_t remaining = iter->remaining; + + if (offset) { + if (offset > count) { + /* No entities to iterate in current table */ + iter->offset -= count; + it->count = 0; + continue; + } else { + it->offset += offset; + count = it->count -= offset; + iter->offset = 0; + offset_iter(it, offset); } } - if (has_filter) { - if (!pred_name) { - pred_name = "-"; - } - if (!obj_name && !pair.obj_0) { - ecs_os_sprintf(filter_expr, "(%s)", pred_name); + if (remaining) { + if (remaining > count) { + iter->remaining -= count; } else { - ecs_os_sprintf(filter_expr, "(%s, %s)", pred_name, obj_name); + it->count = remaining; + iter->remaining = 0; } - ecs_strbuf_append(&buf, "F:%s", filter_expr); + } else if (limit) { + /* Limit hit: no more entities left to iterate */ + goto done; } + } while (it->count == 0); - ecs_strbuf_appendstr(&buf, "\n"); - - ecs_os_free(pred_name_alloc); - ecs_os_free(obj_name_alloc); +yield: + if (!it->is_instanced) { + it->offset = 0; } - return ecs_strbuf_get(&buf); + return true; +done: error: - return NULL; + return false; } -/* Public function that returns number of variables. This enables an application - * to iterate the variables and obtain their values. */ -int32_t ecs_rule_var_count( - const ecs_rule_t *rule) +bool ecs_page_next( + ecs_iter_t *it) { - ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); - return rule->var_count; -} + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); -/* Public function to find a variable by name */ -int32_t ecs_rule_find_var( - const ecs_rule_t *rule, - const char *name) -{ - ecs_rule_var_t *v = find_variable(rule, EcsRuleVarKindEntity, name); - if (v) { - return v->id; - } else { - return -1; + it->chain_it->is_instanced = true; + + if (flecs_iter_next_row(it)) { + return true; } -} -/* Public function to get the name of a variable. */ -const char* ecs_rule_var_name( - const ecs_rule_t *rule, - int32_t var_id) -{ - return rule->vars[var_id].name; + return flecs_iter_next_instanced(it, ecs_page_next_instanced(it)); +error: + return false; } -/* Public function to get the type of a variable. */ -bool ecs_rule_var_is_entity( - const ecs_rule_t *rule, - int32_t var_id) +ecs_iter_t ecs_worker_iter( + const ecs_iter_t *it, + int32_t index, + int32_t count) { - return rule->vars[var_id].kind == EcsRuleVarKindEntity; + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(count > 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(index >= 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(index < count, ECS_INVALID_PARAMETER, NULL); + + return (ecs_iter_t){ + .real_world = it->real_world, + .world = it->world, + .priv.iter.worker = { + .index = index, + .count = count + }, + .next = ecs_worker_next, + .chain_it = (ecs_iter_t*)it, + .is_instanced = it->is_instanced + }; + +error: + return (ecs_iter_t){ 0 }; } -/* Public function to set the value of a variable before iterating. */ -void ecs_rule_set_var( - ecs_iter_t *it, - int32_t var_id, - ecs_entity_t value) +static +bool ecs_worker_next_instanced( + ecs_iter_t *it) { ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(var_id != -1, ECS_INVALID_PARAMETER, NULL); - ecs_check(value != 0, ECS_INVALID_PARAMETER, NULL); - /* Can't set variable while iterating */ - ecs_check(it->is_valid == false, ECS_INVALID_OPERATION, NULL); - ecs_check(it->next == ecs_rule_next, ECS_INVALID_OPERATION, NULL); + ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL); - ecs_rule_iter_t *iter = &it->priv.iter.rule; - ecs_check(iter->registers != NULL, ECS_INVALID_PARAMETER, NULL); + bool instanced = it->is_instanced; - const ecs_rule_t *r = iter->rule; - ecs_check(var_id < r->var_count, ECS_INVALID_PARAMETER, NULL); + ecs_iter_t *chain_it = it->chain_it; + ecs_worker_iter_t *iter = &it->priv.iter.worker; + int32_t res_count = iter->count, res_index = iter->index; + int32_t per_worker, instances_per_worker, first; - entity_reg_set(r, iter->registers, var_id, value); + do { + if (!ecs_iter_next(chain_it)) { + return false; + } - /* Also set table variable if it exists */ - const ecs_rule_var_t *var = &r->vars[var_id]; - if (var->other != -1) { - const ecs_rule_var_t *tvar = &r->vars[var->other]; - ecs_assert(tvar->kind == EcsRuleVarKindTable, - ECS_INTERNAL_ERROR, NULL); - (void)tvar; - reg_set_entity(r, iter->registers, var->other, value); + /* Copy everything up to the private iterator data */ + ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv)); + it->is_instanced = instanced; + + int32_t count = it->count; + int32_t instance_count = it->instance_count; + per_worker = count / res_count; + instances_per_worker = instance_count / res_count; + first = per_worker * res_index; + count -= per_worker * res_count; + + if (count) { + if (res_index < count) { + per_worker ++; + first += res_index; + } else { + first += count; + } + } + + if (!per_worker && it->table == NULL) { + if (res_index == 0) { + return true; + } else { + return false; + } + } + } while (!per_worker); + + it->instance_count = instances_per_worker; + it->frame_offset += first; + + offset_iter(it, it->offset + first); + it->count = per_worker; + + if (it->is_instanced) { + it->offset += first; + } else { + it->offset = 0; } + + return true; error: - return; + return false; } -static -void ecs_rule_iter_free( - ecs_iter_t *iter) +bool ecs_worker_next( + ecs_iter_t *it) { - ecs_rule_iter_t *it = &iter->priv.iter.rule; - ecs_os_free(it->registers); - ecs_os_free(it->columns); - ecs_os_free(it->op_ctx); - ecs_os_free(it->variables); - iter->columns = NULL; - it->registers = NULL; - it->columns = NULL; - it->op_ctx = NULL; + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); + + it->chain_it->is_instanced = true; + + if (flecs_iter_next_row(it)) { + return true; + } + + return flecs_iter_next_instanced(it, ecs_worker_next_instanced(it)); +error: + return false; } -/* Create rule iterator */ -ecs_iter_t ecs_rule_iter( - const ecs_world_t *world, - const ecs_rule_t *rule) -{ - ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(rule != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_iter_t result = {0}; - int i; +/* -- Component lifecycle -- */ - result.world = (ecs_world_t*)world; - result.real_world = (ecs_world_t*)ecs_get_world(rule->world); +/* Component lifecycle actions for EcsIdentifier */ +static ECS_CTOR(EcsIdentifier, ptr, { + ptr->value = NULL; + ptr->hash = 0; + ptr->length = 0; + ptr->index_hash = 0; + ptr->index = NULL; +}) - flecs_process_pending_tables(result.real_world); +static ECS_DTOR(EcsIdentifier, ptr, { + ecs_os_strset(&ptr->value, NULL); +}) - ecs_rule_iter_t *it = &result.priv.iter.rule; - it->rule = rule; +static ECS_COPY(EcsIdentifier, dst, src, { + ecs_os_strset(&dst->value, src->value); + dst->hash = src->hash; + dst->length = src->length; + dst->index_hash = src->index_hash; + dst->index = src->index; +}) - if (rule->operation_count) { - if (rule->var_count) { - it->registers = ecs_os_malloc_n(ecs_rule_reg_t, - rule->operation_count * rule->var_count); +static ECS_MOVE(EcsIdentifier, dst, src, { + ecs_os_strset(&dst->value, NULL); + dst->value = src->value; + dst->hash = src->hash; + dst->length = src->length; + dst->index_hash = src->index_hash; + dst->index = src->index; - it->variables = ecs_os_malloc_n(ecs_entity_t, rule->var_count); - } - - it->op_ctx = ecs_os_calloc_n(ecs_rule_op_ctx_t, rule->operation_count); + src->value = NULL; + src->hash = 0; + src->index_hash = 0; + src->index = 0; + src->length = 0; +}) - if (rule->filter.term_count) { - it->columns = ecs_os_malloc_n(int32_t, - rule->operation_count * rule->filter.term_count); - } +static +void ecs_on_set(EcsIdentifier)(ecs_iter_t *it) { + EcsIdentifier *ptr = ecs_term(it, EcsIdentifier, 1); + + ecs_world_t *world = it->real_world; + ecs_entity_t evt = it->event; + ecs_id_t evt_id = it->event_id; + ecs_entity_t kind = ECS_PAIR_SECOND(evt_id); /* Name, Symbol, Alias */ - for (i = 0; i < rule->filter.term_count; i ++) { - it->columns[i] = -1; + ecs_id_t pair = ecs_childof(0); + + ecs_hashmap_t *name_index = NULL; + if (kind == EcsSymbol) { + name_index = &world->symbols; + } else if (kind == EcsAlias) { + name_index = &world->aliases; + } else if (kind == EcsName) { + ecs_assert(it->table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_search(world, it->table, ecs_childof(EcsWildcard), &pair); + ecs_assert(pair != 0, ECS_INTERNAL_ERROR, NULL); + + if (evt == EcsOnSet) { + name_index = flecs_ensure_id_name_index(world, pair); + } else { + name_index = flecs_get_id_name_index(world, pair); } } - it->op = 0; + for (int i = 0; i < it->count; i ++) { + EcsIdentifier *cur = &ptr[i]; + uint64_t hash; + ecs_size_t len; + const char *name = cur->value; - for (i = 0; i < rule->var_count; i ++) { - if (rule->vars[i].kind == EcsRuleVarKindEntity) { - entity_reg_set(rule, it->registers, i, EcsWildcard); + if (cur->index && cur->index != name_index) { + /* If index doesn't match up, the value must have been copied from + * another entity, so reset index & cached index hash */ + cur->index = NULL; + cur->index_hash = 0; + } + + if (cur->value && (evt == EcsOnSet)) { + len = cur->length = ecs_os_strlen(name); + hash = cur->hash = flecs_hash(name, len); } else { - table_reg_set(rule, it->registers, i, NULL); + len = cur->length = 0; + hash = cur->hash = 0; + cur->index = NULL; } - } - result.variable_names = (char**)rule->var_names; - result.variable_count = rule->var_count; - result.term_count = rule->filter.term_count; - result.terms = rule->filter.terms; - result.next = ecs_rule_next; - result.fini = ecs_rule_iter_free; - result.is_filter = rule->filter.filter; - result.columns = it->columns; /* prevent alloc */ + if (name_index) { + uint64_t index_hash = cur->index_hash; + ecs_entity_t e = it->entities[i]; - return result; + if (hash != index_hash) { + if (index_hash) { + flecs_name_index_remove(name_index, e, index_hash); + } + if (hash) { + flecs_name_index_ensure(name_index, e, name, len, hash); + cur->index_hash = hash; + cur->index = name_index; + } + } else { + /* Name didn't change, but the string could have been + * reallocated. Make sure name index points to correct string */ + flecs_name_index_update_name(name_index, e, hash, name); + } + } + } } -/* Edge case: if the filter has the same variable for both predicate and - * object, they are both resolved at the same time but at the time of - * evaluating the filter they're still wildcards which would match columns - * that have different predicates/objects. Do an additional scan to make - * sure the column we're returning actually matches. */ +/* Component lifecycle actions for EcsTrigger */ +static ECS_CTOR(EcsTrigger, ptr, { + ptr->trigger = NULL; +}) + +static ECS_DTOR(EcsTrigger, ptr, { + if (ptr->trigger) { + flecs_trigger_fini(world, (ecs_trigger_t*)ptr->trigger); + } +}) + +static ECS_COPY(EcsTrigger, dst, src, { + ecs_abort(ECS_INVALID_OPERATION, "Trigger component cannot be copied"); +}) + +static ECS_MOVE(EcsTrigger, dst, src, { + if (dst->trigger) { + flecs_trigger_fini(world, (ecs_trigger_t*)dst->trigger); + } + dst->trigger = src->trigger; + src->trigger = NULL; +}) + +/* Component lifecycle actions for EcsObserver */ +static ECS_CTOR(EcsObserver, ptr, { + ptr->observer = NULL; +}) + +static ECS_DTOR(EcsObserver, ptr, { + if (ptr->observer) { + flecs_observer_fini(world, (ecs_observer_t*)ptr->observer); + } +}) + +static ECS_COPY(EcsObserver, dst, src, { + ecs_abort(ECS_INVALID_OPERATION, "Observer component cannot be copied"); +}) + +static ECS_MOVE(EcsObserver, dst, src, { + if (dst->observer) { + flecs_observer_fini(world, (ecs_observer_t*)dst->observer); + } + dst->observer = src->observer; + src->observer = NULL; +}) + + +/* -- Builtin triggers -- */ + static -int32_t find_next_same_var( - ecs_type_t type, - int32_t column, - ecs_id_t pattern) +void assert_relation_unused( + ecs_world_t *world, + ecs_entity_t rel, + ecs_entity_t property) { - /* If same_var is true, this has to be a wildcard pair. We cannot have - * the same variable in a pair, and one part of a pair resolved with - * another part unresolved. */ - ecs_assert(pattern == ecs_pair(EcsWildcard, EcsWildcard), - ECS_INTERNAL_ERROR, NULL); - (void)pattern; - - /* Keep scanning for an id where rel and obj are the same */ - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t i, count = ecs_vector_count(type); - for (i = column + 1; i < count; i ++) { - ecs_id_t id = ids[i]; - if (!ECS_HAS_ROLE(id, PAIR)) { - /* If id is not a pair, this will definitely not match, and we - * will find no further matches. */ - return -1; - } + if (flecs_get_id_record(world, ecs_pair(rel, EcsWildcard)) != NULL) { + char *r_str = ecs_get_fullpath(world, rel); + char *p_str = ecs_get_fullpath(world, property); - if (ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id)) { - /* Found a match! */ - return i; - } + ecs_throw(ECS_ID_IN_USE, + "cannot add property '%s' to relation '%s': already in use", + p_str, r_str); + + ecs_os_free(r_str); + ecs_os_free(p_str); } - /* No pairs found with same rel/obj */ - return -1; +error: + return; } static -int32_t find_next_column( - const ecs_world_t *world, - const ecs_table_t *table, - int32_t column, - ecs_rule_filter_t *filter) -{ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); +void register_final(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + if (flecs_get_id_record(world, ecs_pair(EcsIsA, e)) != NULL) { + char *e_str = ecs_get_fullpath(world, e); + ecs_throw(ECS_ID_IN_USE, + "cannot add property 'Final' to '%s': already inherited from", + e_str); + ecs_os_free(e_str); + error: + continue; + } + } +} - ecs_entity_t pattern = filter->mask; - ecs_type_t type = table->type; +static +void register_on_delete(ecs_iter_t *it) { + ecs_world_t *world = it->world; + ecs_id_t id = ecs_term_id(it, 1); + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + assert_relation_unused(world, e, EcsOnDelete); - if (column == -1) { - ecs_table_record_t *tr = flecs_get_table_record(world, table, pattern); - if (!tr) { - return -1; - } - column = tr->column; - } else { - column = ecs_search_offset(world, table, column + 1, filter->mask, 0); - if (column == -1) { - return -1; - } + ecs_id_record_t *r = flecs_ensure_id_record(world, e); + ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); + r->flags |= ECS_ID_ON_DELETE_FLAG(ECS_PAIR_SECOND(id)); + + flecs_add_flag(world, e, ECS_FLAG_OBSERVED_ID); } +} + +static +void register_on_delete_object(ecs_iter_t *it) { + ecs_world_t *world = it->world; + ecs_id_t id = ecs_term_id(it, 1); + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + assert_relation_unused(world, e, EcsOnDeleteObject); + + ecs_id_record_t *r = flecs_ensure_id_record(world, e); + ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); + r->flags |= ECS_ID_ON_DELETE_OBJECT_FLAG(ECS_PAIR_SECOND(id)); - if (filter->same_var) { - column = find_next_same_var(type, column - 1, filter->mask); - } + flecs_add_flag(world, e, ECS_FLAG_OBSERVED_ID); + } +} - return column; +static +void register_exclusive(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + assert_relation_unused(world, e, EcsExclusive); + + ecs_id_record_t *r = flecs_ensure_id_record(world, e); + r->flags |= ECS_ID_EXCLUSIVE; + } } -/* This function finds the next table in a table set, and is used by the select - * operation. The function automatically skips empty tables, so that subsequent - * operations don't waste a lot of processing for nothing. */ static -ecs_table_record_t find_next_table( - ecs_rule_filter_t *filter, - ecs_rule_with_ctx_t *op_ctx) -{ - ecs_table_cache_iter_t *it = &op_ctx->it; - ecs_table_t *table = NULL; - int32_t column = -1; +void register_dont_inherit(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + assert_relation_unused(world, e, EcsDontInherit); - const ecs_table_record_t *tr; - while ((column == -1) && (tr = flecs_table_cache_next(it, ecs_table_record_t))) { - table = tr->hdr.table; + ecs_id_record_t *r = flecs_ensure_id_record(world, e); + r->flags |= ECS_ID_DONT_INHERIT; + } +} - /* Should only iterate non-empty tables */ - ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL); +static +void on_symmetric_add_remove(ecs_iter_t *it) { + ecs_entity_t pair = ecs_term_id(it, 1); - column = tr->column; - if (filter->same_var) { - column = find_next_same_var(table->type, column - 1, filter->mask); - } + if (!ECS_HAS_ROLE(pair, PAIR)) { + /* If relationship was not added as a pair, there's nothing to do */ + return; } - if (column == -1) { - table = NULL; + ecs_entity_t rel = ECS_PAIR_FIRST(pair); + ecs_entity_t obj = ECS_PAIR_SECOND(pair); + ecs_entity_t event = it->event; + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t subj = it->entities[i]; + if (event == EcsOnAdd) { + if (!ecs_has_id(it->real_world, obj, ecs_pair(rel, subj))) { + ecs_add_pair(it->world, obj, rel, subj); + } + } else { + if (ecs_has_id(it->real_world, obj, ecs_pair(rel, subj))) { + ecs_remove_pair(it->world, obj, rel, subj); + } + } } - - return (ecs_table_record_t){.hdr.table = table, .column = column}; } - static -ecs_id_record_t* find_tables( - ecs_world_t *world, - ecs_id_t id) -{ - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr || !ecs_table_cache_count(&idr->cache)) { - /* Skip ids that don't have (non-empty) tables */ - return NULL; - } - return idr; -} +void register_symmetric(ecs_iter_t *it) { + ecs_world_t *world = it->real_world; -static -ecs_id_t rule_get_column( - ecs_type_t type, - int32_t column) -{ - ecs_id_t *comp = ecs_vector_get(type, ecs_id_t, column); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); - return *comp; + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t r = it->entities[i]; + assert_relation_unused(world, r, EcsSymmetric); + + /* Create trigger that adds the reverse relationship when R(X, Y) is + * added, or remove the reverse relationship when R(X, Y) is removed. */ + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_pair(r, EcsWildcard), + .callback = on_symmetric_add_remove, + .events = {EcsOnAdd, EcsOnRemove} + }); + } } static -void set_source( - ecs_iter_t *it, - ecs_rule_op_t *op, - ecs_rule_reg_t *regs, - int32_t r) -{ - if (op->term == -1) { - /* If operation is not associated with a term, don't set anything */ - return; - } - - ecs_assert(op->term >= 0, ECS_INTERNAL_ERROR, NULL); +void on_set_component(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsComponent *c = ecs_term(it, EcsComponent, 1); - const ecs_rule_t *rule = it->priv.iter.rule.rule; - if ((r != UINT8_MAX) && rule->vars[r].kind == EcsRuleVarKindEntity) { - it->subjects[op->term] = reg_get_entity(rule, op, regs, r); - } else { - it->subjects[op->term] = 0; + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_type_info_t *ti = flecs_ensure_type_info(world, e); + ti->size = c[i].size; + ti->alignment = c[i].alignment; } } static -void set_term_vars( - const ecs_rule_t *rule, - ecs_rule_reg_t *regs, - int32_t term, - ecs_id_t id) -{ - if (term != -1) { - const ecs_rule_term_vars_t *vars = &rule->term_vars[term]; - if (vars->pred != -1) { - regs[vars->pred].entity = ECS_PAIR_FIRST(id); - } - if (vars->obj != -1) { - regs[vars->obj].entity = ECS_PAIR_SECOND(id); - } +void on_set_component_lifecycle(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsComponentLifecycle *cl = ecs_term(it, EcsComponentLifecycle, 1); + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_set_component_actions_w_id(world, e, &cl[i]); } } -/* Input operation. The input operation acts as a placeholder for the start of - * the program, and creates an entry in the register array that can serve to - * store variables passed to an iterator. */ static -bool eval_input( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - (void)it; - (void)op; - (void)op_index; +void ensure_module_tag(ecs_iter_t *it) { + ecs_world_t *world = it->world; - if (!redo) { - /* First operation executed by the iterator. Always return true. */ - return true; - } else { - /* When Input is asked to redo, it means that all other operations have - * exhausted their results. Input itself does not yield anything, so - * return false. This will terminate rule execution. */ - return false; + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); + if (parent) { + ecs_add_id(world, parent, EcsModule); + } } } +/* -- Triggers for keeping hashed ids in sync -- */ + static -bool eval_superset( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_world_t *world = rule->world; - ecs_rule_superset_ctx_t *op_ctx = &iter->op_ctx[op_index].is.superset; - ecs_rule_superset_frame_t *frame = NULL; - ecs_rule_reg_t *regs = get_registers(iter, op); +void on_parent_change(ecs_iter_t *it) { + ecs_world_t *world = it->world; + ecs_table_t *other_table = it->other_table, *table = it->table; - /* Get register indices for output */ - int32_t sp; - int32_t r = op->r_out; + int32_t col = ecs_search(it->real_world, table, + ecs_pair(ecs_id(EcsIdentifier), EcsName), 0); + bool has_name = col != -1; + bool other_has_name = ecs_search(it->real_world, other_table, + ecs_pair(ecs_id(EcsIdentifier), EcsName), 0) != -1; - /* Register cannot be a literal, since we need to store things in it */ - ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); + if (!has_name && !other_has_name) { + /* If tables don't have names, index does not need to be updated */ + return; + } - /* Get queried for id, fill out potential variables */ - ecs_rule_pair_t pair = op->filter; + ecs_id_t to_pair = it->event_id; + ecs_id_t from_pair = ecs_childof(0); - ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); - ecs_entity_t rel = ECS_PAIR_FIRST(filter.mask); - ecs_rule_filter_t super_filter = { - .mask = ecs_pair(rel, EcsWildcard) - }; - ecs_table_t *table = NULL; + /* Find the other ChildOf relationship */ + ecs_search(it->real_world, other_table, + ecs_pair(EcsChildOf, EcsWildcard), &from_pair); - /* If the input register is not NULL, this is a variable that's been set by - * the application. */ - ecs_entity_t result = iter->registers[r].entity; - bool output_is_input = result && result != EcsWildcard; + bool to_has_name = has_name, from_has_name = other_has_name; + if (it->event == EcsOnRemove) { + if (from_pair != ecs_childof(0)) { + /* Because ChildOf is an exclusive relationship, events always come + * in OnAdd/OnRemove pairs (add for the new, remove for the old + * parent). We only need one of those events, so filter out the + * OnRemove events except for the case where a parent is removed and + * not replaced with another parent. */ + return; + } - if (output_is_input && !redo) { - ecs_assert(regs[r].entity == iter->registers[r].entity, - ECS_INTERNAL_ERROR, NULL); + ecs_id_t temp = from_pair; + from_pair = to_pair; + to_pair = temp; + + to_has_name = other_has_name; + from_has_name = has_name; } - if (!redo) { - op_ctx->stack = op_ctx->storage; - sp = op_ctx->sp = 0; - frame = &op_ctx->stack[sp]; + /* Get the table column with names */ + const EcsIdentifier *names = ecs_iter_column(it, EcsIdentifier, col); - /* Get table of object for which to get supersets */ - ecs_entity_t obj = ECS_PAIR_SECOND(filter.mask); - if (obj == EcsWildcard) { - ecs_assert(pair.reg_mask & RULE_PAIR_OBJECT, - ECS_INTERNAL_ERROR, NULL); - table = regs[pair.obj.reg].table.table; - } else { - table = table_from_entity(world, obj).table; - } + ecs_hashmap_t *from_index = 0; + if (from_has_name) { + from_index = flecs_get_id_name_index(world, from_pair); + } + ecs_hashmap_t *to_index = NULL; + if (to_has_name) { + to_index = flecs_ensure_id_name_index(world, to_pair); + } - int32_t column; + int32_t i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + const EcsIdentifier *name = &names[i]; - /* If output variable is already set, check if it matches */ - if (output_is_input) { - ecs_id_t id = ecs_pair(rel, result); - ecs_entity_t subj = 0; - column = ecs_search_relation(world, table, 0, id, rel, - 0, 0, &subj, 0, NULL); - if (column != -1) { - if (subj != 0) { - table = ecs_get_table(world, subj); - } - } - } else { - column = find_next_column(world, table, -1, &super_filter); + uint64_t index_hash = name->index_hash; + if (from_index && index_hash) { + flecs_name_index_remove(from_index, e, index_hash); } - - /* If no matching column was found, there are no supersets */ - if (column == -1) { - return false; + const char *name_str = name->value; + if (to_index && name_str) { + ecs_assert(name->hash != 0, ECS_INTERNAL_ERROR, NULL); + flecs_name_index_ensure( + to_index, e, name_str, name->length, name->hash); } + } +} - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t col_entity = rule_get_column(table->type, column); - ecs_entity_t col_obj = ecs_entity_t_lo(col_entity); +/* -- Iterable mixins -- */ - reg_set_entity(rule, regs, r, col_obj); +static +void on_event_iterable_init( + const ecs_world_t *world, + const ecs_poly_t *poly, /* Observable */ + ecs_iter_t *it, + ecs_term_t *filter) +{ + ecs_iter_poly(world, poly, it, filter); + it->event_id = filter->id; +} - frame->table = table; - frame->column = column; +/* -- Bootstrapping -- */ - return true; - } else if (output_is_input) { - return false; - } +#define bootstrap_component(world, table, name)\ + _bootstrap_component(world, table, ecs_id(name), #name, sizeof(name),\ + ECS_ALIGNOF(name)) - sp = op_ctx->sp; - frame = &op_ctx->stack[sp]; - table = frame->table; - int32_t column = frame->column; +static +void _bootstrap_component( + ecs_world_t *world, + ecs_table_t *table, + ecs_entity_t entity, + const char *symbol, + ecs_size_t size, + ecs_size_t alignment) +{ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t col_entity = rule_get_column(table->type, column); - ecs_entity_t col_obj = ecs_entity_t_lo(col_entity); - ecs_table_t *next_table = table_from_entity(world, col_obj).table; + ecs_column_t *columns = table->storage.columns; + ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL); - if (next_table) { - sp ++; - frame = &op_ctx->stack[sp]; - frame->table = next_table; - frame->column = -1; - } + ecs_record_t *record = ecs_eis_ensure(world, entity); + record->table = table; - do { - frame = &op_ctx->stack[sp]; - table = frame->table; - column = frame->column; + int32_t index = flecs_table_append(world, table, &table->storage, + entity, record, false); + record->row = ECS_ROW_TO_RECORD(index, 0); - column = find_next_column(world, table, column, &super_filter); - if (column != -1) { - op_ctx->sp = sp; - frame->column = column; - col_entity = rule_get_column(table->type, column); - col_obj = ecs_entity_t_lo(col_entity); - reg_set_entity(rule, regs, r, col_obj); - return true; - } + EcsComponent *component = ecs_vector_first(columns[0].data, EcsComponent); + component[index].size = size; + component[index].alignment = alignment; - sp --; - } while (sp >= 0); + const char *name = &symbol[3]; /* Strip 'Ecs' */ + ecs_size_t symbol_length = ecs_os_strlen(symbol); + ecs_size_t name_length = symbol_length - 3; - return false; + EcsIdentifier *name_col = ecs_vector_first(columns[1].data, EcsIdentifier); + name_col[index].value = ecs_os_strdup(name); + name_col[index].length = name_length; + name_col[index].hash = flecs_hash(name, name_length); + name_col[index].index_hash = 0; + name_col[index].index = NULL; + + EcsIdentifier *symbol_col = ecs_vector_first(columns[2].data, EcsIdentifier); + symbol_col[index].value = ecs_os_strdup(symbol); + symbol_col[index].length = symbol_length; + symbol_col[index].hash = flecs_hash(symbol, symbol_length); + symbol_col[index].index_hash = 0; + symbol_col[index].index = NULL; } +/** Initialize component table. This table is manually constructed to bootstrap + * flecs. After this function has been called, the builtin components can be + * created. + * The reason this table is constructed manually is because it requires the size + * and alignment of the EcsComponent and EcsIdentifier components, which haven't + * been created yet */ static -bool eval_subset( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +ecs_table_t* bootstrap_component_table( + ecs_world_t *world) { - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_world_t *world = rule->world; - ecs_rule_subset_ctx_t *op_ctx = &iter->op_ctx[op_index].is.subset; - ecs_rule_subset_frame_t *frame = NULL; - ecs_table_record_t table_record; - ecs_rule_reg_t *regs = get_registers(iter, op); - - /* Get register indices for output */ - int32_t sp, row; - int32_t r = op->r_out; - ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); - - /* Get queried for id, fill out potential variables */ - ecs_rule_pair_t pair = op->filter; - ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); - ecs_id_record_t *idr; - ecs_table_t *table = NULL; - - if (!redo) { - op_ctx->stack = op_ctx->storage; - sp = op_ctx->sp = 0; - frame = &op_ctx->stack[sp]; - idr = frame->with_ctx.idr = find_tables(world, filter.mask); - if (!idr) { - return false; - } - - flecs_table_cache_iter(&idr->cache, &frame->with_ctx.it); - table_record = find_next_table(&filter, &frame->with_ctx); - - /* If first table set has no non-empty table, yield nothing */ - if (!table_record.hdr.table) { - return false; - } - - frame->row = 0; - frame->column = table_record.column; - table_reg_set(rule, regs, r, (frame->table = table_record.hdr.table)); - goto yield; - } + /* Before creating the table, ensure component ids are alive */ + ecs_ensure(world, ecs_id(EcsComponent)); + ecs_ensure(world, EcsFinal); + ecs_ensure(world, ecs_id(EcsIdentifier)); + ecs_ensure(world, EcsName); + ecs_ensure(world, EcsSymbol); + ecs_ensure(world, EcsAlias); + ecs_ensure(world, EcsChildOf); + ecs_ensure(world, EcsFlecsCore); + ecs_ensure(world, EcsOnDelete); + ecs_ensure(world, EcsThrow); + ecs_ensure(world, EcsWildcard); + ecs_ensure(world, EcsAny); - do { - sp = op_ctx->sp; - frame = &op_ctx->stack[sp]; - table = frame->table; - row = frame->row; + /* Before creating table, manually set flags for ChildOf/Identifier, as this + * can no longer be done after they are in use. */ + ecs_id_record_t *childof_idr = flecs_ensure_id_record(world, EcsChildOf); + childof_idr->flags |= ECS_ID_ON_DELETE_OBJECT_DELETE; + childof_idr->flags |= ECS_ID_DONT_INHERIT; - /* If row exceeds number of elements in table, find next table in frame that - * still has entities */ - while ((sp >= 0) && (row >= ecs_table_count(table))) { - table_record = find_next_table(&filter, &frame->with_ctx); + ecs_id_record_t *ident_idr = flecs_ensure_id_record( + world, ecs_id(EcsIdentifier)); + ident_idr->flags |= ECS_ID_DONT_INHERIT; - if (table_record.hdr.table) { - table = frame->table = table_record.hdr.table; - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - frame->row = 0; - frame->column = table_record.column; - table_reg_set(rule, regs, r, table); - goto yield; - } else { - sp = -- op_ctx->sp; - if (sp < 0) { - /* If none of the frames yielded anything, no more data */ - return false; - } - frame = &op_ctx->stack[sp]; - table = frame->table; - idr = frame->with_ctx.idr; - row = ++ frame->row; + ecs_id_t entities[] = { + ecs_id(EcsComponent), + EcsFinal, + ecs_pair(ecs_id(EcsIdentifier), EcsName), + ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), + ecs_pair(EcsChildOf, EcsFlecsCore), + ecs_pair(EcsOnDelete, EcsThrow) + }; + + ecs_ids_t array = { + .array = entities, + .count = 6 + }; - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); - } - } + ecs_table_t *result = flecs_table_find_or_create(world, &array); + ecs_data_t *data = &result->storage; - int32_t row_count = ecs_table_count(table); + /* Preallocate enough memory for initial components */ + data->entities = ecs_vector_new(ecs_entity_t, EcsFirstUserComponentId); + data->record_ptrs = ecs_vector_new(ecs_record_t*, EcsFirstUserComponentId); - /* Table must have at least row elements */ - ecs_assert(row_count > row, ECS_INTERNAL_ERROR, NULL); + data->columns[0].data = ecs_vector_new(EcsComponent, EcsFirstUserComponentId); + data->columns[1].data = ecs_vector_new(EcsIdentifier, EcsFirstUserComponentId); + data->columns[2].data = ecs_vector_new(EcsIdentifier, EcsFirstUserComponentId); + + return result; +} - ecs_entity_t *entities = ecs_vector_first( - table->storage.entities, ecs_entity_t); - ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); +static +void bootstrap_entity( + ecs_world_t *world, + ecs_entity_t id, + const char *name, + ecs_entity_t parent) +{ + char symbol[256]; + ecs_os_strcpy(symbol, "flecs.core."); + ecs_os_strcat(symbol, name); + + ecs_add_pair(world, id, EcsChildOf, parent); + ecs_set_name(world, id, name); + ecs_set_symbol(world, id, symbol); - /* The entity used to find the next table set */ - do { - ecs_entity_t e = entities[row]; + ecs_assert(ecs_get_name(world, id) != NULL, ECS_INTERNAL_ERROR, NULL); - /* Create look_for expression with the resolved entity as object */ - pair.reg_mask &= ~RULE_PAIR_OBJECT; /* turn of bit because it's not a reg */ - pair.obj.ent = e; - filter = pair_to_filter(iter, op, pair); + if (!parent || parent == EcsFlecsCore) { + ecs_assert(ecs_lookup_fullpath(world, name) == id, + ECS_INTERNAL_ERROR, NULL); + } +} - /* Find table set for expression */ - table = NULL; - idr = find_tables(world, filter.mask); +void flecs_bootstrap( + ecs_world_t *world) +{ + ecs_log_push(); - /* If table set is found, find first non-empty table */ - if (idr) { - ecs_rule_subset_frame_t *new_frame = &op_ctx->stack[sp + 1]; - new_frame->with_ctx.idr = idr; - flecs_table_cache_iter(&idr->cache, &new_frame->with_ctx.it); - table_record = find_next_table(&filter, &new_frame->with_ctx); + ecs_set_name_prefix(world, "Ecs"); - /* If set contains non-empty table, push it to stack */ - if (table_record.hdr.table) { - table = table_record.hdr.table; - op_ctx->sp ++; - new_frame->table = table; - new_frame->row = 0; - new_frame->column = table_record.column; - frame = new_frame; - } - } + /* Bootstrap type info (otherwise initialized by setting EcsComponent) */ + flecs_init_type_info_t(world, EcsComponent); + flecs_init_type_info_t(world, EcsIdentifier); + flecs_init_type_info_t(world, EcsComponentLifecycle); + flecs_init_type_info_t(world, EcsType); + flecs_init_type_info_t(world, EcsQuery); + flecs_init_type_info_t(world, EcsTrigger); + flecs_init_type_info_t(world, EcsObserver); + flecs_init_type_info_t(world, EcsIterable); - /* If no table was found for the current entity, advance row */ - if (!table) { - row = ++ frame->row; - } - } while (!table && row < row_count); - } while (!table); + /* Setup component lifecycle actions */ + ecs_set_component_actions(world, EcsComponent, { + .ctor = ecs_default_ctor + }); - table_reg_set(rule, regs, r, table); + ecs_set_component_actions(world, EcsIdentifier, { + .ctor = ecs_ctor(EcsIdentifier), + .dtor = ecs_dtor(EcsIdentifier), + .copy = ecs_copy(EcsIdentifier), + .move = ecs_move(EcsIdentifier), + .on_set = ecs_on_set(EcsIdentifier), + .on_remove = ecs_on_set(EcsIdentifier) + }); -yield: - set_term_vars(rule, regs, op->term, ecs_vector_get(frame->table->type, - ecs_id_t, frame->column)[0]); + ecs_set_component_actions(world, EcsTrigger, { + .ctor = ecs_ctor(EcsTrigger), + .dtor = ecs_dtor(EcsTrigger), + .copy = ecs_copy(EcsTrigger), + .move = ecs_move(EcsTrigger) + }); - return true; -} + ecs_set_component_actions(world, EcsObserver, { + .ctor = ecs_ctor(EcsObserver), + .dtor = ecs_dtor(EcsObserver), + .copy = ecs_copy(EcsObserver), + .move = ecs_move(EcsObserver) + }); -/* Select operation. The select operation finds and iterates a table set that - * corresponds to its pair expression. */ -static -bool eval_select( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_world_t *world = rule->world; - ecs_rule_with_ctx_t *op_ctx = &iter->op_ctx[op_index].is.with; - ecs_table_record_t table_record; - ecs_rule_reg_t *regs = get_registers(iter, op); + /* Create table for initial components */ + ecs_table_t *table = bootstrap_component_table(world); + assert(table != NULL); - /* Get register indices for output */ - int32_t r = op->r_out; - ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); + bootstrap_component(world, table, EcsIdentifier); + bootstrap_component(world, table, EcsComponent); + bootstrap_component(world, table, EcsComponentLifecycle); - /* Get queried for id, fill out potential variables */ - ecs_rule_pair_t pair = op->filter; - ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); - ecs_entity_t pattern = filter.mask; - int32_t *columns = rule_get_columns(iter, op); + bootstrap_component(world, table, EcsType); + bootstrap_component(world, table, EcsQuery); + bootstrap_component(world, table, EcsTrigger); + bootstrap_component(world, table, EcsObserver); + bootstrap_component(world, table, EcsIterable); - int32_t column = -1; - ecs_table_t *table = NULL; - ecs_id_record_t *idr; + world->stats.last_component_id = EcsFirstUserComponentId; + world->stats.last_id = EcsFirstUserEntityId; + world->stats.min_id = 0; + world->stats.max_id = 0; - if (!redo && op->term != -1) { - columns[op->term] = -1; - } + /* Populate core module */ + ecs_set_scope(world, EcsFlecsCore); - /* If this is a redo, we already looked up the table set */ - if (redo) { - idr = op_ctx->idr; - - /* If this is not a redo lookup the table set. Even though this may not be - * the first time the operation is evaluated, variables may have changed - * since last time, which could change the table set to lookup. */ - } else { - /* A table set is a set of tables that all contain at least the - * requested look_for expression. What is returned is a table record, - * which in addition to the table also stores the first occurrance at - * which the requested expression occurs in the table. This reduces (and - * in most cases eliminates) any searching that needs to occur in a - * table type. Tables are also registered under wildcards, which is why - * this operation can simply use the look_for variable directly */ + flecs_bootstrap_tag(world, EcsName); + flecs_bootstrap_tag(world, EcsSymbol); + flecs_bootstrap_tag(world, EcsAlias); - idr = op_ctx->idr = find_tables(world, pattern); - } + flecs_bootstrap_tag(world, EcsModule); + flecs_bootstrap_tag(world, EcsPrivate); + flecs_bootstrap_tag(world, EcsPrefab); + flecs_bootstrap_tag(world, EcsDisabled); - /* If no table set was found for queried for entity, there are no results */ - if (!idr) { - return false; - } + /* Initialize builtin modules */ + ecs_set_name(world, EcsFlecs, "flecs"); + ecs_add_id(world, EcsFlecs, EcsModule); - /* If the input register is not NULL, this is a variable that's been set by - * the application. */ - table = iter->registers[r].table.table; - bool output_is_input = table != NULL; + ecs_add_pair(world, EcsFlecsCore, EcsChildOf, EcsFlecs); + ecs_set_name(world, EcsFlecsCore, "core"); + ecs_add_id(world, EcsFlecsCore, EcsModule); - if (output_is_input && !redo) { - ecs_assert(regs[r].table.table == iter->registers[r].table.table, - ECS_INTERNAL_ERROR, NULL); + ecs_add_pair(world, EcsFlecsHidden, EcsChildOf, EcsFlecs); + ecs_set_name(world, EcsFlecsHidden, "hidden"); + ecs_add_id(world, EcsFlecsHidden, EcsModule); - table = iter->registers[r].table.table; + /* Initialize builtin entities */ + bootstrap_entity(world, EcsWorld, "World", EcsFlecsCore); + bootstrap_entity(world, EcsThis, "This", EcsFlecsCore); + bootstrap_entity(world, EcsWildcard, "*", EcsFlecsCore); + bootstrap_entity(world, EcsAny, "_", EcsFlecsCore); - /* Check if table can be found in the id record. If not, the provided - * table does not match with the query. */ - ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table); - if (!tr) { - return false; - } + /* Component/relationship properties */ + flecs_bootstrap_tag(world, EcsTransitive); + flecs_bootstrap_tag(world, EcsReflexive); + flecs_bootstrap_tag(world, EcsSymmetric); + flecs_bootstrap_tag(world, EcsFinal); + flecs_bootstrap_tag(world, EcsDontInherit); + flecs_bootstrap_tag(world, EcsTag); + flecs_bootstrap_tag(world, EcsExclusive); + flecs_bootstrap_tag(world, EcsAcyclic); + flecs_bootstrap_tag(world, EcsWith); - column = op_ctx->column = tr->column; - } + flecs_bootstrap_tag(world, EcsOnDelete); + flecs_bootstrap_tag(world, EcsOnDeleteObject); + flecs_bootstrap_tag(world, EcsRemove); + flecs_bootstrap_tag(world, EcsDelete); + flecs_bootstrap_tag(world, EcsThrow); - /* If this is not a redo, start at the beginning */ - if (!redo) { - if (!table) { - flecs_table_cache_iter(&idr->cache, &op_ctx->it); + flecs_bootstrap_tag(world, EcsDefaultChildComponent); - /* Return the first table_record in the table set. */ - table_record = find_next_table(&filter, op_ctx); - - /* If no table record was found, there are no results. */ - if (!table_record.hdr.table) { - return false; - } + /* Builtin relations */ + flecs_bootstrap_tag(world, EcsIsA); + flecs_bootstrap_tag(world, EcsChildOf); - table = table_record.hdr.table; + /* Builtin events */ + bootstrap_entity(world, EcsOnAdd, "OnAdd", EcsFlecsCore); + bootstrap_entity(world, EcsOnRemove, "OnRemove", EcsFlecsCore); + bootstrap_entity(world, EcsOnSet, "OnSet", EcsFlecsCore); + bootstrap_entity(world, EcsUnSet, "UnSet", EcsFlecsCore); + bootstrap_entity(world, EcsOnTableEmpty, "OnTableEmpty", EcsFlecsCore); + bootstrap_entity(world, EcsOnTableFill, "OnTableFilled", EcsFlecsCore); - /* Set current column to first occurrence of queried for entity */ - column = op_ctx->column = table_record.column; + /* Transitive relations are always Acyclic */ + ecs_add_pair(world, EcsTransitive, EcsWith, EcsAcyclic); - /* Store table in register */ - table_reg_set(rule, regs, r, table); - } - - /* If this is a redo, progress to the next match */ - } else { - /* First test if there are any more matches for the current table, in - * case we're looking for a wildcard. */ - if (filter.wildcard) { - table = table_reg_get(rule, regs, r).table; - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + /* Transitive relations */ + ecs_add_id(world, EcsIsA, EcsTransitive); + ecs_add_id(world, EcsIsA, EcsReflexive); - column = op_ctx->column; - column = find_next_column(world, table, column, &filter); - op_ctx->column = column; - } + /* Tag relations (relations that should never have data) */ + ecs_add_id(world, EcsIsA, EcsTag); + ecs_add_id(world, EcsChildOf, EcsTag); + ecs_add_id(world, EcsDefaultChildComponent, EcsTag); - /* If no next match was found for this table, move to next table */ - if (column == -1) { - if (output_is_input) { - return false; - } + /* Acyclic relations */ + ecs_add_id(world, EcsIsA, EcsAcyclic); + ecs_add_id(world, EcsChildOf, EcsAcyclic); + ecs_add_id(world, EcsWith, EcsAcyclic); - table_record = find_next_table(&filter, op_ctx); - if (!table_record.hdr.table) { - return false; - } + /* Exclusive properties */ + ecs_add_id(world, EcsChildOf, EcsExclusive); + ecs_add_id(world, EcsOnDelete, EcsExclusive); + ecs_add_id(world, EcsOnDeleteObject, EcsExclusive); + ecs_add_id(world, EcsDefaultChildComponent, EcsExclusive); - /* Assign new table to table register */ - table_reg_set(rule, regs, r, (table = table_record.hdr.table)); + /* Make EcsOnAdd, EcsOnSet events iterable to enable .yield_existing */ + ecs_set(world, EcsOnAdd, EcsIterable, { .init = on_event_iterable_init }); + ecs_set(world, EcsOnSet, EcsIterable, { .init = on_event_iterable_init }); - /* Assign first matching column */ - column = op_ctx->column = table_record.column; - } - } + /* Removal of ChildOf objects (parents) deletes the subject (child) */ + ecs_add_pair(world, EcsChildOf, EcsOnDeleteObject, EcsDelete); - /* If we got here, we found a match. Table and column must be set */ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL); + /* ChildOf, Identifier, Disabled and Prefab should never be inherited */ + ecs_add_id(world, EcsChildOf, EcsDontInherit); + ecs_add_id(world, ecs_id(EcsIdentifier), EcsDontInherit); - if (op->term != -1) { - columns[op->term] = column; - } + /* The (IsA, *) id record is used often in searches, so cache it */ + world->idr_isa_wildcard = flecs_ensure_id_record(world, + ecs_pair(EcsIsA, EcsWildcard)); - /* If this is a wildcard query, fill out the variable registers */ - if (filter.wildcard) { - reify_variables(iter, op, &filter, table->type, column); - } + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term = { + .id = ecs_pair(EcsChildOf, EcsWildcard), + .subj.set.mask = EcsSelf + }, + .events = { EcsOnAdd, EcsOnRemove }, + .yield_existing = true, + .callback = on_parent_change + }); - return true; -} + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = EcsFinal, .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_final + }); -/* With operation. The With operation always comes after either the Select or - * another With operation, and applies additional filters to the table. */ -static -bool eval_with( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_world_t *world = rule->world; - ecs_rule_with_ctx_t *op_ctx = &iter->op_ctx[op_index].is.with; - ecs_rule_reg_t *regs = get_registers(iter, op); + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = ecs_pair(EcsOnDelete, EcsWildcard), .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_on_delete + }); - /* Get register indices for input */ - int32_t r = op->r_in; + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = ecs_pair(EcsOnDeleteObject, EcsWildcard), .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_on_delete_object + }); - /* Get queried for id, fill out potential variables */ - ecs_rule_pair_t pair = op->filter; - ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); - int32_t *columns = rule_get_columns(iter, op); + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = EcsExclusive, .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_exclusive + }); - /* If looked for entity is not a wildcard (meaning there are no unknown/ - * unconstrained variables) and this is a redo, nothing more to yield. */ - if (redo && !filter.wildcard) { - return false; - } + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = EcsSymmetric, .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_symmetric + }); - int32_t column = -1; - ecs_table_t *table = NULL; - ecs_id_record_t *idr; + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = EcsDontInherit, .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = register_dont_inherit + }); - if (op->term != -1) { - columns[op->term] = -1; - } + /* Define trigger to make sure that adding a module to a child entity also + * adds it to the parent. */ + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = EcsModule, .subj.set.mask = EcsSelf }, + .events = {EcsOnAdd}, + .callback = ensure_module_tag + }); - /* If this is a redo, we already looked up the table set */ - if (redo) { - idr = op_ctx->idr; - - /* If this is not a redo lookup the table set. Even though this may not be - * the first time the operation is evaluated, variables may have changed - * since last time, which could change the table set to lookup. */ - } else { - /* Predicates can be reflexive, which means that if we have a - * transitive predicate which is provided with the same subject and - * object, it should return true. By default with will not return true - * as the subject likely does not have itself as a relationship, which - * is why this is a special case. - * - * TODO: might want to move this code to a separate with_reflexive - * instruction to limit branches for non-transitive queries (and to keep - * code more readable). - */ - if (pair.transitive && pair.reflexive) { - ecs_entity_t subj = 0, obj = 0; - - if (r == UINT8_MAX) { - subj = op->subject; - } else { - const ecs_rule_var_t *v_subj = &rule->vars[r]; + /* Define trigger for when component lifecycle is set for component */ + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = ecs_id(EcsComponentLifecycle), .subj.set.mask = EcsSelf }, + .events = {EcsOnSet}, + .callback = on_set_component_lifecycle + }); - if (v_subj->kind == EcsRuleVarKindEntity) { - subj = entity_reg_get(rule, regs, r); + /* Define trigger for updating component size when it changes */ + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = ecs_id(EcsComponent), .subj.set.mask = EcsSelf }, + .events = {EcsOnSet}, + .callback = on_set_component + }); - /* This is the input for the op, so should always be set */ - ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL); - } - } + ecs_add_id(world, EcsDisabled, EcsDontInherit); + ecs_add_id(world, EcsPrefab, EcsDontInherit); - /* If subj is set, it means that it is an entity. Try to also - * resolve the object. */ - if (subj) { - /* If the object is not a wildcard, it has been reified. Get the - * value from either the register or as a literal */ - if (!filter.obj_wildcard) { - obj = ecs_entity_t_lo(filter.mask); - if (subj == obj) { - return true; - } - } - } - } + /* Run bootstrap functions for other parts of the code */ + flecs_bootstrap_hierarchy(world); - /* The With operation finds the table set that belongs to its pair - * filter. The table set is a sparse set that provides an O(1) operation - * to check whether the current table has the required expression. */ - idr = op_ctx->idr = find_tables(world, filter.mask); - } + ecs_set_scope(world, 0); - /* If no table set was found for queried for entity, there are no results. - * If this result is a transitive query, the table we're evaluating may not - * be in the returned table set. Regardless, if the filter that contains a - * transitive predicate does not have any tables associated with it, there - * can be no transitive matches for the filter. */ - if (!idr) { - return false; - } + ecs_log_pop(); +} - table = reg_get_table(rule, op, regs, r).table; - if (!table) { - return false; - } - /* If this is not a redo, start at the beginning */ - if (!redo) { - column = op_ctx->column = find_next_column(world, table, -1, &filter); - - /* If this is a redo, progress to the next match */ - } else { - if (!filter.wildcard) { - return false; - } - - /* Find the next match for the expression in the column. The columns - * array keeps track of the state for each With operation, so that - * even after redoing a With, the search doesn't have to start from - * the beginning. */ - column = find_next_column(world, table, op_ctx->column, &filter); - op_ctx->column = column; +static +void table_cache_list_remove( + ecs_table_cache_t *cache, + ecs_table_cache_hdr_t *elem) +{ + ecs_table_cache_hdr_t *next = elem->next; + ecs_table_cache_hdr_t *prev = elem->prev; + + if (next) { + next->prev = prev; + } + if (prev) { + prev->next = next; } - /* If no next match was found for this table, no more data */ - if (column == -1) { - return false; + cache->empty_tables.count -= !!elem->empty; + cache->tables.count -= !elem->empty; + + if (cache->empty_tables.first == elem) { + cache->empty_tables.first = next; + } else if (cache->tables.first == elem) { + cache->tables.first = next; + } + if (cache->empty_tables.last == elem) { + cache->empty_tables.last = prev; } + if (cache->tables.last == elem) { + cache->tables.last = prev; + } +} - if (op->term != -1) { - columns[op->term] = column; +static +void table_cache_list_insert( + ecs_table_cache_t *cache, + ecs_table_cache_hdr_t *elem) +{ + ecs_table_cache_hdr_t *last; + if (elem->empty) { + last = cache->empty_tables.last; + cache->empty_tables.last = elem; + if ((++ cache->empty_tables.count) == 1) { + cache->empty_tables.first = elem; + } + } else { + last = cache->tables.last; + cache->tables.last = elem; + if ((++ cache->tables.count) == 1) { + cache->tables.first = elem; + } } - /* If we got here, we found a match. Table and column must be set */ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL); + elem->next = NULL; + elem->prev = last; - /* If this is a wildcard query, fill out the variable registers */ - if (filter.wildcard) { - reify_variables(iter, op, &filter, table->type, column); + if (last) { + last->next = elem; } +} - set_source(it, op, regs, r); +void ecs_table_cache_init( + ecs_table_cache_t *cache) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_map_init(&cache->index, ecs_table_cache_hdr_t*, 0); +} - return true; +void ecs_table_cache_fini( + ecs_table_cache_t *cache) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_map_fini(&cache->index); } -/* Each operation. The each operation is a simple operation that takes a table - * as input, and outputs each of the entities in a table. This operation is - * useful for rules that match a table, and where the entities of the table are - * used as predicate or object. If a rule contains an each operation, an - * iterator is guaranteed to yield an entity instead of a table. The input for - * an each operation can only be the root variable. */ -static -bool eval_each( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +bool ecs_table_cache_is_empty( + const ecs_table_cache_t *cache) { - ecs_rule_iter_t *iter = &it->priv.iter.rule; - ecs_rule_each_ctx_t *op_ctx = &iter->op_ctx[op_index].is.each; - ecs_rule_reg_t *regs = get_registers(iter, op); - int32_t r_in = op->r_in; - int32_t r_out = op->r_out; - ecs_entity_t e; + return ecs_map_count(&cache->index) == 0; +} - /* Make sure in/out registers are of the correct kind */ - ecs_assert(iter->rule->vars[r_in].kind == EcsRuleVarKindTable, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(iter->rule->vars[r_out].kind == EcsRuleVarKindEntity, +void ecs_table_cache_insert( + ecs_table_cache_t *cache, + const ecs_table_t *table, + ecs_table_cache_hdr_t *result) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!table || (ecs_table_cache_get(cache, table) == NULL), ECS_INTERNAL_ERROR, NULL); + ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); - /* Get table, make sure that it contains data. The select operation should - * ensure that empty tables are never forwarded. */ - ecs_table_slice_t slice = table_reg_get(iter->rule, regs, r_in); - ecs_table_t *table = slice.table; - if (table) { - int32_t row, count = slice.count; - int32_t offset = slice.offset; - - if (!count) { - count = ecs_table_count(table); - ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL); - } else { - count += offset; - } - - ecs_entity_t *entities = ecs_vector_first( - table->storage.entities, ecs_entity_t); - ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); + bool empty; + if (!table) { + empty = false; + } else { + empty = ecs_table_count(table) == 0; + } - /* If this is is not a redo, start from row 0, otherwise go to the - * next entity. */ - if (!redo) { - row = op_ctx->row = offset; - } else { - row = ++ op_ctx->row; - } + result->cache = cache; + result->table = (ecs_table_t*)table; + result->empty = empty; - /* If row exceeds number of entities in table, return false */ - if (row >= count) { - return false; - } + table_cache_list_insert(cache, result); - /* Skip builtin entities that could confuse operations */ - e = entities[row]; - while (e == EcsWildcard || e == EcsThis || e == EcsAny) { - row ++; - if (row == count) { - return false; - } - e = entities[row]; - } - } else { - if (!redo) { - e = entity_reg_get(iter->rule, regs, r_in); - } else { - return false; - } + if (table) { + ecs_map_set_ptr(&cache->index, table->id, result); } - /* Assign entity */ - entity_reg_set(iter->rule, regs, r_out, e); + ecs_assert(empty || cache->tables.first != NULL, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!empty || cache->empty_tables.first != NULL, + ECS_INTERNAL_ERROR, NULL); +} - return true; +void* ecs_table_cache_get( + const ecs_table_cache_t *cache, + const ecs_table_t *table) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + return ecs_map_get_ptr(&cache->index, ecs_table_cache_hdr_t*, table->id); } -/* Store operation. Stores entity in register. This can either be an entity - * literal or an entity variable that will be stored in a table register. The - * latter facilitates scenarios where an iterator only need to return a single - * entity but where the Yield returns tables. */ -static -bool eval_store( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +void* ecs_table_cache_remove( + ecs_table_cache_t *cache, + const ecs_table_t *table, + ecs_table_cache_hdr_t *elem) { - (void)op_index; + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - if (redo) { - /* Only ever return result once */ - return false; + if (!ecs_map_is_initialized(&cache->index)) { + return NULL; } - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_rule_reg_t *regs = get_registers(iter, op); - int32_t r_in = op->r_in; - int32_t r_out = op->r_out; - - const ecs_rule_var_t *var_out = &rule->vars[r_out]; - if (var_out->kind == EcsRuleVarKindEntity) { - ecs_entity_t out, in = reg_get_entity(rule, op, regs, r_in); - - out = iter->registers[r_out].entity; - bool output_is_input = out && out != EcsWildcard; - - if (output_is_input && !redo) { - ecs_assert(regs[r_out].entity == iter->registers[r_out].entity, - ECS_INTERNAL_ERROR, NULL); - - if (out != in) { - /* If output variable is set it must match the input */ - return false; - } + if (!elem) { + elem = ecs_map_get_ptr( + &cache->index, ecs_table_cache_hdr_t*, table->id); + if (!elem) { + return false; } + } - reg_set_entity(rule, regs, r_out, in); - } else { - ecs_table_slice_t out, in = reg_get_table(rule, op, regs, r_in); + ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(elem->cache == cache, ECS_INTERNAL_ERROR, NULL); + ecs_assert(elem->table == table, ECS_INTERNAL_ERROR, NULL); - out = iter->registers[r_out].table; - bool output_is_input = out.table != NULL; + table_cache_list_remove(cache, elem); - if (output_is_input && !redo) { - ecs_assert(regs[r_out].entity == iter->registers[r_out].entity, - ECS_INTERNAL_ERROR, NULL); + ecs_map_remove(&cache->index, table->id); - if (ecs_os_memcmp_t(&out, &in, ecs_table_slice_t)) { - /* If output variable is set it must match the input */ - return false; - } - } + return elem; +} - reg_set_table(rule, regs, r_out, in); +bool ecs_table_cache_set_empty( + ecs_table_cache_t *cache, + const ecs_table_t *table, + bool empty) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - /* Ensure that if the input was an empty entity, information is not - * lost */ - if (!regs[r_out].table.table) { - regs[r_out].entity = reg_get_entity(rule, op, regs, r_in); - } + ecs_table_cache_hdr_t *elem = ecs_map_get_ptr( + &cache->index, ecs_table_cache_hdr_t*, table->id); + if (!elem) { + return false; } - ecs_rule_filter_t filter = pair_to_filter(iter, op, op->filter); - set_term_vars(rule, regs, op->term, filter.mask); + if (elem->empty == empty) { + return false; + } + + table_cache_list_remove(cache, elem); + elem->empty = empty; + table_cache_list_insert(cache, elem); return true; } -/* A setjmp operation sets the jump label for a subsequent jump label. When the - * operation is first evaluated (redo=false) it sets the label to the on_pass - * label, and returns true. When the operation is evaluated again (redo=true) - * the label is set to on_fail and the operation returns false. */ -static -bool eval_setjmp( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +void ecs_table_cache_fini_delete_all( + ecs_world_t *world, + ecs_table_cache_t *cache) { - ecs_rule_iter_t *iter = &it->priv.iter.rule; - ecs_rule_setjmp_ctx_t *ctx = &iter->op_ctx[op_index].is.setjmp; + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + if (!ecs_map_is_initialized(&cache->index)) { + return; + } - if (!redo) { - ctx->label = op->on_pass; - return true; - } else { - ctx->label = op->on_fail; - return false; + /* Temporarily set index to NULL, so that when the table tries to remove + * itself from the cache it won't be able to. This keeps the arrays we're + * iterating over consistent */ + ecs_map_t index = cache->index; + ecs_os_zeromem(&cache->index); + + ecs_table_cache_hdr_t *cur, *next = cache->tables.first; + while ((cur = next)) { + flecs_delete_table(world, cur->table); + next = cur->next; + } + + next = cache->empty_tables.first; + while ((cur = next)) { + flecs_delete_table(world, cur->table); + next = cur->next; } + + cache->index = index; + + ecs_table_cache_fini(cache); } -/* The jump operation jumps to an operation label. The operation always returns - * true. Since the operation modifies the control flow of the program directly, - * the dispatcher does not look at the on_pass or on_fail labels of the jump - * instruction. Instead, the on_pass label is used to store the label of the - * operation that contains the label to jump to. */ -static -bool eval_jump( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +bool flecs_table_cache_iter( + ecs_table_cache_t *cache, + ecs_table_cache_iter_t *out) { - (void)it; - (void)op; - (void)op_index; + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); + out->next = cache->tables.first; + out->cur = NULL; + return out->next != NULL; +} - /* Passthrough, result is not used for control flow */ - return !redo; +bool flecs_table_cache_empty_iter( + ecs_table_cache_t *cache, + ecs_table_cache_iter_t *out) +{ + ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); + out->next = cache->empty_tables.first; + out->cur = NULL; + return out->next != NULL; } -/* The not operation reverts the result of the operation it embeds */ -static -bool eval_not( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) +ecs_table_cache_hdr_t* _flecs_table_cache_next( + ecs_table_cache_iter_t *it) { - (void)it; - (void)op; - (void)op_index; + ecs_table_cache_hdr_t *next = it->next; + if (!next) { + return false; + } - return !redo; + it->cur = next; + it->next = next->next; + return next; } -/* Check if entity is stored in table */ + +/* Table sanity check to detect storage issues. Only enabled in SANITIZE mode as + * this can severly slow down many ECS operations. */ +#ifdef FLECS_SANITIZE static -bool eval_intable( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - (void)op_index; +void check_table_sanity(ecs_table_t *table) { + int32_t size = ecs_vector_size(table->storage.entities); + int32_t count = ecs_vector_count(table->storage.entities); - if (redo) { - return false; - } + ecs_assert(size == ecs_vector_size(table->storage.record_ptrs), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(count == ecs_vector_count(table->storage.record_ptrs), + ECS_INTERNAL_ERROR, NULL); - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - ecs_world_t *world = rule->world; - ecs_rule_reg_t *regs = get_registers(iter, op); - ecs_table_t *table = table_reg_get(rule, regs, op->r_in).table; + int32_t sw_offset = table->sw_column_offset; + int32_t sw_count = table->sw_column_count; + int32_t bs_offset = table->bs_column_offset; + int32_t bs_count = table->bs_column_count; + int32_t type_count = ecs_vector_count(table->type); + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - ecs_rule_pair_t pair = op->filter; - ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); - ecs_entity_t obj = ECS_PAIR_SECOND(filter.mask); - ecs_assert(obj != 0 && obj != EcsWildcard, ECS_INTERNAL_ERROR, NULL); - obj = ecs_get_alive(world, obj); - ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert((sw_count + sw_offset) <= type_count, ECS_INTERNAL_ERROR, NULL); + ecs_assert((bs_count + bs_offset) <= type_count, ECS_INTERNAL_ERROR, NULL); - ecs_table_t *obj_table = ecs_get_table(world, obj); - return obj_table == table; -} + ecs_type_t storage_type = table->storage_type; + ecs_table_t *storage_table = table->storage_table; + ecs_assert(table->storage_type == NULL || table->storage_table != NULL, + ECS_INTERNAL_ERROR, NULL); -/* Yield operation. This is the simplest operation, as all it does is return - * false. This will move the solver back to the previous instruction which - * forces redo's on previous operations, for as long as there are matching - * results. */ -static -bool eval_yield( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - (void)it; - (void)op; - (void)op_index; - (void)redo; + int32_t i; + if (storage_table) { + ecs_assert(storage_type == storage_table->type, + ECS_INTERNAL_ERROR, NULL); + int32_t storage_count = ecs_vector_count(storage_type); + ecs_assert(type_count >= storage_count, ECS_INTERNAL_ERROR, NULL); - /* Yield always returns false, because there are never any operations after - * a yield. */ - return false; -} + int32_t *storage_map = table->storage_map; + ecs_assert(storage_map != NULL, ECS_INTERNAL_ERROR, NULL); -/* Dispatcher for operations */ -static -bool eval_op( - ecs_iter_t *it, - ecs_rule_op_t *op, - int32_t op_index, - bool redo) -{ - switch(op->kind) { - case EcsRuleInput: - return eval_input(it, op, op_index, redo); - case EcsRuleSelect: - return eval_select(it, op, op_index, redo); - case EcsRuleWith: - return eval_with(it, op, op_index, redo); - case EcsRuleSubSet: - return eval_subset(it, op, op_index, redo); - case EcsRuleSuperSet: - return eval_superset(it, op, op_index, redo); - case EcsRuleEach: - return eval_each(it, op, op_index, redo); - case EcsRuleStore: - return eval_store(it, op, op_index, redo); - case EcsRuleSetJmp: - return eval_setjmp(it, op, op_index, redo); - case EcsRuleJump: - return eval_jump(it, op, op_index, redo); - case EcsRuleNot: - return eval_not(it, op, op_index, redo); - case EcsRuleInTable: - return eval_intable(it, op, op_index, redo); - case EcsRuleYield: - return eval_yield(it, op, op_index, redo); - default: - return false; + ecs_id_t *storage_ids = ecs_vector_first(storage_type, ecs_id_t); + for (i = 0; i < type_count; i ++) { + if (storage_map[i] != -1) { + ecs_assert(ids[i] == storage_ids[storage_map[i]], + ECS_INTERNAL_ERROR, NULL); + } + } + + for (i = 0; i < storage_count; i ++) { + ecs_type_info_t *ti = NULL; + ecs_column_t *column = &table->storage.columns[i]; + if (table->type_info) { + ti = table->type_info[i]; + } + if (ti) { + ecs_assert(ti->size == column->size, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ti->alignment == column->alignment, + ECS_INTERNAL_ERROR, NULL); + } + ecs_assert(size == ecs_vector_size(column->data), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(count == ecs_vector_count(column->data), + ECS_INTERNAL_ERROR, NULL); + ecs_vector_assert_size(column->data, column->size); + int32_t storage_map_id = storage_map[i + type_count]; + ecs_assert(storage_map_id >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ids[storage_map_id] == storage_ids[i], + ECS_INTERNAL_ERROR, NULL); + } + } + + if (sw_count) { + ecs_assert(table->storage.sw_columns != NULL, + ECS_INTERNAL_ERROR, NULL); + for (i = 0; i < sw_count; i ++) { + ecs_sw_column_t *sw = &table->storage.sw_columns[i]; + ecs_assert(sw->data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ecs_vector_count(sw->data->values) == count, + ECS_INTERNAL_ERROR, NULL); + ecs_assert((ids[i + sw_offset] & ECS_ROLE_MASK) == + ECS_SWITCH, ECS_INTERNAL_ERROR, NULL); + } + } + + if (bs_count) { + ecs_assert(table->storage.bs_columns != NULL, + ECS_INTERNAL_ERROR, NULL); + for (i = 0; i < bs_count; i ++) { + ecs_bs_column_t *bs = &table->storage.bs_columns[i]; + ecs_assert(flecs_bitset_count(&bs->data) == count, + ECS_INTERNAL_ERROR, NULL); + ecs_assert((ids[i + bs_offset] & ECS_ROLE_MASK) == + ECS_DISABLED, ECS_INTERNAL_ERROR, NULL); + } } } +#else +#define check_table_sanity(table) +#endif -/* Utility to copy all registers to the next frame. Keeping track of register - * values for each operation is necessary, because if an operation is asked to - * redo matching, it must to be able to pick up from where it left of */ +/* Count number of switch columns */ static -void push_registers( - ecs_rule_iter_t *it, - int32_t cur, - int32_t next) +int32_t switch_column_count( + ecs_table_t *table) { - if (!it->rule->var_count) { - return; - } + int32_t i, sw_count = 0, count = ecs_vector_count(table->type); + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - ecs_rule_reg_t *src_regs = get_register_frame(it, cur); - ecs_rule_reg_t *dst_regs = get_register_frame(it, next); + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + if (ECS_HAS_ROLE(id, SWITCH)) { + if (!sw_count) { + table->sw_column_offset = i; + } + sw_count ++; + } + } - ecs_os_memcpy_n(dst_regs, src_regs, - ecs_rule_reg_t, it->rule->var_count); + return sw_count; } -/* Utility to copy all columns to the next frame. Columns keep track of which - * columns are currently being evaluated for a table, and are populated by the - * Select and With operations. The columns array is important, as it is used - * to tell the application where to find component data. */ +/* Count number of bitset columns */ static -void push_columns( - ecs_rule_iter_t *it, - int32_t cur, - int32_t next) +int32_t bitset_column_count( + ecs_table_t *table) { - if (!it->rule->filter.term_count) { - return; - } + int32_t count = 0; + ecs_vector_each(table->type, ecs_entity_t, c_ptr, { + ecs_entity_t component = *c_ptr; - int32_t *src_cols = rule_get_columns_frame(it, cur); - int32_t *dst_cols = rule_get_columns_frame(it, next); + if (ECS_HAS_ROLE(component, DISABLED)) { + if (!count) { + table->bs_column_offset = c_ptr_i; + } + count ++; + } + }); - ecs_os_memcpy_n(dst_cols, src_cols, int32_t, it->rule->filter.term_count); + return count; } -/* Populate iterator with data before yielding to application */ static -void populate_iterator( - const ecs_rule_t *rule, - ecs_iter_t *iter, - ecs_rule_iter_t *it, - ecs_rule_op_t *op) +void init_storage_map( + ecs_table_t *table) { - ecs_world_t *world = rule->world; - int32_t r = op->r_in; - ecs_rule_reg_t *regs = get_register_frame(it, op->frame); - ecs_table_t *table = NULL; - int32_t count = 0; - int32_t offset = 0; + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + if (!table->storage_table) { + return; + } - /* If the input register for the yield does not point to a variable, - * the rule doesn't contain a this (.) variable. In that case, the - * iterator doesn't contain any data, and this function will simply - * return true or false. An application will still be able to obtain - * the variables that were resolved. */ - if (r != UINT8_MAX) { - const ecs_rule_var_t *var = &rule->vars[r]; - ecs_rule_reg_t *reg = ®s[r]; + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); + int32_t t, ids_count = ecs_vector_count(table->type); + ecs_id_t *storage_ids = ecs_vector_first(table->storage_type, ecs_id_t); + int32_t s, storage_ids_count = ecs_vector_count(table->storage_type); - if (var->kind == EcsRuleVarKindTable) { - ecs_table_slice_t slice = table_reg_get(rule, regs, r); - table = slice.table; - count = slice.count; - offset = slice.offset; - } else { - /* If a single entity is returned, simply return the - * iterator with count 1 and a pointer to the entity id */ - ecs_assert(var->kind == EcsRuleVarKindEntity, - ECS_INTERNAL_ERROR, NULL); + if (!ids_count) { + table->storage_map = NULL; + return; + } - ecs_entity_t e = reg->entity; - ecs_record_t *record = ecs_eis_get(world, e); - offset = ECS_RECORD_TO_ROW(record->row); + table->storage_map = ecs_os_malloc_n( + int32_t, ids_count + storage_ids_count); - /* If an entity is not stored in a table, it could not have - * been matched by anything */ - ecs_assert(record != NULL, ECS_INTERNAL_ERROR, NULL); - table = record->table; - count = 1; - } - } + int32_t *t2s = table->storage_map; + int32_t *s2t = &table->storage_map[ids_count]; - int32_t i, var_count = rule->var_count; - int32_t term_count = rule->filter.term_count; - iter->variables = it->variables; + for (s = 0, t = 0; (t < ids_count) && (s < storage_ids_count); ) { + ecs_id_t id = ids[t]; + ecs_id_t storage_id = storage_ids[s]; - for (i = 0; i < var_count; i ++) { - if (rule->vars[i].kind == EcsRuleVarKindEntity) { - it->variables[i] = regs[i].entity; + if (id == storage_id) { + t2s[t] = s; + s2t[s] = t; } else { - it->variables[i] = 0; + t2s[t] = -1; } - } - for (i = 0; i < term_count; i ++) { - int32_t v = rule->term_vars[i].subj; - if (v != -1) { - const ecs_rule_var_t *var = &rule->vars[v]; - if (var->name[0] != '.') { - if (var->kind == EcsRuleVarKindEntity) { - iter->subjects[i] = regs[var->id].entity; - } else { - /* This can happen for Any variables, where the actual - * content of the variable is not of interest to the query. - * Just pick the first entity from the table, so that the - * column can be correctly resolved */ - ecs_table_t *t = regs[var->id].table.table; - if (t) { - iter->subjects[i] = ecs_vector_first( - t->storage.entities, ecs_entity_t)[0]; - } else { - /* Can happen if term is optional */ - iter->subjects[i] = 0; - } - } - } - } - } + /* Ids can never get ahead of storage id, as ids are a superset of the + * storage ids */ + ecs_assert(id <= storage_id, ECS_INTERNAL_ERROR, NULL); - /* Iterator expects column indices to start at 1 */ - iter->columns = rule_get_columns_frame(it, op->frame); - for (i = 0; i < term_count; i ++) { - ecs_entity_t subj = iter->subjects[i]; - int32_t c = ++ iter->columns[i]; - if (!subj) { - subj = iter->terms[i].subj.entity; - if (subj != EcsThis && subj != EcsAny) { - iter->columns[i] = 0; - } - } else if (c) { - iter->columns[i] = -1; - } + t += (id <= storage_id); + s += (id == storage_id); } - /* Set iterator ids */ - for (i = 0; i < term_count; i ++) { - const ecs_rule_term_vars_t *vars = &rule->term_vars[i]; - ecs_term_t *term = &rule->filter.terms[i]; - if (term->oper == EcsOptional || term->oper == EcsNot) { - if (iter->columns[i] == 0) { - iter->ids[i] = term->id; - continue; - } - } + /* Storage ids is always a subset of ids, so all should be iterated */ + ecs_assert(s == storage_ids_count, ECS_INTERNAL_ERROR, NULL); - ecs_id_t id = term->id; - ecs_entity_t pred = 0; - ecs_entity_t obj = 0; - bool is_pair = ECS_HAS_ROLE(id, PAIR); + /* Initialize remainder of type -> storage_type map */ + for (; (t < ids_count); t ++) { + t2s[t] = -1; + } +} - if (!is_pair) { - pred = id; - } else { - pred = ECS_PAIR_FIRST(id); - obj = ECS_PAIR_SECOND(id); - } +static +void init_storage_table( + ecs_world_t *world, + ecs_table_t *table) +{ + if (table->storage_table) { + return; + } + + int32_t i, count = ecs_vector_count(table->type); + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); + ecs_ids_t storage_ids = { + .array = ecs_os_alloca_n(ecs_id_t, count) + }; - if (vars->pred != -1) { - pred = regs[vars->pred].entity; - } - if (vars->obj != -1) { - ecs_assert(is_pair, ECS_INTERNAL_ERROR, NULL); - obj = regs[vars->obj].entity; + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + + if ((id == ecs_id(EcsComponent)) || + (ECS_PAIR_FIRST(id) == ecs_id(EcsIdentifier))) + { + storage_ids.array[storage_ids.count ++] = id; + continue; } - if (!is_pair) { - id = pred; - } else { - id = ecs_pair(pred, obj); + const EcsComponent *comp = flecs_component_from_id(world, id); + if (!comp || !comp->size) { + continue; } - iter->ids[i] = id; + storage_ids.array[storage_ids.count ++] = id; + } + + if (storage_ids.count && storage_ids.count != count) { + table->storage_table = flecs_table_find_or_create(world, &storage_ids); + table->storage_type = table->storage_table->type; + table->storage_table->refcount ++; + ecs_assert(table->storage_table != NULL, ECS_INTERNAL_ERROR, NULL); + } else if (storage_ids.count) { + table->storage_table = table; + table->storage_type = table->storage_table->type; + ecs_assert(table->storage_table != NULL, ECS_INTERNAL_ERROR, NULL); } - flecs_iter_populate_data(world, iter, table, offset, count, - iter->ptrs, iter->sizes); + if (!table->storage_map) { + init_storage_map(table); + } } static -bool is_control_flow( - ecs_rule_op_t *op) +ecs_flags32_t type_info_flags( + const ecs_type_info_t *ti) { - switch(op->kind) { - case EcsRuleSetJmp: - case EcsRuleJump: - return true; - default: - return false; + ecs_flags32_t flags = 0; + + if (ti->lifecycle.ctor) { + flags |= EcsTableHasCtors; + } + if (ti->lifecycle.dtor) { + flags |= EcsTableHasDtors; + } + if (ti->lifecycle.on_remove) { + flags |= EcsTableHasDtors; + } + if (ti->lifecycle.copy) { + flags |= EcsTableHasCopy; } + if (ti->lifecycle.move) { + flags |= EcsTableHasMove; + } + + return flags; } -bool ecs_rule_next( - ecs_iter_t *it) +static +void init_type_info( + ecs_world_t *world, + ecs_table_t *table) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL); + ecs_table_t *storage_table = table->storage_table; + if (!storage_table) { + return; + } - if (flecs_iter_next_row(it)) { - return true; + if (storage_table != table) { + /* Because the storage table is guaranteed to have the same components + * (but not tags) as this table, we can share the type info cache */ + table->type_info = storage_table->type_info; + table->flags |= storage_table->flags; + return; } - return flecs_iter_next_instanced(it, ecs_rule_next_instanced(it)); -error: - return false; + ecs_type_t type = table->storage_type; + ecs_assert(type != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t i, count = ecs_vector_count(type); + + table->type_info = ecs_os_calloc_n(ecs_type_info_t*, count); + + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + ecs_entity_t t = ecs_get_typeid(world, id); + + /* Component type info must have been registered before using it */ + const ecs_type_info_t *ti = flecs_get_type_info(world, t); + ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); + table->flags |= type_info_flags(ti); + table->type_info[i] = (ecs_type_info_t*)ti; + } } -/* Iterator next function. This evaluates the program until it reaches a Yield - * operation, and returns the intermediate result(s) to the application. An - * iterator can, depending on the program, either return a table, entity, or - * just true/false, in case a rule doesn't contain the this variable. */ -bool ecs_rule_next_instanced( - ecs_iter_t *it) +void flecs_table_init_data( + ecs_world_t *world, + ecs_table_t *table) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL); + init_storage_table(world, table); + init_type_info(world, table); - ecs_rule_iter_t *iter = &it->priv.iter.rule; - const ecs_rule_t *rule = iter->rule; - bool redo = iter->redo; - int32_t last_frame = -1; - bool init_subjects = it->subjects == NULL; + int32_t sw_count = table->sw_column_count = switch_column_count(table); + int32_t bs_count = table->bs_column_count = bitset_column_count(table); - /* Can't iterate an iterator that's already depleted */ - ecs_check(iter->op != -1, ECS_INVALID_PARAMETER, NULL); + ecs_data_t *storage = &table->storage; + ecs_type_t type = table->storage_type; - flecs_iter_init(it); + int32_t i, count = ecs_vector_count(type); - /* Make sure that if there are any terms with literal subjects, they're - * initialized in the subjects array */ - if (init_subjects) { - int32_t i; - for (i = 0; i < rule->filter.term_count; i ++) { - ecs_term_t *t = &rule->filter.terms[i]; - ecs_term_id_t *subj = &t->subj; - ecs_assert(subj->var == EcsVarIsVariable || subj->entity != EcsThis, - ECS_INTERNAL_ERROR, NULL); + /* Root tables don't have columns */ + if (!count && !sw_count && !bs_count) { + storage->columns = NULL; + } - if (subj->var == EcsVarIsEntity) { - it->subjects[i] = subj->entity; + if (count) { + ecs_entity_t *ids = ecs_vector_first(type, ecs_entity_t); + storage->columns = ecs_os_calloc_n(ecs_column_t, count); + + for (i = 0; i < count; i ++) { + ecs_entity_t id = ids[i]; + + /* Bootstrap components */ + if (id == ecs_id(EcsComponent)) { + storage->columns[i].size = ECS_SIZEOF(EcsComponent); + storage->columns[i].alignment = ECS_ALIGNOF(EcsComponent); + continue; + } else if (ECS_PAIR_FIRST(id) == ecs_id(EcsIdentifier)) { + storage->columns[i].size = ECS_SIZEOF(EcsIdentifier); + storage->columns[i].alignment = ECS_ALIGNOF(EcsIdentifier); + continue; } + + const EcsComponent *component = flecs_component_from_id(world, id); + ecs_assert(component != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(component->size != 0, ECS_INTERNAL_ERROR, NULL); + + storage->columns[i].size = flecs_itoi16(component->size); + storage->columns[i].alignment = flecs_itoi16(component->alignment); } } - do { - /* Evaluate an operation. The result of an operation determines the - * flow of the program. If an operation returns true, the program - * continues to the operation pointed to by 'on_pass'. If the operation - * returns false, the program continues to the operation pointed to by - * 'on_fail'. - * - * In most scenarios, on_pass points to the next operation, and on_fail - * points to the previous operation. - * - * When an operation fails, the previous operation will be invoked with - * redo=true. This will cause the operation to continue its search from - * where it left off. When the operation succeeds, the next operation - * will be invoked with redo=false. This causes the operation to start - * from the beginning, which is necessary since it just received a new - * input. */ - int32_t op_index = iter->op; - ecs_rule_op_t *op = &rule->operations[op_index]; - int32_t cur = op->frame; + if (sw_count) { + ecs_entity_t *ids = ecs_vector_first(table->type, ecs_entity_t); + int32_t sw_offset = table->sw_column_offset; + storage->sw_columns = ecs_os_calloc_n(ecs_sw_column_t, sw_count); - /* If this is not the first operation and is also not a control flow - * operation, push a new frame on the stack for the next operation */ - if (!redo && !is_control_flow(op) && cur && cur != last_frame) { - int32_t prev = cur - 1; - push_registers(iter, prev, cur); - push_columns(iter, prev, cur); - } + for (i = 0; i < sw_count; i ++) { + ecs_entity_t e = ids[i + sw_offset]; + ecs_assert(ECS_HAS_ROLE(e, SWITCH), ECS_INTERNAL_ERROR, NULL); + e = e & ECS_COMPONENT_MASK; + const EcsType *type_ptr = ecs_get(world, e, EcsType); + ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_table_t *sw_table = type_ptr->normalized; + ecs_type_t sw_type = sw_table->type; - /* Dispatch the operation */ - bool result = eval_op(it, op, op_index, redo); - iter->op = result ? op->on_pass : op->on_fail; + ecs_entity_t *sw_array = ecs_vector_first(sw_type, ecs_entity_t); + int32_t sw_array_count = ecs_vector_count(sw_type); - /* If the current operation is yield, return results */ - if (op->kind == EcsRuleYield) { - populate_iterator(rule, it, iter, op); - iter->redo = true; - return true; + ecs_switch_t *sw = flecs_switch_new( + sw_array[0], + sw_array[sw_array_count - 1], + 0); + + storage->sw_columns[i].data = sw; + storage->sw_columns[i].type = sw_table; } + } - /* If the current operation is a jump, goto stored label */ - if (op->kind == EcsRuleJump) { - /* Label is stored in setjmp context */ - iter->op = iter->op_ctx[op->on_pass].is.setjmp.label; + if (bs_count) { + storage->bs_columns = ecs_os_calloc_n(ecs_bs_column_t, bs_count); + for (i = 0; i < bs_count; i ++) { + flecs_bitset_init(&storage->bs_columns[i].data); } + } +} - /* If jumping backwards, it's a redo */ - redo = iter->op <= op_index; +static +void notify_trigger( + ecs_world_t *world, + ecs_table_t *table, + ecs_entity_t event) +{ + (void)world; - if (!is_control_flow(op)) { - last_frame = op->frame; - } - } while (iter->op != -1); + if (event == EcsOnAdd) { + table->flags |= EcsTableHasOnAdd; + } else if (event == EcsOnRemove) { + table->flags |= EcsTableHasOnRemove; + } else if (event == EcsOnSet) { + table->flags |= EcsTableHasOnSet; + } else if (event == EcsUnSet) { + table->flags |= EcsTableHasUnSet; + } +} + +static +void run_on_remove( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data) +{ + int32_t count = ecs_vector_count(data->entities); + if (count) { + ecs_ids_t removed = { + .array = ecs_vector_first(table->type, ecs_id_t), + .count = ecs_vector_count(table->type) + }; + + ecs_table_diff_t diff = { + .removed = removed, + .un_set = removed + }; + + flecs_notify_on_remove(world, table, NULL, 0, count, &diff); + } +} + +/* -- Private functions -- */ + +static +void ctor_component( + ecs_world_t *world, + ecs_type_info_t *ti, + ecs_column_t *column, + ecs_entity_t *entities, + int32_t row, + int32_t count) +{ + /* A new component is constructed */ + ecs_xtor_t ctor; + if (ti && (ctor = ti->lifecycle.ctor)) { + int16_t size = column->size; + int16_t alignment = column->alignment; + void *ptr = ecs_vector_get_t(column->data, size, alignment, row); + ctor(world, entities, ptr, count, ti); + } +} - ecs_iter_fini(it); +static +void on_remove_component( + ecs_world_t *world, + ecs_table_t *table, + ecs_iter_action_t on_remove, + void *ptr, + ecs_size_t size, + ecs_entity_t *entities, + ecs_id_t id, + int32_t count, + void *ctx) +{ + ecs_iter_t it = { .term_count = 1 }; + it.entities = entities; -error: - return false; + flecs_iter_init(&it); + it.world = world; + it.real_world = world; + it.table = table; + it.type = table->type; + it.ptrs[0] = ptr; + it.sizes[0] = size; + it.ids[0] = id; + it.event = EcsOnRemove; + it.event_id = id; + it.ctx = ctx; + it.count = count; + on_remove(&it); } -#endif +static +void dtor_component( + ecs_world_t *world, + ecs_table_t *table, + ecs_type_info_t *ti, + ecs_column_t *column, + ecs_entity_t *entities, + ecs_id_t id, + int32_t row, + int32_t count, + bool is_remove) +{ + if (!count) { + return; + } + if (!ti) { + return; + } -#ifdef FLECS_MODULE + ecs_iter_action_t on_remove = 0; + if (is_remove) { + on_remove = ti->lifecycle.on_remove; + } -#include + ecs_xtor_t dtor = ti->lifecycle.dtor; + if (!on_remove && !dtor) { + return; + } -char* ecs_module_path_from_c( - const char *c_name) -{ - ecs_strbuf_t str = ECS_STRBUF_INIT; - const char *ptr; - char ch; + void *ctx = ti->lifecycle.ctx; + int16_t size = column->size; + int16_t alignment = column->alignment; + ecs_entity_t *entity_elem = &entities[row]; - for (ptr = c_name; (ch = *ptr); ptr++) { - if (isupper(ch)) { - ch = flecs_ito(char, tolower(ch)); - if (ptr != c_name) { - ecs_strbuf_appendstrn(&str, ".", 1); - } - } + ecs_assert(column->data != NULL, ECS_INTERNAL_ERROR, NULL); + void *ptr = ecs_vector_get_t(column->data, size, alignment, row); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_strbuf_appendstrn(&str, &ch, 1); + if (on_remove) { + on_remove_component(world, table, on_remove, ptr, size, + entity_elem, id, count, ctx); } - return ecs_strbuf_get(&str); + if (dtor) { + dtor(world, entity_elem, ptr, count, ti); + } } -ecs_entity_t ecs_import( +static +void dtor_all_components( ecs_world_t *world, - ecs_module_action_t init_action, - const char *module_name) + ecs_table_t *table, + ecs_data_t *data, + int32_t row, + int32_t count, + bool update_entity_index, + bool is_delete) { - ecs_check(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); - - ecs_entity_t old_scope = ecs_set_scope(world, 0); - const char *old_name_prefix = world->name_prefix; - - char *path = ecs_module_path_from_c(module_name); - ecs_entity_t e = ecs_lookup_fullpath(world, path); - ecs_os_free(path); - - if (!e) { - ecs_trace("#[magenta]import#[reset] %s", module_name); - ecs_log_push(); + /* Can't delete and not update the entity index */ + ecs_assert(!is_delete || update_entity_index, ECS_INTERNAL_ERROR, NULL); - /* Load module */ - init_action(world); + ecs_id_t *ids = ecs_vector_first(table->storage_type, ecs_id_t); + ecs_record_t **records = ecs_vector_first(data->record_ptrs, ecs_record_t*); + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + int32_t i, c, end = row + count; + int32_t column_count = ecs_vector_count(table->storage_type); - /* Lookup module entity (must be registered by module) */ - e = ecs_lookup_fullpath(world, module_name); - ecs_check(e != 0, ECS_MODULE_UNDEFINED, module_name); + (void)records; - ecs_log_pop(); - } + /* If table has components with destructors, iterate component columns */ + if (table->flags & EcsTableHasDtors) { + /* Prevent the storage from getting modified while deleting */ + ecs_defer_begin(world); - /* Restore to previous state */ - ecs_set_scope(world, old_scope); - world->name_prefix = old_name_prefix; + /* Throw up a lock just to be sure */ + table->lock = true; - return e; -error: - return 0; -} + /* Run on_remove callbacks in bulk for improved performance */ + for (c = 0; c < column_count; c++) { + ecs_column_t *column = &data->columns[c]; + ecs_type_info_t *cdata = table->type_info[c]; + if (!cdata) { + continue; + } -ecs_entity_t ecs_import_from_library( - ecs_world_t *world, - const char *library_name, - const char *module_name) -{ - ecs_check(library_name != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_iter_action_t on_remove = cdata->lifecycle.on_remove; + if (on_remove) { + ecs_size_t size = column->size; + ecs_size_t align = column->alignment; + void *ptr = ecs_vector_get_t(column->data, size, align, row); + on_remove_component(world, table, on_remove, ptr, column->size, + &entities[row], ids[c], count, cdata->lifecycle.ctx); + } + } - char *import_func = (char*)module_name; /* safe */ - char *module = (char*)module_name; + /* Iterate entities first, then components. This ensures that only one + * entity is invalidated at a time, which ensures that destructors can + * safely access other entities. */ + for (i = row; i < end; i ++) { + for (c = 0; c < column_count; c++) { + ecs_column_t *column = &data->columns[c]; + dtor_component(world, table, table->type_info[c], column, + entities, ids[c], i, 1, false); + } - if (!ecs_os_has_modules() || !ecs_os_has_dl()) { - ecs_err( - "library loading not supported, set module_to_dl, dlopen, dlclose " - "and dlproc os API callbacks first"); - return 0; - } + /* Update entity index after invoking destructors so that entity can + * be safely used in destructor callbacks. */ + if (update_entity_index) { + ecs_entity_t e = entities[i]; + ecs_assert(!e || ecs_is_valid(world, e), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i] == ecs_eis_get(world, e), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i]->table == table, + ECS_INTERNAL_ERROR, NULL); - /* If no module name is specified, try default naming convention for loading - * the main module from the library */ - if (!import_func) { - import_func = ecs_os_malloc(ecs_os_strlen(library_name) + ECS_SIZEOF("Import")); - ecs_assert(import_func != NULL, ECS_OUT_OF_MEMORY, NULL); - - const char *ptr; - char ch, *bptr = import_func; - bool capitalize = true; - for (ptr = library_name; (ch = *ptr); ptr ++) { - if (ch == '.') { - capitalize = true; - } else { - if (capitalize) { - *bptr = flecs_ito(char, toupper(ch)); - bptr ++; - capitalize = false; + if (is_delete) { + ecs_eis_delete(world, e); + ecs_assert(ecs_is_valid(world, e) == false, + ECS_INTERNAL_ERROR, NULL); } else { - *bptr = flecs_ito(char, tolower(ch)); - bptr ++; + // If this is not a delete, clear the entity index record + records[i]->table = NULL; + records[i]->row = 0; } + } else { + /* This should only happen in rare cases, such as when the data + * cleaned up is not part of the world (like with snapshots) */ } } - *bptr = '\0'; + table->lock = false; + + ecs_defer_end(world); - module = ecs_os_strdup(import_func); - ecs_assert(module != NULL, ECS_OUT_OF_MEMORY, NULL); + /* If table does not have destructors, just update entity index */ + } else if (update_entity_index) { + if (is_delete) { + for (i = row; i < end; i ++) { + ecs_entity_t e = entities[i]; + ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i] == ecs_eis_get(world, e), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i]->table == table, + ECS_INTERNAL_ERROR, NULL); - ecs_os_strcat(bptr, "Import"); + ecs_eis_delete(world, e); + ecs_assert(!ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); + } + } else { + for (i = row; i < end; i ++) { + ecs_entity_t e = entities[i]; + ecs_assert(!e || ecs_is_valid(world, e), ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i] == ecs_eis_get(world, e), + ECS_INTERNAL_ERROR, NULL); + ecs_assert(!e || records[i]->table == table, + ECS_INTERNAL_ERROR, NULL); + records[i]->table = NULL; + records[i]->row = 0; + (void)e; + } + } } +} - char *library_filename = ecs_os_module_to_dl(library_name); - if (!library_filename) { - ecs_err("failed to find library file for '%s'", library_name); - if (module != module_name) { - ecs_os_free(module); - } - return 0; - } else { - ecs_trace("found file '%s' for library '%s'", - library_filename, library_name); - } +static +void fini_data( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + bool do_on_remove, + bool update_entity_index, + bool is_delete, + bool deactivate) +{ + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_os_dl_t dl = ecs_os_dlopen(library_filename); - if (!dl) { - ecs_err("failed to load library '%s' ('%s')", - library_name, library_filename); - - ecs_os_free(library_filename); + if (!data) { + return; + } - if (module != module_name) { - ecs_os_free(module); - } + ecs_flags32_t flags = table->flags; - return 0; - } else { - ecs_trace("library '%s' ('%s') loaded", - library_name, library_filename); + if (do_on_remove && (flags & EcsTableHasOnRemove)) { + run_on_remove(world, table, data); } - ecs_module_action_t action = (ecs_module_action_t) - ecs_os_dlproc(dl, import_func); - if (!action) { - ecs_err("failed to load import function %s from library %s", - import_func, library_name); - ecs_os_free(library_filename); - ecs_os_dlclose(dl); - return 0; - } else { - ecs_trace("found import function '%s' in library '%s' for module '%s'", - import_func, library_name, module); + int32_t count = flecs_table_data_count(data); + if (count) { + dtor_all_components(world, table, data, 0, count, + update_entity_index, is_delete); } - /* Do not free id, as it will be stored as the component identifier */ - ecs_entity_t result = ecs_import(world, action, module); + /* Sanity check */ + ecs_assert(ecs_vector_count(data->record_ptrs) == + ecs_vector_count(data->entities), ECS_INTERNAL_ERROR, NULL); - if (import_func != module_name) { - ecs_os_free(import_func); - } + ecs_column_t *columns = data->columns; + if (columns) { + int32_t c, column_count = ecs_vector_count(table->storage_type); + for (c = 0; c < column_count; c ++) { + /* Sanity check */ + ecs_assert(!columns[c].data || (ecs_vector_count(columns[c].data) == + ecs_vector_count(data->entities)), ECS_INTERNAL_ERROR, NULL); - if (module != module_name) { - ecs_os_free(module); + ecs_vector_free(columns[c].data); + } + ecs_os_free(columns); + data->columns = NULL; } - ecs_os_free(library_filename); - - return result; -error: - return 0; -} - -ecs_entity_t ecs_module_init( - ecs_world_t *world, - const ecs_component_desc_t *desc) -{ - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_poly_assert(world, ecs_world_t); + ecs_sw_column_t *sw_columns = data->sw_columns; + if (sw_columns) { + int32_t c, column_count = table->sw_column_count; + for (c = 0; c < column_count; c ++) { + flecs_switch_free(sw_columns[c].data); + } + ecs_os_free(sw_columns); + data->sw_columns = NULL; + } - const char *name = desc->entity.name; + ecs_bs_column_t *bs_columns = data->bs_columns; + if (bs_columns) { + int32_t c, column_count = table->bs_column_count; + for (c = 0; c < column_count; c ++) { + flecs_bitset_fini(&bs_columns[c].data); + } + ecs_os_free(bs_columns); + data->bs_columns = NULL; + } - char *module_path = ecs_module_path_from_c(name); - ecs_entity_t e = ecs_new_from_fullpath(world, module_path); - ecs_set_symbol(world, e, module_path); - ecs_os_free(module_path); + ecs_vector_free(data->entities); + ecs_vector_free(data->record_ptrs); - ecs_component_desc_t private_desc = *desc; - private_desc.entity.entity = e; - private_desc.entity.name = NULL; + data->entities = NULL; + data->record_ptrs = NULL; - if (desc->size) { - ecs_entity_t result = ecs_component_init(world, &private_desc); - ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL); - (void)result; - } else { - ecs_entity_t result = ecs_entity_init(world, &private_desc.entity); - ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL); - (void)result; + if (deactivate && count) { + flecs_table_set_empty(world, table); } - - return e; -error: - return 0; } -#endif - -#ifndef FLECS_META_PRIVATE_H -#define FLECS_META_PRIVATE_H - - -#ifdef FLECS_META - -void ecs_meta_type_serialized_init( - ecs_iter_t *it); - -void ecs_meta_dtor_serialized( - EcsMetaTypeSerialized *ptr); - - -bool flecs_unit_validate( +/* Cleanup, no OnRemove, don't update entity index, don't deactivate table */ +void flecs_table_clear_data( ecs_world_t *world, - ecs_entity_t t, - EcsUnit *data); - -#endif - -#endif - - -#ifdef FLECS_META + ecs_table_t *table, + ecs_data_t *data) +{ + fini_data(world, table, data, false, false, false, false); +} -ecs_entity_t ecs_primitive_init( +/* Cleanup, no OnRemove, clear entity index, deactivate table */ +void flecs_table_clear_entities_silent( ecs_world_t *world, - const ecs_primitive_desc_t *desc) + ecs_table_t *table) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; - } - - ecs_set(world, t, EcsPrimitive, { desc->kind }); - - return t; + fini_data(world, table, &table->storage, false, true, false, true); } -ecs_entity_t ecs_enum_init( +/* Cleanup, run OnRemove, clear entity index, deactivate table */ +void flecs_table_clear_entities( ecs_world_t *world, - const ecs_enum_desc_t *desc) + ecs_table_t *table) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; - } + fini_data(world, table, &table->storage, true, true, false, true); +} - ecs_add(world, t, EcsEnum); +/* Cleanup, run OnRemove, delete from entity index, deactivate table */ +void flecs_table_delete_entities( + ecs_world_t *world, + ecs_table_t *table) +{ + fini_data(world, table, &table->storage, true, true, true, true); +} - ecs_entity_t old_scope = ecs_set_scope(world, t); +/* Unset all components in table. This function is called before a table is + * deleted, and invokes all UnSet handlers, if any */ +void flecs_table_remove_actions( + ecs_world_t *world, + ecs_table_t *table) +{ + (void)world; + run_on_remove(world, table, &table->storage); +} - int i; - for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { - const ecs_enum_constant_t *m_desc = &desc->constants[i]; - if (!m_desc->name) { - break; - } +/* Free table resources. */ +void flecs_table_free( + ecs_world_t *world, + ecs_table_t *table) +{ + bool is_root = table == &world->store.root; + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); + ecs_assert(is_root || table->id != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(is_root || flecs_sparse_is_alive(&world->store.tables, table->id), + ECS_INTERNAL_ERROR, NULL); + (void)world; - ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = m_desc->name - }); + ecs_assert(table->refcount == 0, ECS_INTERNAL_ERROR, NULL); - if (!m_desc->value) { - ecs_add_id(world, c, EcsConstant); - } else { - ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, - {m_desc->value}); - } + if (!is_root) { + flecs_notify_queries( + world, &(ecs_query_event_t){ + .kind = EcsQueryTableUnmatch, + .table = table + }); } - ecs_set_scope(world, old_scope); - - if (i == 0) { - ecs_err("enum '%s' has no constants", ecs_get_name(world, t)); - ecs_delete(world, t); - return 0; + if (ecs_should_log_2()) { + char *expr = ecs_type_str(world, table->type); + ecs_dbg_2( + "#[green]table#[normal] [%s] #[red]deleted#[normal] with id %d", + expr, table->id); + ecs_os_free(expr); } - return t; -} + /* Cleanup data, no OnRemove, delete from entity index, don't deactivate */ + fini_data(world, table, &table->storage, false, true, true, false); -ecs_entity_t ecs_bitmask_init( - ecs_world_t *world, - const ecs_bitmask_desc_t *desc) -{ - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; - } + flecs_table_clear_edges(world, table); - ecs_add(world, t, EcsBitmask); + if (!is_root) { + ecs_ids_t ids = { + .array = ecs_vector_first(table->type, ecs_id_t), + .count = ecs_vector_count(table->type) + }; - ecs_entity_t old_scope = ecs_set_scope(world, t); + flecs_hashmap_remove(&world->store.table_map, &ids, ecs_table_t*); + } - int i; - for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { - const ecs_bitmask_constant_t *m_desc = &desc->constants[i]; - if (!m_desc->name) { - break; - } + ecs_os_free(table->dirty_state); + ecs_os_free(table->storage_map); - ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = m_desc->name - }); + flecs_table_records_unregister(world, table); - if (!m_desc->value) { - ecs_add_id(world, c, EcsConstant); - } else { - ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, - {m_desc->value}); + ecs_table_t *storage_table = table->storage_table; + if (storage_table == table) { + if (table->type_info) { + ecs_os_free(table->type_info); } + } else if (storage_table) { + flecs_table_release(world, storage_table); } - ecs_set_scope(world, old_scope); - - if (i == 0) { - ecs_err("bitmask '%s' has no constants", ecs_get_name(world, t)); - ecs_delete(world, t); - return 0; + if (!world->is_fini) { + ecs_assert(!is_root, ECS_INTERNAL_ERROR, NULL); + flecs_table_free_type(table); + flecs_sparse_remove(&world->store.tables, table->id); } +} - return t; +void flecs_table_claim( + ecs_world_t *world, + ecs_table_t *table) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table->refcount > 0, ECS_INTERNAL_ERROR, NULL); + table->refcount ++; + (void)world; } -ecs_entity_t ecs_array_init( +bool flecs_table_release( ecs_world_t *world, - const ecs_array_desc_t *desc) + ecs_table_t *table) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; + ecs_poly_assert(world, ecs_world_t); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table->refcount > 0, ECS_INTERNAL_ERROR, NULL); + + if (--table->refcount == 0) { + flecs_table_free(world, table); + return true; } + + return false; +} - ecs_set(world, t, EcsArray, { - .type = desc->type, - .count = desc->count - }); +/* Free table type. Do this separately from freeing the table as types can be + * in use by application destructors. */ +void flecs_table_free_type( + ecs_table_t *table) +{ + ecs_vector_free((ecs_vector_t*)table->type); +} - return t; +/* Reset a table to its initial state. */ +void flecs_table_reset( + ecs_world_t *world, + ecs_table_t *table) +{ + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); + flecs_table_clear_edges(world, table); } -ecs_entity_t ecs_vector_init( +static +void mark_table_dirty( ecs_world_t *world, - const ecs_vector_desc_t *desc) + ecs_table_t *table, + int32_t index) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; + (void)world; + if (table->dirty_state) { + table->dirty_state[index] ++; } +} - ecs_set(world, t, EcsVector, { - .type = desc->type - }); +void flecs_table_mark_dirty( + ecs_world_t *world, + ecs_table_t *table, + ecs_entity_t component) +{ + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - return t; + if (table->dirty_state) { + int32_t index = ecs_search(world, table->storage_table, component, 0); + ecs_assert(index != -1, ECS_INTERNAL_ERROR, NULL); + table->dirty_state[index + 1] ++; + } } -ecs_entity_t ecs_struct_init( - ecs_world_t *world, - const ecs_struct_desc_t *desc) +static +void move_switch_columns( + ecs_table_t *new_table, + ecs_data_t *new_data, + int32_t new_index, + ecs_table_t *old_table, + ecs_data_t *old_data, + int32_t old_index, + int32_t count, + bool clear) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; + int32_t i_old = 0, old_column_count = old_table->sw_column_count; + int32_t i_new = 0, new_column_count = new_table->sw_column_count; + + if (!old_column_count && !new_column_count) { + return; } - ecs_entity_t old_scope = ecs_set_scope(world, t); + ecs_sw_column_t *old_columns = old_data->sw_columns; + ecs_sw_column_t *new_columns = new_data->sw_columns; - int i; - for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { - const ecs_member_t *m_desc = &desc->members[i]; - if (!m_desc->type) { - break; - } + ecs_type_t new_type = new_table->type; + ecs_type_t old_type = old_table->type; - if (!m_desc->name) { - ecs_err("member %d of struct '%s' does not have a name", i, - ecs_get_name(world, t)); - ecs_delete(world, t); - return 0; - } + int32_t offset_new = new_table->sw_column_offset; + int32_t offset_old = old_table->sw_column_offset; - ecs_entity_t m = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = m_desc->name - }); + ecs_id_t *new_ids = ecs_vector_first(new_type, ecs_id_t); + ecs_id_t *old_ids = ecs_vector_first(old_type, ecs_id_t); - ecs_set(world, m, EcsMember, { - .type = m_desc->type, - .count = m_desc->count, - .unit = m_desc->unit - }); - } + for (; (i_new < new_column_count) && (i_old < old_column_count);) { + ecs_entity_t new_id = new_ids[i_new + offset_new]; + ecs_entity_t old_id = old_ids[i_old + offset_old]; - ecs_set_scope(world, old_scope); + if (new_id == old_id) { + ecs_switch_t *old_switch = old_columns[i_old].data; + ecs_switch_t *new_switch = new_columns[i_new].data; - if (i == 0) { - ecs_err("struct '%s' has no members", ecs_get_name(world, t)); - ecs_delete(world, t); - return 0; - } + flecs_switch_ensure(new_switch, new_index + count); - if (!ecs_has(world, t, EcsStruct)) { - /* Invalid members */ - ecs_delete(world, t); - return 0; + int i; + for (i = 0; i < count; i ++) { + uint64_t value = flecs_switch_get(old_switch, old_index + i); + flecs_switch_set(new_switch, new_index + i, value); + } + + if (clear) { + ecs_assert(count == flecs_switch_count(old_switch), + ECS_INTERNAL_ERROR, NULL); + flecs_switch_clear(old_switch); + } + } + + i_new += new_id <= old_id; + i_old += new_id >= old_id; } - return t; + /* Clear remaining columns */ + if (clear) { + for (; (i_old < old_column_count); i_old ++) { + ecs_switch_t *old_switch = old_columns[i_old].data; + ecs_assert(count == flecs_switch_count(old_switch), + ECS_INTERNAL_ERROR, NULL); + flecs_switch_clear(old_switch); + } + } } -ecs_entity_t ecs_unit_init( - ecs_world_t *world, - const ecs_unit_desc_t *desc) +static +void move_bitset_columns( + ecs_table_t *new_table, + ecs_data_t *new_data, + int32_t new_index, + ecs_table_t *old_table, + ecs_data_t *old_data, + int32_t old_index, + int32_t count, + bool clear) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - goto error; + int32_t i_old = 0, old_column_count = old_table->bs_column_count; + int32_t i_new = 0, new_column_count = new_table->bs_column_count; + + if (!old_column_count && !new_column_count) { + return; } - ecs_entity_t quantity = desc->quantity; - if (quantity) { - if (!ecs_has_id(world, quantity, EcsQuantity)) { - ecs_err("entity '%s' for unit '%s' is not a quantity", - ecs_get_name(world, quantity), ecs_get_name(world, t)); - goto error; - } + ecs_bs_column_t *old_columns = old_data->bs_columns; + ecs_bs_column_t *new_columns = new_data->bs_columns; - ecs_add_pair(world, t, EcsQuantity, desc->quantity); - } else { - ecs_remove_pair(world, t, EcsQuantity, EcsWildcard); - } + ecs_type_t new_type = new_table->type; + ecs_type_t old_type = old_table->type; - EcsUnit *value = ecs_get_mut(world, t, EcsUnit, 0); - value->base = desc->base; - value->over = desc->over; - value->translation = desc->translation; - value->prefix = desc->prefix; - ecs_os_strset(&value->symbol, desc->symbol); + int32_t offset_new = new_table->bs_column_offset; + int32_t offset_old = old_table->bs_column_offset; - if (!flecs_unit_validate(world, t, value)) { - goto error; - } + ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); + ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - ecs_modified(world, t, EcsUnit); + for (; (i_new < new_column_count) && (i_old < old_column_count);) { + ecs_entity_t new_component = new_components[i_new + offset_new]; + ecs_entity_t old_component = old_components[i_old + offset_old]; - return t; -error: - if (t) { - ecs_delete(world, t); + if (new_component == old_component) { + ecs_bitset_t *old_bs = &old_columns[i_old].data; + ecs_bitset_t *new_bs = &new_columns[i_new].data; + + flecs_bitset_ensure(new_bs, new_index + count); + + int i; + for (i = 0; i < count; i ++) { + uint64_t value = flecs_bitset_get(old_bs, old_index + i); + flecs_bitset_set(new_bs, new_index + i, value); + } + + if (clear) { + ecs_assert(count == flecs_bitset_count(old_bs), + ECS_INTERNAL_ERROR, NULL); + flecs_bitset_fini(old_bs); + } + } + + i_new += new_component <= old_component; + i_old += new_component >= old_component; + } + + /* Clear remaining columns */ + if (clear) { + for (; (i_old < old_column_count); i_old ++) { + ecs_bitset_t *old_bs = &old_columns[i_old].data; + ecs_assert(count == flecs_bitset_count(old_bs), + ECS_INTERNAL_ERROR, NULL); + flecs_bitset_fini(old_bs); + } } - return 0; } -ecs_entity_t ecs_unit_prefix_init( +static +void grow_column( ecs_world_t *world, - const ecs_unit_prefix_desc_t *desc) + ecs_entity_t *entities, + ecs_column_t *column, + ecs_type_info_t *ti, + int32_t to_add, + int32_t new_size, + bool construct) { - ecs_entity_t t = ecs_entity_init(world, &desc->entity); - if (!t) { - return 0; - } + ecs_vector_t *vec = column->data; + int16_t alignment = column->alignment; - ecs_set(world, t, EcsUnitPrefix, { - .symbol = (char*)desc->symbol, - .translation = desc->translation - }); + int32_t size = column->size; + int32_t count = ecs_vector_count(vec); + int32_t old_size = ecs_vector_size(vec); + int32_t new_count = count + to_add; + bool can_realloc = new_size != old_size; - return t; -} + ecs_assert(new_size >= new_count, ECS_INTERNAL_ERROR, NULL); -ecs_entity_t ecs_quantity_init( - ecs_world_t *world, - const ecs_entity_desc_t *desc) -{ - ecs_entity_t t = ecs_entity_init(world, desc); - if (!t) { - return 0; - } + /* If the array could possibly realloc and the component has a move action + * defined, move old elements manually */ + ecs_move_t move_ctor; + if (ti && count && can_realloc && + (move_ctor = ti->lifecycle.move_ctor)) + { + ecs_xtor_t ctor = ti->lifecycle.ctor; + ecs_assert(ctor != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(move_ctor != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_add_id(world, t, EcsQuantity); + /* Create new vector */ + ecs_vector_t *new_vec = ecs_vector_new_t(size, alignment, new_size); + ecs_vector_set_count_t(&new_vec, size, alignment, new_count); - return t; -} + void *old_buffer = ecs_vector_first_t(vec, size, alignment); + void *new_buffer = ecs_vector_first_t(new_vec, size, alignment); -#endif + /* Move (and construct) existing elements to new vector */ + move_ctor(world, entities, entities, new_buffer, old_buffer, count, ti); + if (construct) { + /* Construct new element(s) */ + void *elem = ECS_OFFSET(new_buffer, size * count); + ctor(world, &entities[count], elem, to_add, ti); + } -#ifdef FLECS_META + /* Free old vector */ + ecs_vector_free(vec); -static -ecs_vector_t* serialize_type( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops); + column->data = new_vec; + } else { + /* If array won't realloc or has no move, simply add new elements */ + if (can_realloc) { + ecs_vector_set_size_t(&vec, size, alignment, new_size); + } -static -ecs_meta_type_op_kind_t primitive_to_op_kind(ecs_primitive_kind_t kind) { - return EcsOpPrimitive + kind; -} + void *elem = ecs_vector_addn_t(&vec, size, alignment, to_add); -static -ecs_size_t type_size(ecs_world_t *world, ecs_entity_t type) { - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); - return comp->size; -} + ecs_xtor_t ctor; + if (construct && ti && (ctor = ti->lifecycle.ctor)) { + /* If new elements need to be constructed and component has a + * constructor, construct */ + ctor(world, &entities[count], elem, to_add, ti); + } -static -ecs_meta_type_op_t* ops_add(ecs_vector_t **ops, ecs_meta_type_op_kind_t kind) { - ecs_meta_type_op_t *op = ecs_vector_add(ops, ecs_meta_type_op_t); - op->kind = kind; - op->offset = 0; - op->count = 1; - op->op_count = 1; - op->size = 0; - op->name = NULL; - op->members = NULL; - op->type = 0; - op->unit = 0; - return op; -} + column->data = vec; + } -static -ecs_meta_type_op_t* ops_get(ecs_vector_t *ops, int32_t index) { - ecs_meta_type_op_t* op = ecs_vector_get(ops, ecs_meta_type_op_t, index); - ecs_assert(op != NULL, ECS_INTERNAL_ERROR, NULL); - return op; + ecs_assert(ecs_vector_size(column->data) == new_size, + ECS_INTERNAL_ERROR, NULL); } static -ecs_vector_t* serialize_primitive( +int32_t grow_data( ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) + ecs_table_t *table, + ecs_data_t *data, + int32_t to_add, + int32_t size, + const ecs_entity_t *ids) { - const EcsPrimitive *ptr = ecs_get(world, type, EcsPrimitive); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_meta_type_op_t *op = ops_add(&ops, primitive_to_op_kind(ptr->kind)); - op->offset = offset, - op->type = type; - op->size = type_size(world, type); + int32_t cur_count = flecs_table_data_count(data); + int32_t column_count = ecs_vector_count(table->storage_type); + int32_t sw_column_count = table->sw_column_count; + int32_t bs_column_count = table->bs_column_count; + ecs_column_t *columns = data->columns; + ecs_sw_column_t *sw_columns = data->sw_columns; + ecs_bs_column_t *bs_columns = data->bs_columns; - return ops; -} + /* Add record to record ptr array */ + ecs_vector_set_size(&data->record_ptrs, ecs_record_t*, size); + ecs_record_t **r = ecs_vector_addn(&data->record_ptrs, ecs_record_t*, to_add); + ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); + if (ecs_vector_size(data->record_ptrs) > size) { + size = ecs_vector_size(data->record_ptrs); + } -static -ecs_vector_t* serialize_enum( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) -{ - (void)world; - - ecs_meta_type_op_t *op = ops_add(&ops, EcsOpEnum); - op->offset = offset, - op->type = type; - op->size = ECS_SIZEOF(ecs_i32_t); + /* Add entity to column with entity ids */ + ecs_vector_set_size(&data->entities, ecs_entity_t, size); + ecs_entity_t *e = ecs_vector_addn(&data->entities, ecs_entity_t, to_add); + ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ecs_vector_size(data->entities) == size, ECS_INTERNAL_ERROR, NULL); - return ops; -} + /* Initialize entity ids and record ptrs */ + int32_t i; + if (ids) { + for (i = 0; i < to_add; i ++) { + e[i] = ids[i]; + } + } else { + ecs_os_memset(e, 0, ECS_SIZEOF(ecs_entity_t) * to_add); + } + ecs_os_memset(r, 0, ECS_SIZEOF(ecs_record_t*) * to_add); -static -ecs_vector_t* serialize_bitmask( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) -{ - (void)world; - - ecs_meta_type_op_t *op = ops_add(&ops, EcsOpBitmask); - op->offset = offset, - op->type = type; - op->size = ECS_SIZEOF(ecs_u32_t); + /* Add elements to each column array */ + ecs_type_info_t **c_info_array = table->type_info; + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + ecs_assert(column->size != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_type_info_t *c_info = NULL; + if (c_info_array) { + c_info = c_info_array[i]; + } - return ops; -} + grow_column(world, entities, column, c_info, to_add, size, true); + ecs_assert(ecs_vector_size(columns[i].data) == size, + ECS_INTERNAL_ERROR, NULL); + } -static -ecs_vector_t* serialize_array( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) -{ - (void)world; + /* Add elements to each switch column */ + for (i = 0; i < sw_column_count; i ++) { + ecs_switch_t *sw = sw_columns[i].data; + flecs_switch_addn(sw, to_add); + } - ecs_meta_type_op_t *op = ops_add(&ops, EcsOpArray); - op->offset = offset; - op->type = type; - op->size = type_size(world, type); + /* Add elements to each bitset column */ + for (i = 0; i < bs_column_count; i ++) { + ecs_bitset_t *bs = &bs_columns[i].data; + flecs_bitset_addn(bs, to_add); + } - return ops; -} + /* If the table is monitored indicate that there has been a change */ + mark_table_dirty(world, table, 0); -static -ecs_vector_t* serialize_array_component( - ecs_world_t *world, - ecs_entity_t type) -{ - const EcsArray *ptr = ecs_get(world, type, EcsArray); - if (!ptr) { - return NULL; /* Should never happen, will trigger internal error */ + if (!world->is_readonly && !cur_count) { + flecs_table_set_empty(world, table); } - ecs_vector_t *ops = serialize_type(world, ptr->type, 0, NULL); - ecs_assert(ops != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_meta_type_op_t *first = ecs_vector_first(ops, ecs_meta_type_op_t); - first->count = ptr->count; + table->alloc_count ++; - return ops; + /* Return index of first added entity */ + return cur_count; } static -ecs_vector_t* serialize_vector( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) +void fast_append( + ecs_column_t *columns, + int32_t column_count) { - (void)world; - - ecs_meta_type_op_t *op = ops_add(&ops, EcsOpVector); - op->offset = offset; - op->type = type; - op->size = type_size(world, type); - - return ops; + /* Add elements to each column array */ + int32_t i; + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + int16_t size = column->size; + if (size) { + int16_t alignment = column->alignment; + ecs_vector_add_t(&column->data, size, alignment); + } + } } -static -ecs_vector_t* serialize_struct( +int32_t flecs_table_append( ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) + ecs_table_t *table, + ecs_data_t *data, + ecs_entity_t entity, + ecs_record_t *record, + bool construct) { - const EcsStruct *ptr = ecs_get(world, type, EcsStruct); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - - int32_t cur, first = ecs_vector_count(ops); - ecs_meta_type_op_t *op = ops_add(&ops, EcsOpPush); - op->offset = offset; - op->type = type; - op->size = type_size(world, type); - - ecs_member_t *members = ecs_vector_first(ptr->members, ecs_member_t); - int32_t i, count = ecs_vector_count(ptr->members); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_hashmap_t *member_index = NULL; - if (count) { - op->members = member_index = flecs_name_index_new(); - } + check_table_sanity(table); - for (i = 0; i < count; i ++) { - ecs_member_t *member = &members[i]; + /* Get count & size before growing entities array. This tells us whether the + * arrays will realloc */ + int32_t count = ecs_vector_count(data->entities); + int32_t size = ecs_vector_size(data->entities); + int32_t column_count = ecs_vector_count(table->storage_type); + ecs_column_t *columns = table->storage.columns; + + /* Grow buffer with entity ids, set new element to new entity */ + ecs_entity_t *e = ecs_vector_add(&data->entities, ecs_entity_t); + ecs_assert(e != NULL, ECS_INTERNAL_ERROR, NULL); + *e = entity; - cur = ecs_vector_count(ops); - ops = serialize_type(world, member->type, offset + member->offset, ops); + /* Keep track of alloc count. This allows references to check if cached + * pointers need to be updated. */ + table->alloc_count += (count == size); - op = ops_get(ops, cur); - if (!op->type) { - op->type = member->type; - } + /* Add record ptr to array with record ptrs */ + ecs_record_t **r = ecs_vector_add(&data->record_ptrs, ecs_record_t*); + ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); + *r = record; + + /* If the table is monitored indicate that there has been a change */ + mark_table_dirty(world, table, 0); + ecs_assert(count >= 0, ECS_INTERNAL_ERROR, NULL); - if (op->count <= 1) { - op->count = member->count; + /* Fast path: no switch columns, no lifecycle actions */ + if (!(table->flags & EcsTableIsComplex)) { + fast_append(columns, column_count); + if (!count) { + flecs_table_set_empty(world, table); /* See below */ } - - const char *member_name = member->name; - op->name = member_name; - op->unit = member->unit; - op->op_count = ecs_vector_count(ops) - cur; - - flecs_name_index_ensure( - member_index, flecs_ito(uint64_t, cur - first - 1), - member_name, 0, 0); + return count; } - ops_add(&ops, EcsOpPop); - ops_get(ops, first)->op_count = ecs_vector_count(ops) - first; - - return ops; -} + int32_t sw_column_count = table->sw_column_count; + int32_t bs_column_count = table->bs_column_count; + ecs_sw_column_t *sw_columns = table->storage.sw_columns; + ecs_bs_column_t *bs_columns = table->storage.bs_columns; -static -ecs_vector_t* serialize_type( - ecs_world_t *world, - ecs_entity_t type, - ecs_size_t offset, - ecs_vector_t *ops) -{ - const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType); - if (!ptr) { - char *path = ecs_get_fullpath(world, type); - ecs_err("missing EcsMetaType for type %s'", path); - ecs_os_free(path); - return NULL; - } + ecs_type_info_t **c_info_array = table->type_info; + ecs_entity_t *entities = ecs_vector_first( + data->entities, ecs_entity_t); - switch(ptr->kind) { - case EcsPrimitiveType: - ops = serialize_primitive(world, type, offset, ops); - break; + /* Reobtain size to ensure that the columns have the same size as the + * entities and record vectors. This keeps reasoning about when allocations + * occur easier. */ + size = ecs_vector_size(data->entities); - case EcsEnumType: - ops = serialize_enum(world, type, offset, ops); - break; + /* Grow component arrays with 1 element */ + int32_t i; + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + ecs_assert(column->size != 0, ECS_INTERNAL_ERROR, NULL); - case EcsBitmaskType: - ops = serialize_bitmask(world, type, offset, ops); - break; + ecs_type_info_t *c_info = NULL; + if (c_info_array) { + c_info = c_info_array[i]; + } + + grow_column(world, entities, column, c_info, 1, size, construct); + + ecs_assert( + ecs_vector_size(columns[i].data) == ecs_vector_size(data->entities), + ECS_INTERNAL_ERROR, NULL); + + ecs_assert( + ecs_vector_count(columns[i].data) == ecs_vector_count(data->entities), + ECS_INTERNAL_ERROR, NULL); + } - case EcsStructType: - ops = serialize_struct(world, type, offset, ops); - break; + /* Add element to each switch column */ + for (i = 0; i < sw_column_count; i ++) { + ecs_assert(sw_columns != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_switch_t *sw = sw_columns[i].data; + flecs_switch_add(sw); + } - case EcsArrayType: - ops = serialize_array(world, type, offset, ops); - break; + /* Add element to each bitset column */ + for (i = 0; i < bs_column_count; i ++) { + ecs_assert(bs_columns != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_bitset_t *bs = &bs_columns[i].data; + flecs_bitset_addn(bs, 1); + } - case EcsVectorType: - ops = serialize_vector(world, type, offset, ops); - break; + /* If this is the first entity in this table, signal queries so that the + * table moves from an inactive table to an active table. */ + if (!count) { + flecs_table_set_empty(world, table); } - return ops; + check_table_sanity(table); + + return count; } static -ecs_vector_t* serialize_component( - ecs_world_t *world, - ecs_entity_t type) +void fast_delete_last( + ecs_column_t *columns, + int32_t column_count) { - const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType); - if (!ptr) { - char *path = ecs_get_fullpath(world, type); - ecs_err("missing EcsMetaType for type %s'", path); - ecs_os_free(path); - return NULL; + int i; + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + ecs_vector_remove_last(column->data); } +} - ecs_vector_t *ops = NULL; +static +void fast_delete( + ecs_column_t *columns, + int32_t column_count, + int32_t index) +{ + int i; + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + int16_t size = column->size; + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); - switch(ptr->kind) { - case EcsArrayType: - ops = serialize_array_component(world, type); - break; - default: - ops = serialize_type(world, type, 0, NULL); - break; + int16_t alignment = column->alignment; + ecs_vector_remove_t(column->data, size, alignment, index); } - - return ops; } -void ecs_meta_type_serialized_init( - ecs_iter_t *it) +void flecs_table_delete( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + int32_t index, + bool destruct) { - ecs_world_t *world = it->world; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_vector_t *ops = serialize_component(world, e); - ecs_assert(ops != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - EcsMetaTypeSerialized *ptr = ecs_get_mut( - world, e, EcsMetaTypeSerialized, NULL); - if (ptr->ops) { - ecs_meta_dtor_serialized(ptr); - } + check_table_sanity(table); - ptr->ops = ops; - } -} + ecs_vector_t *v_entities = data->entities; + int32_t count = ecs_vector_count(v_entities); -#endif + ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL); + count --; + ecs_assert(index <= count, ECS_INTERNAL_ERROR, NULL); + /* Move last entity id to index */ + ecs_entity_t *entities = ecs_vector_first(v_entities, ecs_entity_t); + ecs_entity_t entity_to_move = entities[count]; + ecs_entity_t entity_to_delete = entities[index]; + entities[index] = entity_to_move; + ecs_vector_remove_last(v_entities); -#ifdef FLECS_META + /* Move last record ptr to index */ + ecs_vector_t *v_records = data->record_ptrs; + ecs_assert(count < ecs_vector_count(v_records), ECS_INTERNAL_ERROR, NULL); -/* EcsMetaTypeSerialized lifecycle */ + ecs_record_t **records = ecs_vector_first(v_records, ecs_record_t*); + ecs_record_t *record_to_move = records[count]; + records[index] = record_to_move; + ecs_vector_remove_last(v_records); -void ecs_meta_dtor_serialized( - EcsMetaTypeSerialized *ptr) -{ - int32_t i, count = ecs_vector_count(ptr->ops); - ecs_meta_type_op_t *ops = ecs_vector_first(ptr->ops, ecs_meta_type_op_t); - - for (i = 0; i < count; i ++) { - ecs_meta_type_op_t *op = &ops[i]; - if (op->members) { - flecs_hashmap_fini(op->members); - ecs_os_free(op->members); + /* Update record of moved entity in entity index */ + if (index != count) { + if (record_to_move) { + uint32_t row_flags = record_to_move->row & ECS_ROW_FLAGS_MASK; + record_to_move->row = ECS_ROW_TO_RECORD(index, row_flags); + ecs_assert(record_to_move->table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(record_to_move->table == table, ECS_INTERNAL_ERROR, NULL); } - } - - ecs_vector_free(ptr->ops); -} - -static ECS_COPY(EcsMetaTypeSerialized, dst, src, { - ecs_meta_dtor_serialized(dst); + } - dst->ops = ecs_vector_copy(src->ops, ecs_meta_type_op_t); + /* If the table is monitored indicate that there has been a change */ + mark_table_dirty(world, table, 0); - int32_t o, count = ecs_vector_count(src->ops); - ecs_meta_type_op_t *ops = ecs_vector_first(src->ops, ecs_meta_type_op_t); - - for (o = 0; o < count; o ++) { - ecs_meta_type_op_t *op = &ops[o]; - if (op->members) { - op->members = ecs_os_memdup_t(op->members, ecs_hashmap_t); - flecs_hashmap_copy(op->members, op->members); - } + /* If table is empty, deactivate it */ + if (!count) { + flecs_table_set_empty(world, table); } -}) - -static ECS_MOVE(EcsMetaTypeSerialized, dst, src, { - ecs_meta_dtor_serialized(dst); - dst->ops = src->ops; - src->ops = NULL; -}) -static ECS_DTOR(EcsMetaTypeSerialized, ptr, { - ecs_meta_dtor_serialized(ptr); -}) + /* Destruct component data */ + ecs_type_info_t **c_info_array = table->type_info; + ecs_column_t *columns = data->columns; + int32_t column_count = ecs_vector_count(table->storage_type); + int32_t i; + /* If this is a table without lifecycle callbacks or special columns, take + * fast path that just remove an element from the array(s) */ + if (!(table->flags & EcsTableIsComplex)) { + if (index == count) { + fast_delete_last(columns, column_count); + } else { + fast_delete(columns, column_count, index); + } -/* EcsStruct lifecycle */ + check_table_sanity(table); -static void dtor_struct( - EcsStruct *ptr) -{ - ecs_member_t *members = ecs_vector_first(ptr->members, ecs_member_t); - int32_t i, count = ecs_vector_count(ptr->members); - for (i = 0; i < count; i ++) { - ecs_os_free((char*)members[i].name); + return; } - ecs_vector_free(ptr->members); -} -static ECS_COPY(EcsStruct, dst, src, { - dtor_struct(dst); + ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - dst->members = ecs_vector_copy(src->members, ecs_member_t); + /* Last element, destruct & remove */ + if (index == count) { + /* If table has component destructors, invoke */ + if (destruct && (table->flags & EcsTableHasDtors)) { + ecs_assert(c_info_array != NULL, ECS_INTERNAL_ERROR, NULL); + + for (i = 0; i < column_count; i ++) { + ecs_type_info_t *ti = c_info_array[i]; + if (!ti) { + continue; + } - ecs_member_t *members = ecs_vector_first(dst->members, ecs_member_t); - int32_t m, count = ecs_vector_count(dst->members); + dtor_component(world, table, ti, &columns[i], + entities, ids[i], index, 1, true); + } + } - for (m = 0; m < count; m ++) { - members[m].name = ecs_os_strdup(members[m].name); - } -}) + fast_delete_last(columns, column_count); -static ECS_MOVE(EcsStruct, dst, src, { - dtor_struct(dst); - dst->members = src->members; - src->members = NULL; -}) + /* Not last element, move last element to deleted element & destruct */ + } else { + /* If table has component destructors, invoke */ + if (destruct && (table->flags & (EcsTableHasDtors | EcsTableHasMove))) { + ecs_assert(c_info_array != NULL, ECS_INTERNAL_ERROR, NULL); -static ECS_DTOR(EcsStruct, ptr, { dtor_struct(ptr); }) + for (i = 0; i < column_count; i ++) { + ecs_column_t *column = &columns[i]; + ecs_size_t size = column->size; + ecs_size_t align = column->alignment; + ecs_vector_t *vec = column->data; + void *dst = ecs_vector_get_t(vec, size, align, index); + void *src = ecs_vector_last_t(vec, size, align); + + ecs_type_info_t *ti = c_info_array[i]; + ecs_iter_action_t on_remove; + if (ti && (on_remove = ti->lifecycle.on_remove)) { + on_remove_component(world, table, on_remove, dst, + size, &entity_to_delete, ids[i], 1, + ti->lifecycle.ctx); + } -/* EcsEnum lifecycle */ + ecs_move_t move_dtor; + if (ti && (move_dtor = ti->lifecycle.move_dtor)) { + move_dtor(world, &entity_to_move, + &entity_to_delete, dst, src, 1, ti); + } else { + ecs_os_memcpy(dst, src, size); + } -static void dtor_enum( - EcsEnum *ptr) -{ - ecs_map_iter_t it = ecs_map_iter(ptr->constants); - ecs_enum_constant_t *c; - while ((c = ecs_map_next(&it, ecs_enum_constant_t, NULL))) { - ecs_os_free((char*)c->name); + ecs_vector_remove_last(vec); + } + } else { + fast_delete(columns, column_count, index); + } } - ecs_map_free(ptr->constants); -} - -static ECS_COPY(EcsEnum, dst, src, { - dtor_enum(dst); - - dst->constants = ecs_map_copy(src->constants); - ecs_assert(ecs_map_count(dst->constants) == ecs_map_count(src->constants), - ECS_INTERNAL_ERROR, NULL); - ecs_map_iter_t it = ecs_map_iter(dst->constants); - ecs_enum_constant_t *c; - while ((c = ecs_map_next(&it, ecs_enum_constant_t, NULL))) { - c->name = ecs_os_strdup(c->name); + /* Remove elements from switch columns */ + ecs_sw_column_t *sw_columns = data->sw_columns; + int32_t sw_column_count = table->sw_column_count; + for (i = 0; i < sw_column_count; i ++) { + flecs_switch_remove(sw_columns[i].data, index); } -}) - -static ECS_MOVE(EcsEnum, dst, src, { - dtor_enum(dst); - dst->constants = src->constants; - src->constants = NULL; -}) - -static ECS_DTOR(EcsEnum, ptr, { dtor_enum(ptr); }) + /* Remove elements from bitset columns */ + ecs_bs_column_t *bs_columns = data->bs_columns; + int32_t bs_column_count = table->bs_column_count; + for (i = 0; i < bs_column_count; i ++) { + flecs_bitset_remove(&bs_columns[i].data, index); + } -/* EcsBitmask lifecycle */ + check_table_sanity(table); +} -static void dtor_bitmask( - EcsBitmask *ptr) +static +void fast_move( + ecs_table_t *new_table, + ecs_data_t *new_data, + int32_t new_index, + ecs_table_t *old_table, + ecs_data_t *old_data, + int32_t old_index) { - ecs_map_iter_t it = ecs_map_iter(ptr->constants); - ecs_bitmask_constant_t *c; - while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, NULL))) { - ecs_os_free((char*)c->name); - } - ecs_map_free(ptr->constants); -} + ecs_type_t new_type = new_table->storage_type; + ecs_type_t old_type = old_table->storage_type; -static ECS_COPY(EcsBitmask, dst, src, { - dtor_bitmask(dst); + int32_t i_new = 0, new_column_count = ecs_vector_count(new_table->storage_type); + int32_t i_old = 0, old_column_count = ecs_vector_count(old_table->storage_type); + ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); + ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - dst->constants = ecs_map_copy(src->constants); - ecs_assert(ecs_map_count(dst->constants) == ecs_map_count(src->constants), - ECS_INTERNAL_ERROR, NULL); + ecs_column_t *old_columns = old_data->columns; + ecs_column_t *new_columns = new_data->columns; - ecs_map_iter_t it = ecs_map_iter(dst->constants); - ecs_bitmask_constant_t *c; - while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, NULL))) { - c->name = ecs_os_strdup(c->name); - } -}) -static ECS_MOVE(EcsBitmask, dst, src, { - dtor_bitmask(dst); - dst->constants = src->constants; - src->constants = NULL; -}) + for (; (i_new < new_column_count) && (i_old < old_column_count);) { + ecs_entity_t new_component = new_components[i_new]; + ecs_entity_t old_component = old_components[i_old]; -static ECS_DTOR(EcsBitmask, ptr, { dtor_bitmask(ptr); }) + if (new_component == old_component) { + ecs_column_t *new_column = &new_columns[i_new]; + ecs_column_t *old_column = &old_columns[i_old]; + int16_t size = new_column->size; + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); + int16_t alignment = new_column->alignment; + void *dst = ecs_vector_get_t( + new_column->data, size, alignment, new_index); + void *src = ecs_vector_get_t( + old_column->data, size, alignment, old_index); -/* EcsUnit lifecycle */ + ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(src != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_os_memcpy(dst, src, size); + } -static void dtor_unit( - EcsUnit *ptr) -{ - ecs_os_free(ptr->symbol); + i_new += new_component <= old_component; + i_old += new_component >= old_component; + } } -static ECS_COPY(EcsUnit, dst, src, { - dtor_unit(dst); - dst->symbol = ecs_os_strdup(src->symbol); - dst->base = src->base; - dst->over = src->over; - dst->prefix = src->prefix; - dst->translation = src->translation; -}) +void flecs_table_move( + ecs_world_t *world, + ecs_entity_t dst_entity, + ecs_entity_t src_entity, + ecs_table_t *new_table, + ecs_data_t *new_data, + int32_t new_index, + ecs_table_t *old_table, + ecs_data_t *old_data, + int32_t old_index, + bool construct) +{ + ecs_assert(new_table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(old_table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!new_table->lock, ECS_LOCKED_STORAGE, NULL); + ecs_assert(!old_table->lock, ECS_LOCKED_STORAGE, NULL); -static ECS_MOVE(EcsUnit, dst, src, { - dtor_unit(dst); - dst->symbol = src->symbol; - dst->base = src->base; - dst->over = src->over; - dst->prefix = src->prefix; - dst->translation = src->translation; + ecs_assert(old_index >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(new_index >= 0, ECS_INTERNAL_ERROR, NULL); - src->symbol = NULL; - src->base = 0; - src->over = 0; - src->prefix = 0; - src->translation = (ecs_unit_translation_t){0}; -}) + ecs_assert(old_data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(new_data != NULL, ECS_INTERNAL_ERROR, NULL); -static ECS_DTOR(EcsUnit, ptr, { dtor_unit(ptr); }) + check_table_sanity(new_table); + check_table_sanity(old_table); + if (!((new_table->flags | old_table->flags) & EcsTableIsComplex)) { + fast_move(new_table, new_data, new_index, old_table, old_data, + old_index); + check_table_sanity(new_table); + check_table_sanity(old_table); + return; + } -/* EcsUnitPrefix lifecycle */ + move_switch_columns(new_table, new_data, new_index, old_table, old_data, + old_index, 1, false); + move_bitset_columns(new_table, new_data, new_index, old_table, old_data, + old_index, 1, false); -static void dtor_unit_prefix( - EcsUnitPrefix *ptr) -{ - ecs_os_free(ptr->symbol); -} + bool same_entity = dst_entity == src_entity; -static ECS_COPY(EcsUnitPrefix, dst, src, { - dtor_unit_prefix(dst); - dst->symbol = ecs_os_strdup(src->symbol); - dst->translation = src->translation; -}) + ecs_type_t new_type = new_table->storage_type; + ecs_type_t old_type = old_table->storage_type; -static ECS_MOVE(EcsUnitPrefix, dst, src, { - dtor_unit_prefix(dst); - dst->symbol = src->symbol; - dst->translation = src->translation; + int32_t i_new = 0, new_column_count = ecs_vector_count(new_table->storage_type); + int32_t i_old = 0, old_column_count = ecs_vector_count(old_table->storage_type); + ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); + ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - src->symbol = NULL; - src->translation = (ecs_unit_translation_t){0}; -}) + ecs_column_t *old_columns = old_data->columns; + ecs_column_t *new_columns = new_data->columns; -static ECS_DTOR(EcsUnitPrefix, ptr, { dtor_unit_prefix(ptr); }) + for (; (i_new < new_column_count) && (i_old < old_column_count);) { + ecs_entity_t new_component = new_components[i_new]; + ecs_entity_t old_component = old_components[i_old]; + if (new_component == old_component) { + ecs_column_t *new_column = &new_columns[i_new]; + ecs_column_t *old_column = &old_columns[i_old]; + int16_t size = new_column->size; + int16_t alignment = new_column->alignment; -/* Type initialization */ + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); -static -int init_type( - ecs_world_t *world, - ecs_entity_t type, - ecs_type_kind_t kind, - ecs_size_t size, - ecs_size_t alignment) -{ - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL); + void *dst = ecs_vector_get_t( + new_column->data, size, alignment, new_index); + void *src = ecs_vector_get_t( + old_column->data, size, alignment, old_index); - bool is_added = false; - EcsMetaType *meta_type = ecs_get_mut(world, type, EcsMetaType, &is_added); - if (is_added) { - meta_type->existing = ecs_has(world, type, EcsComponent); + ecs_assert(dst != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(src != NULL, ECS_INTERNAL_ERROR, NULL); - /* Ensure that component has a default constructor, to prevent crashing - * serializers on uninitialized values. */ - ecs_type_info_t *ti = flecs_ensure_type_info(world, type); - if (!ti->lifecycle.ctor) { - ti->lifecycle.ctor = ecs_default_ctor; - } - } else { - if (meta_type->kind != kind) { - ecs_err("type '%s' reregistered with different kind", - ecs_get_name(world, type)); - return -1; + ecs_type_info_t *ti = new_table->type_info[i_new]; + if (same_entity) { + ecs_move_t callback; + if (ti && (callback = ti->lifecycle.ctor_move_dtor)) { + /* ctor + move + dtor */ + callback(world, &dst_entity, &src_entity, dst, src, 1, ti); + } else { + ecs_os_memcpy(dst, src, size); + } + } else { + ecs_copy_t copy; + if (ti && (copy = ti->lifecycle.copy_ctor)) { + copy(world, &dst_entity, &src_entity, dst, src, 1, ti); + } else { + ecs_os_memcpy(dst, src, size); + } + } + } else { + if (new_component < old_component) { + if (construct) { + ctor_component(world, new_table->type_info[i_new], + &new_columns[i_new], &dst_entity, new_index, 1); + } + } else { + dtor_component(world, old_table, old_table->type_info[i_old], + &old_columns[i_old], &src_entity, old_component, + old_index, 1, true); + } } + + i_new += new_component <= old_component; + i_old += new_component >= old_component; } - if (!meta_type->existing) { - EcsComponent *comp = ecs_get_mut(world, type, EcsComponent, NULL); - comp->size = size; - comp->alignment = alignment; - ecs_modified(world, type, EcsComponent); - } else { - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - if (comp->size < size) { - ecs_err("computed size for '%s' is larger than actual type", - ecs_get_name(world, type)); - return -1; - } - if (comp->alignment < alignment) { - ecs_err("computed alignment for '%s' is larger than actual type", - ecs_get_name(world, type)); - return -1; - } - if (comp->size == size && comp->alignment != alignment) { - ecs_err("computed size for '%s' matches with actual type but " - "alignment is different", ecs_get_name(world, type)); - return -1; + if (construct) { + for (; (i_new < new_column_count); i_new ++) { + ctor_component(world, new_table->type_info[i_new], + &new_columns[i_new], &dst_entity, new_index, 1); } - - meta_type->partial = comp->size != size; } - meta_type->kind = kind; - meta_type->size = size; - meta_type->alignment = alignment; - ecs_modified(world, type, EcsMetaType); + for (; (i_old < old_column_count); i_old ++) { + dtor_component(world, old_table, old_table->type_info[i_old], + &old_columns[i_old], &src_entity, old_components[i_old], + old_index, 1, true); + } - return 0; + check_table_sanity(new_table); + check_table_sanity(old_table); } -#define init_type_t(world, type, kind, T) \ - init_type(world, type, kind, ECS_SIZEOF(T), ECS_ALIGNOF(T)) - -static -void set_struct_member( - ecs_member_t *member, - ecs_entity_t entity, - const char *name, - ecs_entity_t type, - int32_t count, - ecs_entity_t unit) +int32_t flecs_table_appendn( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + int32_t to_add, + const ecs_entity_t *ids) { - member->member = entity; - member->type = type; - member->count = count; - member->unit = unit; + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - if (!count) { - member->count = 1; - } + check_table_sanity(table); - ecs_os_strset((char**)&member->name, name); + int32_t cur_count = flecs_table_data_count(data); + int32_t result = grow_data( + world, table, data, to_add, cur_count + to_add, ids); + check_table_sanity(table); + return result; } -static -int add_member_to_struct( +void flecs_table_set_size( ecs_world_t *world, - ecs_entity_t type, - ecs_entity_t member, - EcsMember *m) + ecs_table_t *table, + ecs_data_t *data, + int32_t size) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(member != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - const char *name = ecs_get_name(world, member); - if (!name) { - char *path = ecs_get_fullpath(world, type); - ecs_err("member for struct '%s' does not have a name", path); - ecs_os_free(path); - return -1; - } + check_table_sanity(table); - if (!m->type) { - char *path = ecs_get_fullpath(world, member); - ecs_err("member '%s' does not have a type", path); - ecs_os_free(path); - return -1; - } + int32_t cur_count = flecs_table_data_count(data); - if (ecs_get_typeid(world, m->type) == 0) { - char *path = ecs_get_fullpath(world, member); - char *ent_path = ecs_get_fullpath(world, m->type); - ecs_err("member '%s.type' is '%s' which is not a type", path, ent_path); - ecs_os_free(path); - ecs_os_free(ent_path); - return -1; + if (cur_count < size) { + grow_data(world, table, data, 0, size, NULL); + check_table_sanity(table); } +} - ecs_entity_t unit = m->unit; - - if (unit) { - if (!ecs_has(world, unit, EcsUnit)) { - ecs_err("entity '%s' for member '%s' is not a unit", - ecs_get_name(world, unit), name); - return -1; - } +int32_t flecs_table_data_count( + const ecs_data_t *data) +{ + return data ? ecs_vector_count(data->entities) : 0; +} - if (ecs_has(world, m->type, EcsUnit) && m->type != unit) { - ecs_err("unit mismatch for type '%s' and unit '%s' for member '%s'", - ecs_get_name(world, m->type), ecs_get_name(world, unit), name); - return -1; - } - } else { - if (ecs_has(world, m->type, EcsUnit)) { - unit = m->type; - m->unit = unit; - } +static +void swap_switch_columns( + ecs_table_t *table, + ecs_data_t *data, + int32_t row_1, + int32_t row_2) +{ + int32_t i = 0, column_count = table->sw_column_count; + if (!column_count) { + return; } - EcsStruct *s = ecs_get_mut(world, type, EcsStruct, NULL); - ecs_assert(s != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_sw_column_t *columns = data->sw_columns; - /* First check if member is already added to struct */ - ecs_member_t *members = ecs_vector_first(s->members, ecs_member_t); - int32_t i, count = ecs_vector_count(s->members); - for (i = 0; i < count; i ++) { - if (members[i].member == member) { - set_struct_member( - &members[i], member, name, m->type, m->count, unit); - break; - } + for (i = 0; i < column_count; i ++) { + ecs_switch_t *sw = columns[i].data; + flecs_switch_swap(sw, row_1, row_2); } +} - /* If member wasn't added yet, add a new element to vector */ - if (i == count) { - ecs_member_t *elem = ecs_vector_add(&s->members, ecs_member_t); - elem->name = NULL; - set_struct_member(elem, member, name, m->type, m->count, unit); - - /* Reobtain members array in case it was reallocated */ - members = ecs_vector_first(s->members, ecs_member_t); - count ++; +static +void swap_bitset_columns( + ecs_table_t *table, + ecs_data_t *data, + int32_t row_1, + int32_t row_2) +{ + int32_t i = 0, column_count = table->bs_column_count; + if (!column_count) { + return; } - /* Compute member offsets and size & alignment of struct */ - ecs_size_t size = 0; - ecs_size_t alignment = 0; - - for (i = 0; i < count; i ++) { - ecs_member_t *elem = &members[i]; + ecs_bs_column_t *columns = data->bs_columns; - ecs_assert(elem->name != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(elem->type != 0, ECS_INTERNAL_ERROR, NULL); + for (i = 0; i < column_count; i ++) { + ecs_bitset_t *bs = &columns[i].data; + flecs_bitset_swap(bs, row_1, row_2); + } +} - /* Get component of member type to get its size & alignment */ - const EcsComponent *mbr_comp = ecs_get(world, elem->type, EcsComponent); - if (!mbr_comp) { - char *path = ecs_get_fullpath(world, member); - ecs_err("member '%s' is not a type", path); - ecs_os_free(path); - return -1; - } +void flecs_table_swap( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + int32_t row_1, + int32_t row_2) +{ + (void)world; - ecs_size_t member_size = mbr_comp->size; - ecs_size_t member_alignment = mbr_comp->alignment; + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); + ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(row_1 >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(row_2 >= 0, ECS_INTERNAL_ERROR, NULL); - if (!member_size || !member_alignment) { - char *path = ecs_get_fullpath(world, member); - ecs_err("member '%s' has 0 size/alignment"); - ecs_os_free(path); - return -1; - } + check_table_sanity(table); + + if (row_1 == row_2) { + return; + } - member_size *= elem->count; - size = ECS_ALIGN(size, member_alignment); - elem->size = member_size; - elem->offset = size; + /* If the table is monitored indicate that there has been a change */ + mark_table_dirty(world, table, 0); - size += member_size; + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + ecs_entity_t e1 = entities[row_1]; + ecs_entity_t e2 = entities[row_2]; - if (member_alignment > alignment) { - alignment = member_alignment; - } - } + ecs_record_t **record_ptrs = ecs_vector_first(data->record_ptrs, ecs_record_t*); + ecs_record_t *record_ptr_1 = record_ptrs[row_1]; + ecs_record_t *record_ptr_2 = record_ptrs[row_2]; - if (size == 0) { - ecs_err("struct '%s' has 0 size", ecs_get_name(world, type)); - return -1; - } + ecs_assert(record_ptr_1 != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(record_ptr_2 != NULL, ECS_INTERNAL_ERROR, NULL); - if (alignment == 0) { - ecs_err("struct '%s' has 0 alignment", ecs_get_name(world, type)); - return -1; - } + /* Keep track of whether entity is watched */ + uint32_t flags_1 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_1->row); + uint32_t flags_2 = ECS_RECORD_TO_ROW_FLAGS(record_ptr_2->row); - /* Align struct size to struct alignment */ - size = ECS_ALIGN(size, alignment); + /* Swap entities & records */ + entities[row_1] = e2; + entities[row_2] = e1; + record_ptr_1->row = ECS_ROW_TO_RECORD(row_2, flags_1); + record_ptr_2->row = ECS_ROW_TO_RECORD(row_1, flags_2); + record_ptrs[row_1] = record_ptr_2; + record_ptrs[row_2] = record_ptr_1; - ecs_modified(world, type, EcsStruct); + swap_switch_columns(table, data, row_1, row_2); + swap_bitset_columns(table, data, row_1, row_2); - /* Do this last as it triggers the update of EcsMetaTypeSerialized */ - if (init_type(world, type, EcsStructType, size, alignment)) { - return -1; + ecs_column_t *columns = data->columns; + if (!columns) { + check_table_sanity(table); + return; } - /* If current struct is also a member, assign to itself */ - if (ecs_has(world, type, EcsMember)) { - EcsMember *type_mbr = ecs_get_mut(world, type, EcsMember, NULL); - ecs_assert(type_mbr != NULL, ECS_INTERNAL_ERROR, NULL); + /* Swap columns */ + int32_t i, column_count = ecs_vector_count(table->storage_type); + + for (i = 0; i < column_count; i ++) { + int16_t size = columns[i].size; + int16_t alignment = columns[i].alignment; - type_mbr->type = type; - type_mbr->count = 1; + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); - ecs_modified(world, type, EcsMember); + void *ptr = ecs_vector_first_t(columns[i].data, size, alignment); + void *tmp = ecs_os_alloca(size); + + void *el_1 = ECS_OFFSET(ptr, size * row_1); + void *el_2 = ECS_OFFSET(ptr, size * row_2); + + ecs_os_memcpy(tmp, el_1, size); + ecs_os_memcpy(el_1, el_2, size); + ecs_os_memcpy(el_2, tmp, size); } - return 0; + check_table_sanity(table); } static -int add_constant_to_enum( - ecs_world_t *world, - ecs_entity_t type, - ecs_entity_t e, - ecs_id_t constant_id) +void merge_vector( + ecs_vector_t **dst_out, + ecs_vector_t *src, + int16_t size, + int16_t alignment) { - EcsEnum *ptr = ecs_get_mut(world, type, EcsEnum, NULL); - - /* Remove constant from map if it was already added */ - ecs_map_iter_t it = ecs_map_iter(ptr->constants); - ecs_enum_constant_t *c; - ecs_map_key_t key; - while ((c = ecs_map_next(&it, ecs_enum_constant_t, &key))) { - if (c->constant == e) { - ecs_os_free((char*)c->name); - ecs_map_remove(ptr->constants, key); - } - } + ecs_vector_t *dst = *dst_out; + int32_t dst_count = ecs_vector_count(dst); - /* Check if constant sets explicit value */ - int32_t value = 0; - bool value_set = false; - if (ecs_id_is_pair(constant_id)) { - if (ecs_pair_second(world, constant_id) != ecs_id(ecs_i32_t)) { - char *path = ecs_get_fullpath(world, e); - ecs_err("expected i32 type for enum constant '%s'", path); - ecs_os_free(path); - return -1; + if (!dst_count) { + if (dst) { + ecs_vector_free(dst); } - const int32_t *value_ptr = ecs_get_pair_object( - world, e, EcsConstant, ecs_i32_t); - ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL); - value = *value_ptr; - value_set = true; - } + *dst_out = src; + + /* If the new table is not empty, copy the contents from the + * src into the dst. */ + } else { + int32_t src_count = ecs_vector_count(src); + ecs_vector_set_count_t(&dst, size, alignment, dst_count + src_count); + + void *dst_ptr = ecs_vector_first_t(dst, size, alignment); + void *src_ptr = ecs_vector_first_t(src, size, alignment); - /* Make sure constant value doesn't conflict if set / find the next value */ - it = ecs_map_iter(ptr->constants); - while ((c = ecs_map_next(&it, ecs_enum_constant_t, &key))) { - if (value_set) { - if (c->value == value) { - char *path = ecs_get_fullpath(world, e); - ecs_err("conflicting constant value for '%s' (other is '%s')", - path, c->name); - ecs_os_free(path); - return -1; - } - } else { - if (c->value >= value) { - value = c->value + 1; - } - } - } + dst_ptr = ECS_OFFSET(dst_ptr, size * dst_count); + + ecs_os_memcpy(dst_ptr, src_ptr, size * src_count); - if (!ptr->constants) { - ptr->constants = ecs_map_new(ecs_enum_constant_t, 1); + ecs_vector_free(src); + *dst_out = dst; } - - c = ecs_map_ensure(ptr->constants, ecs_enum_constant_t, value); - c->name = ecs_os_strdup(ecs_get_name(world, e)); - c->value = value; - c->constant = e; - - ecs_i32_t *cptr = ecs_get_mut_pair_object( - world, e, EcsConstant, ecs_i32_t, NULL); - ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); - cptr[0] = value; - - return 0; } static -int add_constant_to_bitmask( - ecs_world_t *world, - ecs_entity_t type, - ecs_entity_t e, - ecs_id_t constant_id) +void merge_column( + ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *data, + int32_t column_id, + ecs_vector_t *src) { - EcsBitmask *ptr = ecs_get_mut(world, type, EcsBitmask, NULL); - - /* Remove constant from map if it was already added */ - ecs_map_iter_t it = ecs_map_iter(ptr->constants); - ecs_bitmask_constant_t *c; - ecs_map_key_t key; - while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { - if (c->constant == e) { - ecs_os_free((char*)c->name); - ecs_map_remove(ptr->constants, key); - } - } + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + ecs_type_info_t *ti = table->type_info[column_id]; + ecs_column_t *column = &data->columns[column_id]; + ecs_vector_t *dst = column->data; + int16_t size = column->size; + int16_t alignment = column->alignment; + int32_t dst_count = ecs_vector_count(dst); - /* Check if constant sets explicit value */ - uint32_t value = 1; - if (ecs_id_is_pair(constant_id)) { - if (ecs_pair_second(world, constant_id) != ecs_id(ecs_u32_t)) { - char *path = ecs_get_fullpath(world, e); - ecs_err("expected u32 type for bitmask constant '%s'", path); - ecs_os_free(path); - return -1; + if (!dst_count) { + if (dst) { + ecs_vector_free(dst); } - const uint32_t *value_ptr = ecs_get_pair_object( - world, e, EcsConstant, ecs_u32_t); - ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL); - value = *value_ptr; + column->data = src; + + /* If the new table is not empty, copy the contents from the + * src into the dst. */ } else { - value = 1u << (ecs_u32_t)ecs_map_count(ptr->constants); - } + int32_t src_count = ecs_vector_count(src); + ecs_vector_set_count_t(&dst, size, alignment, dst_count + src_count); + column->data = dst; - /* Make sure constant value doesn't conflict */ - it = ecs_map_iter(ptr->constants); - while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { - if (c->value == value) { - char *path = ecs_get_fullpath(world, e); - ecs_err("conflicting constant value for '%s' (other is '%s')", - path, c->name); - ecs_os_free(path); - return -1; + /* Construct new values */ + if (ti) { + ctor_component(world, ti, column, entities, dst_count, src_count); } - } - - if (!ptr->constants) { - ptr->constants = ecs_map_new(ecs_bitmask_constant_t, 1); - } - - c = ecs_map_ensure(ptr->constants, ecs_bitmask_constant_t, value); - c->name = ecs_os_strdup(ecs_get_name(world, e)); - c->value = value; - c->constant = e; + + void *dst_ptr = ecs_vector_first_t(dst, size, alignment); + void *src_ptr = ecs_vector_first_t(src, size, alignment); - ecs_u32_t *cptr = ecs_get_mut_pair_object( - world, e, EcsConstant, ecs_u32_t, NULL); - ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); - cptr[0] = value; + dst_ptr = ECS_OFFSET(dst_ptr, size * dst_count); + + /* Move values into column */ + ecs_move_t move; + if (ti && (move = ti->lifecycle.move)) { + move(world, entities, entities, dst_ptr, src_ptr, src_count, ti); + } else { + ecs_os_memcpy(dst_ptr, src_ptr, size * src_count); + } - return 0; + ecs_vector_free(src); + } } static -void set_primitive(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsPrimitive *type = ecs_term(it, EcsPrimitive, 1); +void merge_table_data( + ecs_world_t *world, + ecs_table_t *new_table, + ecs_table_t *old_table, + int32_t old_count, + int32_t new_count, + ecs_data_t *old_data, + ecs_data_t *new_data) +{ + ecs_type_t new_type = new_table->storage_type; + ecs_type_t old_type = old_table->storage_type; + int32_t i_new = 0, new_column_count = ecs_vector_count(new_type); + int32_t i_old = 0, old_column_count = ecs_vector_count(old_type); + ecs_entity_t *new_components = ecs_vector_first(new_type, ecs_entity_t); + ecs_entity_t *old_components = ecs_vector_first(old_type, ecs_entity_t); - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - switch(type->kind) { - case EcsBool: - init_type_t(world, e, EcsPrimitiveType, bool); - break; - case EcsChar: - init_type_t(world, e, EcsPrimitiveType, char); - break; - case EcsByte: - init_type_t(world, e, EcsPrimitiveType, bool); - break; - case EcsU8: - init_type_t(world, e, EcsPrimitiveType, uint8_t); - break; - case EcsU16: - init_type_t(world, e, EcsPrimitiveType, uint16_t); - break; - case EcsU32: - init_type_t(world, e, EcsPrimitiveType, uint32_t); - break; - case EcsU64: - init_type_t(world, e, EcsPrimitiveType, uint64_t); - break; - case EcsI8: - init_type_t(world, e, EcsPrimitiveType, int8_t); - break; - case EcsI16: - init_type_t(world, e, EcsPrimitiveType, int16_t); - break; - case EcsI32: - init_type_t(world, e, EcsPrimitiveType, int32_t); - break; - case EcsI64: - init_type_t(world, e, EcsPrimitiveType, int64_t); - break; - case EcsF32: - init_type_t(world, e, EcsPrimitiveType, float); - break; - case EcsF64: - init_type_t(world, e, EcsPrimitiveType, double); - break; - case EcsUPtr: - init_type_t(world, e, EcsPrimitiveType, uintptr_t); - break; - case EcsIPtr: - init_type_t(world, e, EcsPrimitiveType, intptr_t); - break; - case EcsString: - init_type_t(world, e, EcsPrimitiveType, char*); - break; - case EcsEntity: - init_type_t(world, e, EcsPrimitiveType, ecs_entity_t); - break; - } + ecs_column_t *old_columns = old_data->columns; + ecs_column_t *new_columns = new_data->columns; + + if (!new_columns && !new_data->entities) { + new_columns = new_data->columns; } -} + + ecs_assert(!new_column_count || new_columns, ECS_INTERNAL_ERROR, NULL); -static -void set_member(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsMember *member = ecs_term(it, EcsMember, 1); + if (!old_count) { + return; + } - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); - if (!parent) { - ecs_err("missing parent for member '%s'", ecs_get_name(world, e)); - continue; - } + /* Merge entities */ + merge_vector(&new_data->entities, old_data->entities, ECS_SIZEOF(ecs_entity_t), + ECS_ALIGNOF(ecs_entity_t)); + old_data->entities = NULL; + ecs_entity_t *entities = ecs_vector_first(new_data->entities, ecs_entity_t); - add_member_to_struct(world, parent, e, &member[i]); - } -} + ecs_assert(ecs_vector_count(new_data->entities) == old_count + new_count, + ECS_INTERNAL_ERROR, NULL); -static -void add_enum(ecs_iter_t *it) { - ecs_world_t *world = it->world; + /* Merge entity index record pointers */ + merge_vector(&new_data->record_ptrs, old_data->record_ptrs, + ECS_SIZEOF(ecs_record_t*), ECS_ALIGNOF(ecs_record_t*)); + old_data->record_ptrs = NULL; - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; + for (; (i_new < new_column_count) && (i_old < old_column_count); ) { + ecs_entity_t new_component = new_components[i_new]; + ecs_entity_t old_component = old_components[i_old]; + int16_t size = new_columns[i_new].size; + int16_t alignment = new_columns[i_new].alignment; + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); - if (init_type_t(world, e, EcsEnumType, ecs_i32_t)) { - continue; - } + if (new_component == old_component) { + merge_column(world, new_table, new_data, i_new, + old_columns[i_old].data); + old_columns[i_old].data = NULL; - ecs_add_id(world, e, EcsExclusive); - ecs_add_id(world, e, EcsTag); - } -} + /* Mark component column as dirty */ + mark_table_dirty(world, new_table, i_new + 1); + + i_new ++; + i_old ++; + } else if (new_component < old_component) { + /* New column does not occur in old table, make sure vector is large + * enough. */ + ecs_column_t *column = &new_columns[i_new]; + ecs_vector_set_count_t(&column->data, size, alignment, + old_count + new_count); -static -void add_bitmask(ecs_iter_t *it) { - ecs_world_t *world = it->world; + /* Construct new values */ + ecs_type_info_t *c_info = new_table->type_info[i_new]; + if (c_info) { + ctor_component(world, c_info, column, + entities, 0, old_count + new_count); + } + + i_new ++; + } else if (new_component > old_component) { + ecs_column_t *column = &old_columns[i_old]; + + /* Destruct old values */ + ecs_type_info_t *c_info = old_table->type_info[i_old]; + if (c_info) { + dtor_component(world, old_table, c_info, column, + entities, 0, 0, old_count, false); + } - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; + /* Old column does not occur in new table, remove */ + ecs_vector_free(column->data); + column->data = NULL; - if (init_type_t(world, e, EcsBitmaskType, ecs_u32_t)) { - continue; + i_old ++; } } -} -static -void add_constant(ecs_iter_t *it) { - ecs_world_t *world = it->world; + move_switch_columns(new_table, new_data, new_count, old_table, old_data, 0, + old_count, true); + move_bitset_columns(new_table, new_data, new_count, old_table, old_data, 0, + old_count, true); - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); - if (!parent) { - ecs_err("missing parent for constant '%s'", ecs_get_name(world, e)); - continue; - } + /* Initialize remaining columns */ + for (; i_new < new_column_count; i_new ++) { + ecs_column_t *column = &new_columns[i_new]; + int16_t size = column->size; + int16_t alignment = column->alignment; + ecs_assert(size != 0, ECS_INTERNAL_ERROR, NULL); - if (ecs_has(world, parent, EcsEnum)) { - add_constant_to_enum(world, parent, e, it->event_id); - } else if (ecs_has(world, parent, EcsBitmask)) { - add_constant_to_bitmask(world, parent, e, it->event_id); + ecs_vector_set_count_t(&column->data, size, alignment, + old_count + new_count); + + /* Construct new values */ + ecs_type_info_t *c_info = new_table->type_info[i_new]; + if (c_info) { + ctor_component(world, c_info, column, + entities, 0, old_count + new_count); } } + + /* Destroy remaining columns */ + for (; i_old < old_column_count; i_old ++) { + ecs_column_t *column = &old_columns[i_old]; + + /* Destruct old values */ + ecs_type_info_t *c_info = old_table->type_info[i_old]; + if (c_info) { + dtor_component(world, old_table, c_info, column, entities, 0, + 0, old_count, false); + } + + /* Old column does not occur in new table, remove */ + ecs_vector_free(column->data); + column->data = NULL; + } + + /* Mark entity column as dirty */ + mark_table_dirty(world, new_table, 0); } -static -void set_array(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsArray *array = ecs_term(it, EcsArray, 1); +int32_t ecs_table_count( + const ecs_table_t *table) +{ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + return flecs_table_data_count(&table->storage); +} - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_entity_t elem_type = array[i].type; - int32_t elem_count = array[i].count; +void flecs_table_merge( + ecs_world_t *world, + ecs_table_t *new_table, + ecs_table_t *old_table, + ecs_data_t *new_data, + ecs_data_t *old_data) +{ + ecs_assert(old_table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!old_table->lock, ECS_LOCKED_STORAGE, NULL); - if (!elem_type) { - ecs_err("array '%s' has no element type", ecs_get_name(world, e)); - continue; - } + check_table_sanity(new_table); + check_table_sanity(old_table); + + bool move_data = false; + + /* If there is nothing to merge to, just clear the old table */ + if (!new_table) { + flecs_table_clear_data(world, old_table, old_data); + check_table_sanity(old_table); + return; + } else { + ecs_assert(!new_table->lock, ECS_LOCKED_STORAGE, NULL); + } - if (!elem_count) { - ecs_err("array '%s' has size 0", ecs_get_name(world, e)); - continue; - } + /* If there is no data to merge, drop out */ + if (!old_data) { + return; + } - const EcsComponent *elem_ptr = ecs_get(world, elem_type, EcsComponent); - if (init_type(world, e, EcsArrayType, - elem_ptr->size * elem_count, elem_ptr->alignment)) - { - continue; + if (!new_data) { + new_data = &new_table->storage; + if (new_table == old_table) { + move_data = true; } } -} -static -void set_vector(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsVector *array = ecs_term(it, EcsVector, 1); + ecs_entity_t *old_entities = ecs_vector_first(old_data->entities, ecs_entity_t); + int32_t old_count = ecs_vector_count(old_data->entities); + int32_t new_count = ecs_vector_count(new_data->entities); - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_entity_t elem_type = array[i].type; + ecs_record_t **old_records = ecs_vector_first( + old_data->record_ptrs, ecs_record_t*); + + /* First, update entity index so old entities point to new type */ + int32_t i; + for(i = 0; i < old_count; i ++) { + ecs_record_t *record; + if (new_table != old_table) { + record = old_records[i]; + ecs_assert(record != NULL, ECS_INTERNAL_ERROR, NULL); + } else { + record = ecs_eis_ensure(world, old_entities[i]); + } + + uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(record->row); + record->row = ECS_ROW_TO_RECORD(new_count + i, flags); + record->table = new_table; + } - if (!elem_type) { - ecs_err("vector '%s' has no element type", ecs_get_name(world, e)); - continue; - } + /* Merge table columns */ + if (move_data) { + *new_data = *old_data; + } else { + merge_table_data(world, new_table, old_table, old_count, new_count, + old_data, new_data); + } - if (init_type_t(world, e, EcsVectorType, ecs_vector_t*)) { - continue; + new_table->alloc_count ++; + + if (old_count) { + if (!new_count) { + flecs_table_set_empty(world, new_table); } + flecs_table_set_empty(world, old_table); } + + check_table_sanity(old_table); + check_table_sanity(new_table); } -bool flecs_unit_validate( +void flecs_table_replace_data( ecs_world_t *world, - ecs_entity_t t, - EcsUnit *data) + ecs_table_t *table, + ecs_data_t *data) { - char *derived_symbol = NULL; - const char *symbol = data->symbol; + int32_t prev_count = 0; + ecs_data_t *table_data = &table->storage; + ecs_assert(!data || data != table_data, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!table->lock, ECS_LOCKED_STORAGE, NULL); - ecs_entity_t base = data->base; - ecs_entity_t over = data->over; - ecs_entity_t prefix = data->prefix; - ecs_unit_translation_t translation = data->translation; + check_table_sanity(table); - if (base) { - if (!ecs_has(world, base, EcsUnit)) { - ecs_err("entity '%s' for unit '%s' used as base is not a unit", - ecs_get_name(world, base), ecs_get_name(world, t)); - goto error; - } + prev_count = ecs_vector_count(table_data->entities); + run_on_remove(world, table, table_data); + flecs_table_clear_data(world, table, table_data); + + if (data) { + table->storage = *data; + } else { + flecs_table_init_data(world, table); } - if (over) { - if (!base) { - ecs_err("invalid unit '%s': cannot specify over without base", - ecs_get_name(world, t)); - goto error; - } - if (!ecs_has(world, over, EcsUnit)) { - ecs_err("entity '%s' for unit '%s' used as over is not a unit", - ecs_get_name(world, over), ecs_get_name(world, t)); - goto error; - } + int32_t count = ecs_table_count(table); + + if (!prev_count && count) { + flecs_table_set_empty(world, table); + } else if (prev_count && !count) { + flecs_table_set_empty(world, table); } - if (prefix) { - if (!base) { - ecs_err("invalid unit '%s': cannot specify prefix without base", - ecs_get_name(world, t)); - goto error; - } - const EcsUnitPrefix *prefix_ptr = ecs_get(world, prefix, EcsUnitPrefix); - if (!prefix_ptr) { - ecs_err("entity '%s' for unit '%s' used as prefix is not a prefix", - ecs_get_name(world, over), ecs_get_name(world, t)); - goto error; - } + table->alloc_count ++; - if (translation.factor || translation.power) { - if (prefix_ptr->translation.factor != translation.factor || - prefix_ptr->translation.power != translation.power) - { - ecs_err( - "factor for unit '%s' is inconsistent with prefix '%s'", - ecs_get_name(world, t), ecs_get_name(world, prefix)); - goto error; - } - } else { - translation = prefix_ptr->translation; + check_table_sanity(table); +} + +int32_t* flecs_table_get_dirty_state( + ecs_table_t *table) +{ + if (!table->dirty_state) { + int32_t column_count = ecs_vector_count(table->storage_type); + table->dirty_state = ecs_os_malloc_n( int32_t, column_count + 1); + ecs_assert(table->dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); + + for (int i = 0; i < column_count + 1; i ++) { + table->dirty_state[i] = 1; } } + return table->dirty_state; +} - if (base) { - bool must_match = false; /* Must base symbol match symbol? */ - ecs_strbuf_t sbuf = ECS_STRBUF_INIT; - if (prefix) { - const EcsUnitPrefix *ptr = ecs_get(world, prefix, EcsUnitPrefix); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - if (ptr->symbol) { - ecs_strbuf_appendstr(&sbuf, ptr->symbol); - must_match = true; - } - } +int32_t* flecs_table_get_monitor( + ecs_table_t *table) +{ + int32_t *dirty_state = flecs_table_get_dirty_state(table); + ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); - const EcsUnit *uptr = ecs_get(world, base, EcsUnit); - ecs_assert(uptr != NULL, ECS_INTERNAL_ERROR, NULL); - if (uptr->symbol) { - ecs_strbuf_appendstr(&sbuf, uptr->symbol); - } + int32_t column_count = ecs_vector_count(table->storage_type); + return ecs_os_memdup(dirty_state, (column_count + 1) * ECS_SIZEOF(int32_t)); +} - if (over) { - uptr = ecs_get(world, over, EcsUnit); - ecs_assert(uptr != NULL, ECS_INTERNAL_ERROR, NULL); - if (uptr->symbol) { - ecs_strbuf_appendstr(&sbuf, "/"); - ecs_strbuf_appendstr(&sbuf, uptr->symbol); - must_match = true; - } - } +void flecs_table_notify( + ecs_world_t *world, + ecs_table_t *table, + ecs_table_event_t *event) +{ + if (world->is_fini) { + return; + } - derived_symbol = ecs_strbuf_get(&sbuf); - if (derived_symbol && !ecs_os_strlen(derived_symbol)) { - ecs_os_free(derived_symbol); - derived_symbol = NULL; - } + switch(event->kind) { + case EcsTableTriggersForId: + notify_trigger(world, table, event->event); + break; + case EcsTableNoTriggersForId: + break; + } +} - if (derived_symbol && symbol && ecs_os_strcmp(symbol, derived_symbol)) { - if (must_match) { - ecs_err("symbol '%s' for unit '%s' does not match base" - " symbol '%s'", symbol, - ecs_get_name(world, t), derived_symbol); - goto error; - } - } - if (!symbol && derived_symbol && (prefix || over)) { - ecs_os_free(data->symbol); - data->symbol = derived_symbol; - } else { - ecs_os_free(derived_symbol); +void ecs_table_lock( + ecs_world_t *world, + ecs_table_t *table) +{ + if (table) { + if (ecs_poly_is(world, ecs_world_t) && !world->is_readonly) { + table->lock ++; } } +} - data->base = base; - data->over = over; - data->prefix = prefix; - data->translation = translation; - - return true; -error: - ecs_os_free(derived_symbol); - return false; +void ecs_table_unlock( + ecs_world_t *world, + ecs_table_t *table) +{ + if (table) { + if (ecs_poly_is(world, ecs_world_t) && !world->is_readonly) { + table->lock --; + ecs_assert(table->lock >= 0, ECS_INVALID_OPERATION, NULL); + } + } } -static -void set_unit(ecs_iter_t *it) { - EcsUnit *u = ecs_term(it, EcsUnit, 1); +bool ecs_table_has_module( + ecs_table_t *table) +{ + return table->flags & EcsTableHasModule; +} - ecs_world_t *world = it->world; +ecs_column_t* ecs_table_column_for_id( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_id_t id) +{ + ecs_table_t *storage_table = table->storage_table; + if (!storage_table) { + return NULL; + } - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - flecs_unit_validate(world, e, &u[i]); + ecs_table_record_t *tr = flecs_get_table_record(world, storage_table, id); + if (tr) { + return &table->storage.columns[tr->column]; } -} -static -void unit_quantity_monitor(ecs_iter_t *it) { - ecs_world_t *world = it->world; + return NULL; +} - int i, count = it->count; - if (it->event == EcsOnAdd) { - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_add_pair(world, e, EcsQuantity, e); - } +ecs_type_t ecs_table_get_type( + const ecs_table_t *table) +{ + if (table) { + return table->type; } else { - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_remove_pair(world, e, EcsQuantity, e); - } + return NULL; } } -static -void ecs_meta_type_init_default_ctor(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsMetaType *type = ecs_term(it, EcsMetaType, 1); +ecs_table_t* ecs_table_get_storage_table( + const ecs_table_t *table) +{ + return table->storage_table; +} - int i; - for (i = 0; i < it->count; i ++) { - /* If a component is defined from reflection data, configure it with the - * default constructor. This ensures that a new component value does not - * contain uninitialized memory, which could cause serializers to crash - * when for example inspecting string fields. */ - if (!type->existing) { - ecs_set_component_actions_w_id(world, it->entities[i], - &(EcsComponentLifecycle){ - .ctor = ecs_default_ctor - }); - } - } +int32_t ecs_table_storage_count( + const ecs_table_t *table) +{ + return ecs_vector_count(table->storage_type); } -static -void member_on_set(ecs_iter_t *it) { - EcsMember *mbr = it->ptrs[0]; - if (!mbr->count) { - mbr->count = 1; +int32_t ecs_table_type_to_storage_index( + const ecs_table_t *table, + int32_t index) +{ + ecs_assert(index >= 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(index < ecs_vector_count(table->type), + ECS_INVALID_PARAMETER, NULL); + int32_t *storage_map = table->storage_map; + if (storage_map) { + return storage_map[index]; } +error: + return -1; } -void FlecsMetaImport( - ecs_world_t *world) +int32_t ecs_table_storage_to_type_index( + const ecs_table_t *table, + int32_t index) { - ECS_MODULE(world, FlecsMeta); + ecs_check(index < ecs_vector_count(table->storage_type), + ECS_INVALID_PARAMETER, NULL); + ecs_check(table->storage_map != NULL, ECS_INVALID_PARAMETER, NULL); + int32_t offset = ecs_vector_count(table->type); + return table->storage_map[offset + index]; +error: + return -1; +} - ecs_set_name_prefix(world, "Ecs"); +ecs_record_t* ecs_record_find( + const ecs_world_t *world, + ecs_entity_t entity) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL); - flecs_bootstrap_component(world, EcsMetaType); - flecs_bootstrap_component(world, EcsMetaTypeSerialized); - flecs_bootstrap_component(world, EcsPrimitive); - flecs_bootstrap_component(world, EcsEnum); - flecs_bootstrap_component(world, EcsBitmask); - flecs_bootstrap_component(world, EcsMember); - flecs_bootstrap_component(world, EcsStruct); - flecs_bootstrap_component(world, EcsArray); - flecs_bootstrap_component(world, EcsVector); - flecs_bootstrap_component(world, EcsUnit); - flecs_bootstrap_component(world, EcsUnitPrefix); + world = ecs_get_world(world); - flecs_bootstrap_tag(world, EcsConstant); - flecs_bootstrap_tag(world, EcsQuantity); + ecs_record_t *r = ecs_eis_get(world, entity); + if (r) { + return r; + } +error: + return NULL; +} - ecs_set_component_actions(world, EcsMetaType, { .ctor = ecs_default_ctor }); +void* ecs_record_get_column( + ecs_record_t *r, + int32_t column, + size_t c_size) +{ + (void)c_size; + ecs_table_t *table = r->table; - ecs_set_component_actions(world, EcsMetaTypeSerialized, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsMetaTypeSerialized), - .copy = ecs_copy(EcsMetaTypeSerialized), - .dtor = ecs_dtor(EcsMetaTypeSerialized) - }); + ecs_check(column < ecs_vector_count(table->storage_type), + ECS_INVALID_PARAMETER, NULL); - ecs_set_component_actions(world, EcsStruct, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsStruct), - .copy = ecs_copy(EcsStruct), - .dtor = ecs_dtor(EcsStruct) - }); + ecs_column_t *c = &table->storage.columns[column]; + ecs_assert(c != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_set_component_actions(world, EcsMember, { - .ctor = ecs_default_ctor, - .on_set = member_on_set - }); + ecs_check(!flecs_utosize(c_size) || + flecs_utosize(c_size) == c->size, + ECS_INVALID_PARAMETER, NULL); - ecs_set_component_actions(world, EcsEnum, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsEnum), - .copy = ecs_copy(EcsEnum), - .dtor = ecs_dtor(EcsEnum) - }); + return ecs_vector_get_t(c->data, c->size, c->alignment, + ECS_RECORD_TO_ROW(r->row)); +error: + return NULL; +} - ecs_set_component_actions(world, EcsBitmask, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsBitmask), - .copy = ecs_copy(EcsBitmask), - .dtor = ecs_dtor(EcsBitmask) - }); +#include - ecs_set_component_actions(world, EcsUnit, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsUnit), - .copy = ecs_copy(EcsUnit), - .dtor = ecs_dtor(EcsUnit) - }); +static const char* mixin_kind_str[] = { + [EcsMixinBase] = "base (should never be requested by application)", + [EcsMixinWorld] = "world", + [EcsMixinObservable] = "observable", + [EcsMixinIterable] = "iterable", + [EcsMixinMax] = "max (should never be requested by application)" +}; - ecs_set_component_actions(world, EcsUnitPrefix, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsUnitPrefix), - .copy = ecs_copy(EcsUnitPrefix), - .dtor = ecs_dtor(EcsUnitPrefix) - }); +ecs_mixins_t ecs_world_t_mixins = { + .type_name = "ecs_world_t", + .elems = { + [EcsMixinWorld] = offsetof(ecs_world_t, self), + [EcsMixinObservable] = offsetof(ecs_world_t, observable), + [EcsMixinIterable] = offsetof(ecs_world_t, iterable) + } +}; - /* Register triggers to finalize type information from component data */ - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsPrimitive), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = set_primitive - }); +ecs_mixins_t ecs_stage_t_mixins = { + .type_name = "ecs_stage_t", + .elems = { + [EcsMixinBase] = offsetof(ecs_stage_t, world), + [EcsMixinWorld] = offsetof(ecs_stage_t, world) + } +}; - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsMember), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = set_member - }); +ecs_mixins_t ecs_query_t_mixins = { + .type_name = "ecs_query_t", + .elems = { + [EcsMixinWorld] = offsetof(ecs_query_t, world), + [EcsMixinIterable] = offsetof(ecs_query_t, iterable) + } +}; - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsEnum), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnAdd}, - .callback = add_enum - }); +ecs_mixins_t ecs_filter_t_mixins = { + .type_name = "ecs_filter_t", + .elems = { + [EcsMixinIterable] = offsetof(ecs_filter_t, iterable) + } +}; - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsBitmask), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnAdd}, - .callback = add_bitmask - }); +static +void* get_mixin( + const ecs_poly_t *poly, + ecs_mixin_kind_t kind) +{ + ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(kind < EcsMixinMax, ECS_INVALID_PARAMETER, NULL); + + const ecs_header_t *hdr = poly; + ecs_assert(hdr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = EcsConstant, - .term.subj.set.mask = EcsSelf, - .events = {EcsOnAdd}, - .callback = add_constant - }); + const ecs_mixins_t *mixins = hdr->mixins; + if (!mixins) { + /* Object has no mixins */ + goto not_found; + } - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_pair(EcsConstant, EcsWildcard), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = add_constant - }); + ecs_size_t offset = mixins->elems[kind]; + if (offset == 0) { + /* Object has mixins but not the requested one. Try to find the mixin + * in the poly's base */ + goto find_in_base; + } - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsArray), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = set_array - }); + /* Object has mixin, return its address */ + return ECS_OFFSET(hdr, offset); - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsVector), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = set_vector - }); +find_in_base: + if (offset) { + /* If the poly has a base, try to find the mixin in the base */ + ecs_poly_t *base = *(ecs_poly_t**)ECS_OFFSET(hdr, offset); + if (base) { + return get_mixin(base, kind); + } + } + +not_found: + /* Mixin wasn't found for poly */ + return NULL; +} - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsUnit), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = set_unit - }); +static +void* assert_mixin( + const ecs_poly_t *poly, + ecs_mixin_kind_t kind) +{ + void *ptr = get_mixin(poly, kind); + if (!ptr) { + const ecs_header_t *header = poly; + const ecs_mixins_t *mixins = header->mixins; + ecs_err("%s not available for type %s", + mixin_kind_str[kind], + mixins ? mixins->type_name : "unknown"); + ecs_os_abort(); + } - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsMetaType), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = ecs_meta_type_serialized_init - }); + return ptr; +} - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_id(EcsMetaType), - .term.subj.set.mask = EcsSelf, - .events = {EcsOnSet}, - .callback = ecs_meta_type_init_default_ctor - }); +void* _ecs_poly_init( + ecs_poly_t *poly, + int32_t type, + ecs_size_t size, + ecs_mixins_t *mixins) +{ + ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_observer_init(world, &(ecs_observer_desc_t) { - .filter.terms = { - { .id = ecs_id(EcsUnit) }, - { .id = EcsQuantity } - }, - .events = { EcsMonitor }, - .callback = unit_quantity_monitor - }); + ecs_header_t *hdr = poly; + ecs_os_memset(poly, 0, size); - /* Initialize primitive types */ - #define ECS_PRIMITIVE(world, type, primitive_kind)\ - ecs_entity_init(world, &(ecs_entity_desc_t) {\ - .entity = ecs_id(ecs_##type##_t),\ - .name = #type,\ - .symbol = #type });\ - ecs_set(world, ecs_id(ecs_##type##_t), EcsPrimitive, {\ - .kind = primitive_kind\ - }); + hdr->magic = ECS_OBJECT_MAGIC; + hdr->type = type; + hdr->mixins = mixins; - ECS_PRIMITIVE(world, bool, EcsBool); - ECS_PRIMITIVE(world, char, EcsChar); - ECS_PRIMITIVE(world, byte, EcsByte); - ECS_PRIMITIVE(world, u8, EcsU8); - ECS_PRIMITIVE(world, u16, EcsU16); - ECS_PRIMITIVE(world, u32, EcsU32); - ECS_PRIMITIVE(world, u64, EcsU64); - ECS_PRIMITIVE(world, uptr, EcsUPtr); - ECS_PRIMITIVE(world, i8, EcsI8); - ECS_PRIMITIVE(world, i16, EcsI16); - ECS_PRIMITIVE(world, i32, EcsI32); - ECS_PRIMITIVE(world, i64, EcsI64); - ECS_PRIMITIVE(world, iptr, EcsIPtr); - ECS_PRIMITIVE(world, f32, EcsF32); - ECS_PRIMITIVE(world, f64, EcsF64); - ECS_PRIMITIVE(world, string, EcsString); - ECS_PRIMITIVE(world, entity, EcsEntity); + return poly; +} - #undef ECS_PRIMITIVE +void _ecs_poly_fini( + ecs_poly_t *poly, + int32_t type) +{ + ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); + (void)type; - /* Set default child components */ - ecs_add_pair(world, ecs_id(EcsStruct), - EcsDefaultChildComponent, ecs_id(EcsMember)); + ecs_header_t *hdr = poly; - ecs_add_pair(world, ecs_id(EcsMember), - EcsDefaultChildComponent, ecs_id(EcsMember)); + /* Don't deinit poly that wasn't initialized */ + ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); + ecs_assert(hdr->type == type, ECS_INVALID_PARAMETER, NULL); + hdr->magic = 0; +} - ecs_add_pair(world, ecs_id(EcsEnum), - EcsDefaultChildComponent, EcsConstant); +#define assert_object(cond, file, line)\ + _ecs_assert((cond), ECS_INVALID_PARAMETER, #cond, file, line, NULL);\ + assert(cond) - ecs_add_pair(world, ecs_id(EcsBitmask), - EcsDefaultChildComponent, EcsConstant); +#ifndef FLECS_NDEBUG +void _ecs_poly_assert( + const ecs_poly_t *poly, + int32_t type, + const char *file, + int32_t line) +{ + assert_object(poly != NULL, file, line); + + const ecs_header_t *hdr = poly; + assert_object(hdr->magic == ECS_OBJECT_MAGIC, file, line); + assert_object(hdr->type == type, file, line); +} +#endif - /* Relationship properties */ - ecs_add_id(world, EcsQuantity, EcsExclusive); - ecs_add_id(world, EcsQuantity, EcsTag); +bool _ecs_poly_is( + const ecs_poly_t *poly, + int32_t type) +{ + ecs_assert(poly != NULL, ECS_INVALID_PARAMETER, NULL); - /* Initialize reflection data for meta components */ - ecs_entity_t type_kind = ecs_enum_init(world, &(ecs_enum_desc_t) { - .entity.name = "TypeKind", - .constants = { - {.name = "PrimitiveType"}, - {.name = "BitmaskType"}, - {.name = "EnumType"}, - {.name = "StructType"}, - {.name = "ArrayType"}, - {.name = "VectorType"} - } - }); + const ecs_header_t *hdr = poly; + ecs_assert(hdr->magic == ECS_OBJECT_MAGIC, ECS_INVALID_PARAMETER, NULL); + return hdr->type == type; +} - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsMetaType), - .members = { - {.name = (char*)"kind", .type = type_kind} - } - }); +ecs_iterable_t* ecs_get_iterable( + const ecs_poly_t *poly) +{ + return (ecs_iterable_t*)assert_mixin(poly, EcsMixinIterable); +} - ecs_entity_t primitive_kind = ecs_enum_init(world, &(ecs_enum_desc_t) { - .entity.name = "PrimitiveKind", - .constants = { - {.name = "Bool", 1}, - {.name = "Char"}, - {.name = "Byte"}, - {.name = "U8"}, - {.name = "U16"}, - {.name = "U32"}, - {.name = "U64"}, - {.name = "I8"}, - {.name = "I16"}, - {.name = "I32"}, - {.name = "I64"}, - {.name = "F32"}, - {.name = "F64"}, - {.name = "UPtr"}, - {.name = "IPtr"}, - {.name = "String"}, - {.name = "Entity"} - } - }); +ecs_observable_t* ecs_get_observable( + const ecs_poly_t *poly) +{ + return (ecs_observable_t*)assert_mixin(poly, EcsMixinObservable); +} - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsPrimitive), - .members = { - {.name = (char*)"kind", .type = primitive_kind} - } - }); +const ecs_world_t* ecs_get_world( + const ecs_poly_t *poly) +{ + return *(ecs_world_t**)assert_mixin(poly, EcsMixinWorld); +} - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsMember), - .members = { - {.name = (char*)"type", .type = ecs_id(ecs_entity_t)}, - {.name = (char*)"count", .type = ecs_id(ecs_i32_t)}, - {.name = (char*)"unit", .type = ecs_id(ecs_entity_t)} - } - }); +#include - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsArray), - .members = { - {.name = (char*)"type", .type = ecs_id(ecs_entity_t)}, - {.name = (char*)"count", .type = ecs_id(ecs_i32_t)}, - } - }); +#ifndef FLECS_NDEBUG +static int64_t s_min[] = { + [1] = INT8_MIN, [2] = INT16_MIN, [4] = INT32_MIN, [8] = INT64_MIN }; +static int64_t s_max[] = { + [1] = INT8_MAX, [2] = INT16_MAX, [4] = INT32_MAX, [8] = INT64_MAX }; +static uint64_t u_max[] = { + [1] = UINT8_MAX, [2] = UINT16_MAX, [4] = UINT32_MAX, [8] = UINT64_MAX }; - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsVector), - .members = { - {.name = (char*)"type", .type = ecs_id(ecs_entity_t)} - } - }); +uint64_t _flecs_ito( + size_t size, + bool is_signed, + bool lt_zero, + uint64_t u, + const char *err) +{ + union { + uint64_t u; + int64_t s; + } v; - ecs_entity_t ut = ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.name = "unit_translation", - .members = { - {.name = (char*)"factor", .type = ecs_id(ecs_i32_t)}, - {.name = (char*)"power", .type = ecs_id(ecs_i32_t)} - } - }); + v.u = u; - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsUnit), - .members = { - {.name = (char*)"symbol", .type = ecs_id(ecs_string_t)}, - {.name = (char*)"prefix", .type = ecs_id(ecs_entity_t)}, - {.name = (char*)"base", .type = ecs_id(ecs_entity_t)}, - {.name = (char*)"over", .type = ecs_id(ecs_entity_t)}, - {.name = (char*)"translation", .type = ut} - } - }); + if (is_signed) { + ecs_assert(v.s >= s_min[size], ECS_INVALID_CONVERSION, err); + ecs_assert(v.s <= s_max[size], ECS_INVALID_CONVERSION, err); + } else { + ecs_assert(lt_zero == false, ECS_INVALID_CONVERSION, err); + ecs_assert(u <= u_max[size], ECS_INVALID_CONVERSION, err); + } - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsUnitPrefix), - .members = { - {.name = (char*)"symbol", .type = ecs_id(ecs_string_t)}, - {.name = (char*)"translation", .type = ut} - } - }); + return u; } - #endif +int32_t flecs_next_pow_of_2( + int32_t n) +{ + n --; + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + n ++; -#ifdef FLECS_META + return n; +} -static -const char* op_kind_str( - ecs_meta_type_op_kind_t kind) +/** Convert time to double */ +double ecs_time_to_double( + ecs_time_t t) { - switch(kind) { + double result; + result = t.sec; + return result + (double)t.nanosec / (double)1000000000; +} - case EcsOpEnum: return "Enum"; - case EcsOpBitmask: return "Bitmask"; - case EcsOpArray: return "Array"; - case EcsOpVector: return "Vector"; - case EcsOpPush: return "Push"; - case EcsOpPop: return "Pop"; - case EcsOpPrimitive: return "Primitive"; - case EcsOpBool: return "Bool"; - case EcsOpChar: return "Char"; - case EcsOpByte: return "Byte"; - case EcsOpU8: return "U8"; - case EcsOpU16: return "U16"; - case EcsOpU32: return "U32"; - case EcsOpU64: return "U64"; - case EcsOpI8: return "I8"; - case EcsOpI16: return "I16"; - case EcsOpI32: return "I32"; - case EcsOpI64: return "I64"; - case EcsOpF32: return "F32"; - case EcsOpF64: return "F64"; - case EcsOpUPtr: return "UPtr"; - case EcsOpIPtr: return "IPtr"; - case EcsOpString: return "String"; - case EcsOpEntity: return "Entity"; - default: return "<< invalid kind >>"; +ecs_time_t ecs_time_sub( + ecs_time_t t1, + ecs_time_t t2) +{ + ecs_time_t result; + + if (t1.nanosec >= t2.nanosec) { + result.nanosec = t1.nanosec - t2.nanosec; + result.sec = t1.sec - t2.sec; + } else { + result.nanosec = t1.nanosec - t2.nanosec + 1000000000; + result.sec = t1.sec - t2.sec - 1; } + + return result; } -/* Get current scope */ -static -ecs_meta_scope_t* get_scope( - const ecs_meta_cursor_t *cursor) +void ecs_sleepf( + double t) { - ecs_check(cursor != NULL, ECS_INVALID_PARAMETER, NULL); - return (ecs_meta_scope_t*)&cursor->scope[cursor->depth]; -error: - return NULL; + if (t > 0) { + int sec = (int)t; + int nsec = (int)((t - sec) * 1000000000); + ecs_os_sleep(sec, nsec); + } } -/* Get previous scope */ -static -ecs_meta_scope_t* get_prev_scope( - ecs_meta_cursor_t *cursor) +double ecs_time_measure( + ecs_time_t *start) { - ecs_check(cursor != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(cursor->depth > 0, ECS_INVALID_PARAMETER, NULL); - return &cursor->scope[cursor->depth - 1]; -error: - return NULL; + ecs_time_t stop, temp; + ecs_os_get_time(&stop); + temp = stop; + stop = ecs_time_sub(stop, *start); + *start = temp; + return ecs_time_to_double(stop); } -/* Get current operation for scope */ -static -ecs_meta_type_op_t* get_op( - ecs_meta_scope_t *scope) +void* ecs_os_memdup( + const void *src, + ecs_size_t size) { - return &scope->ops[scope->op_cur]; + if (!src) { + return NULL; + } + + void *dst = ecs_os_malloc(size); + ecs_assert(dst != NULL, ECS_OUT_OF_MEMORY, NULL); + ecs_os_memcpy(dst, src, size); + return dst; } -/* Get component for type in current scope */ -static -const EcsComponent* get_component_ptr( - const ecs_world_t *world, - ecs_meta_scope_t *scope) +int flecs_entity_compare( + ecs_entity_t e1, + const void *ptr1, + ecs_entity_t e2, + const void *ptr2) { - const EcsComponent *comp = scope->comp; - if (!comp) { - comp = scope->comp = ecs_get(world, scope->type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); - } - return comp; + (void)ptr1; + (void)ptr2; + return (e1 > e2) - (e1 < e2); } -/* Get size for type in current scope */ -static -ecs_size_t get_size( - const ecs_world_t *world, - ecs_meta_scope_t *scope) +int flecs_entity_compare_qsort( + const void *e1, + const void *e2) { - return get_component_ptr(world, scope)->size; + ecs_entity_t v1 = *(ecs_entity_t*)e1; + ecs_entity_t v2 = *(ecs_entity_t*)e2; + return flecs_entity_compare(v1, NULL, v2, NULL); } -/* Get alignment for type in current scope */ -static -ecs_size_t get_alignment( - const ecs_world_t *world, - ecs_meta_scope_t *scope) +uint64_t flecs_string_hash( + const void *ptr) { - return get_component_ptr(world, scope)->alignment; + const ecs_hashed_string_t *str = ptr; + ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL); + return str->hash; } +/* + This code was taken from sokol_time.h + + zlib/libpng license + Copyright (c) 2018 Andre Weissflog + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the + use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software in a + product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not + be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source + distribution. +*/ + + static -int32_t get_elem_count( - ecs_meta_scope_t *scope) +int32_t type_search( + const ecs_table_t *table, + ecs_id_record_t *idr, + ecs_id_t *ids, + ecs_id_t *id_out, + ecs_table_record_t **tr_out) { - if (scope->vector) { - return ecs_vector_count(*(scope->vector)); + ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table); + if (tr) { + int32_t r = tr->column; + if (tr_out) tr_out[0] = tr; + if (id_out) id_out[0] = ids[r]; + return r; } - ecs_meta_type_op_t *op = get_op(scope); - return op->count; + return -1; } -/* Get pointer to current field/element */ static -ecs_meta_type_op_t* get_ptr( - const ecs_world_t *world, - ecs_meta_scope_t *scope) +int32_t type_offset_search( + int32_t offset, + ecs_id_t id, + ecs_id_t *ids, + int32_t count, + ecs_id_t *id_out) { - ecs_meta_type_op_t *op = get_op(scope); - ecs_size_t size = get_size(world, scope); + ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); + ecs_assert(!ECS_HAS_ROLE(id, CASE), ECS_INVALID_PARAMETER, NULL); - if (scope->vector) { - ecs_size_t align = get_alignment(world, scope); - ecs_vector_set_min_count_t( - scope->vector, size, align, scope->elem_cur + 1); - scope->ptr = ecs_vector_first_t(*(scope->vector), size, align); + while (offset < count) { + ecs_id_t type_id = ids[offset ++]; + if (ecs_id_match(type_id, id)) { + if (id_out) id_out[0] = type_id; + return offset - 1; + } + } + + return -1; +} + +static +bool type_can_inherit_id( + const ecs_world_t *world, + const ecs_table_t *table, + const ecs_id_record_t *idr, + ecs_id_t id) +{ + if (idr->flags & ECS_ID_DONT_INHERIT) { + return false; + } + if (idr->flags & ECS_ID_EXCLUSIVE) { + if (ECS_HAS_ROLE(id, PAIR)) { + ecs_entity_t er = ECS_PAIR_FIRST(id); + if (flecs_get_table_record( + world, table, ecs_pair(er, EcsWildcard))) + { + return false; + } + } } - - return ECS_OFFSET(scope->ptr, size * scope->elem_cur + op->offset); + return true; } static -int push_type( +int32_t type_search_relation( const ecs_world_t *world, - ecs_meta_scope_t *scope, - ecs_entity_t type, - void *ptr) + const ecs_table_t *table, + int32_t offset, + ecs_id_t id, + ecs_id_record_t *idr, + ecs_id_t rel, + ecs_id_record_t *idr_r, + int32_t min_depth, + int32_t max_depth, + ecs_entity_t *subject_out, + ecs_id_t *id_out, + ecs_table_record_t **tr_out) { - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - if (ser == NULL) { - char *str = ecs_id_str(world, type); - ecs_err("cannot open scope for entity '%s' which is not a type", str); - ecs_os_free(str); - return -1; + ecs_type_t type = table->type; + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t count = ecs_vector_count(type); + + if (min_depth <= 0) { + if (offset) { + int32_t r = type_offset_search(offset, id, ids, count, id_out); + if (r != -1) { + return r; + } + } else { + int32_t r = type_search(table, idr, ids, id_out, tr_out); + if (r != -1) { + return r; + } + } } - scope[0] = (ecs_meta_scope_t) { - .type = type, - .ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t), - .op_count = ecs_vector_count(ser->ops), - .ptr = ptr - }; + ecs_flags32_t flags = table->flags; + if ((flags & EcsTableHasPairs) && max_depth && rel) { + bool is_a = rel == ecs_pair(EcsIsA, EcsWildcard); + if (is_a) { + if (!(flags & EcsTableHasIsA)) { + return -1; + } + if (!type_can_inherit_id(world, table, idr, id)) { + return -1; + } + idr_r = world->idr_isa_wildcard; + } - return 0; -} + if (!idr_r) { + idr_r = flecs_get_id_record(world, rel); + if (!idr_r) { + return -1; + } + } -ecs_meta_cursor_t ecs_meta_cursor( - const ecs_world_t *world, - ecs_entity_t type, - void *ptr) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(type != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_id_t id_r; + ecs_table_record_t *tr_r; + int32_t r, r_column = type_search(table, idr_r, ids, &id_r, &tr_r); + while (r_column != -1) { + ecs_entity_t obj = ECS_PAIR_SECOND(id_r); + ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); - ecs_meta_cursor_t result = { - .world = world, - .valid = true - }; + ecs_record_t *rec = ecs_eis_get_any(world, obj); + ecs_assert(rec != NULL, ECS_INTERNAL_ERROR, NULL); - if (push_type(world, result.scope, type, ptr) != 0) { - result.valid = false; + ecs_table_t *obj_table = rec->table; + if (obj_table) { + r = type_search_relation(world, obj_table, offset, id, idr, + rel, idr_r, min_depth - 1, max_depth - 1, subject_out, + id_out, tr_out); + if (r != -1) { + if (subject_out && !subject_out[0]) { + subject_out[0] = ecs_get_alive(world, obj); + } + return r; + } + + if (!is_a) { + r = type_search_relation(world, obj_table, offset, id, idr, + ecs_pair(EcsIsA, EcsWildcard), world->idr_isa_wildcard, + 1, INT_MAX, subject_out, id_out, tr_out); + if (r != -1) { + if (subject_out && !subject_out[0]) { + subject_out[0] = ecs_get_alive(world, obj); + } + return r; + } + } + } + + r_column = type_offset_search(r_column + 1, rel, ids, count, &id_r); + } } - return result; -error: - return (ecs_meta_cursor_t){ 0 }; + return -1; } -void* ecs_meta_get_ptr( - ecs_meta_cursor_t *cursor) +int32_t ecs_search_relation( + const ecs_world_t *world, + const ecs_table_t *table, + int32_t offset, + ecs_id_t id, + ecs_entity_t rel, + int32_t min_depth, + int32_t max_depth, + ecs_entity_t *subject_out, + ecs_id_t *id_out, + struct ecs_table_record_t **tr_out) { - return get_ptr(cursor->world, get_scope(cursor)); -} + if (!table) return -1; -int ecs_meta_next( - ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); + ecs_poly_assert(world, ecs_world_t); + ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); - if (scope->is_collection) { - scope->elem_cur ++; - scope->op_cur = 0; - if (scope->elem_cur >= get_elem_count(scope)) { - ecs_err("out of collection bounds (%d)", scope->elem_cur); - return -1; - } - - return 0; - } + bool is_case = ECS_HAS_ROLE(id, CASE); + id = is_case * (ECS_SWITCH | ECS_PAIR_FIRST(id)) + !is_case * id; - scope->op_cur += op->op_count; - if (scope->op_cur >= scope->op_count) { - ecs_err("out of bounds"); + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { return -1; } - return 0; + max_depth = INT_MAX * !max_depth + max_depth * !!max_depth; + + int32_t result = type_search_relation(world, table, offset, id, idr, + ecs_pair(rel, EcsWildcard), NULL, min_depth, max_depth, subject_out, + id_out, tr_out); + + return result; } -int ecs_meta_member( - ecs_meta_cursor_t *cursor, - const char *name) +int32_t ecs_search( + const ecs_world_t *world, + const ecs_table_t *table, + ecs_id_t id, + ecs_id_t *id_out) { - if (cursor->depth == 0) { - ecs_err("cannot move to member in root scope"); - return -1; - } - - ecs_meta_scope_t *prev_scope = get_prev_scope(cursor); - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *push_op = get_op(prev_scope); - const ecs_world_t *world = cursor->world; + if (!table) return -1; - ecs_assert(push_op->kind == EcsOpPush, ECS_INTERNAL_ERROR, NULL); - - if (!push_op->members) { - ecs_err("cannot move to member '%s' for non-struct type", name); - return -1; - } + ecs_poly_assert(world, ecs_world_t); + ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); - const uint64_t *cur_ptr = flecs_name_index_find_ptr(push_op->members, name, 0, 0); - if (!cur_ptr) { - char *path = ecs_get_fullpath(world, scope->type); - ecs_err("unknown member '%s' for type '%s'", name, path); - ecs_os_free(path); + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr) { return -1; } - scope->op_cur = flecs_uto(int32_t, cur_ptr[0]); - - return 0; + ecs_type_t type = table->type; + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + return type_search(table, idr, ids, id_out, NULL); } -int ecs_meta_push( - ecs_meta_cursor_t *cursor) +int32_t ecs_search_offset( + const ecs_world_t *world, + const ecs_table_t *table, + int32_t offset, + ecs_id_t id, + ecs_id_t *id_out) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - const ecs_world_t *world = cursor->world; - - if (cursor->depth == 0) { - if (!cursor->is_primitive_scope) { - if (op->kind > EcsOpScope) { - cursor->is_primitive_scope = true; - return 0; - } - } + if (!offset) { + return ecs_search(world, table, id, id_out); } - void *ptr = get_ptr(world, scope); - cursor->depth ++; - ecs_check(cursor->depth < ECS_META_MAX_SCOPE_DEPTH, - ECS_INVALID_PARAMETER, NULL); + if (!table) return -1; - ecs_meta_scope_t *next_scope = get_scope(cursor); + ecs_poly_assert(world, ecs_world_t); - /* If we're not already in an inline array and this operation is an inline - * array, push a frame for the array. - * Doing this first ensures that inline arrays take precedence over other - * kinds of push operations, such as for a struct element type. */ - if (!scope->is_inline_array && op->count > 1 && !scope->is_collection) { - /* Push a frame just for the element type, with inline_array = true */ - next_scope[0] = (ecs_meta_scope_t){ - .ops = op, - .op_count = op->op_count, - .ptr = scope->ptr, - .type = op->type, - .is_collection = true, - .is_inline_array = true - }; + ecs_type_t type = table->type; + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t count = ecs_vector_count(type); + return type_offset_search(offset, id, ids, count, id_out); +} - /* With 'is_inline_array' set to true we ensure that we can never push - * the same inline array twice */ - return 0; - } +#include - switch(op->kind) { - case EcsOpPush: - next_scope[0] = (ecs_meta_scope_t) { - .ops = &op[1], /* op after push */ - .op_count = op->op_count - 1, /* don't include pop */ - .ptr = scope->ptr, - .type = op->type - }; - break; +static +void term_error( + const ecs_world_t *world, + const ecs_term_t *term, + const char *name, + const char *fmt, + ...) +{ + va_list args; + va_start(args, fmt); - case EcsOpArray: { - if (push_type(world, next_scope, op->type, ptr) != 0) { - goto error; - } + char *expr = ecs_term_str(world, term); + ecs_parser_errorv(name, expr, 0, fmt, args); + ecs_os_free(expr); - const EcsArray *type_ptr = ecs_get(world, op->type, EcsArray); - next_scope->type = type_ptr->type; - next_scope->is_collection = true; - break; + va_end(args); +} + +static +int finalize_term_set( + const ecs_world_t *world, + ecs_term_t *term, + ecs_term_id_t *identifier, + const char *name) +{ + if (identifier->set.mask & EcsParent) { + identifier->set.mask |= EcsSuperSet; + identifier->set.relation = EcsChildOf; } - case EcsOpVector: - next_scope->vector = ptr; - if (push_type(world, next_scope, op->type, NULL) != 0) { - goto error; + /* Default relation for superset/subset is EcsIsA */ + if (identifier->set.mask & (EcsSuperSet|EcsSubSet)) { + if (!identifier->set.relation) { + identifier->set.relation = EcsIsA; } - const EcsVector *type_ptr = ecs_get(world, op->type, EcsVector); - next_scope->type = type_ptr->type; - next_scope->is_collection = true; - break; + if (!(identifier->set.mask & EcsSelf)) { + if (!identifier->set.min_depth) { + identifier->set.min_depth = 1; + } + } + } else { + if (identifier->set.min_depth > 0) { + term_error(world, term, name, + "min depth cannnot be non-zero for Self term"); + return -1; + } + if (identifier->set.max_depth > 1) { + term_error(world, term, name, + "max depth cannnot be larger than 1 for Self term"); + return -1; + } - default: { - char *path = ecs_get_fullpath(world, scope->type); - ecs_err("invalid push for type '%s'", path); - ecs_os_free(path); - goto error; - } + identifier->set.max_depth = 1; } - if (scope->is_collection) { - next_scope[0].ptr = ECS_OFFSET(next_scope[0].ptr, - scope->elem_cur * get_size(world, scope)); + if ((identifier->set.mask != EcsNothing) && + (identifier->set.mask & EcsNothing)) + { + term_error(world, term, name, "invalid Nothing in set mask"); + return -1; } return 0; -error: - return -1; } -int ecs_meta_pop( - ecs_meta_cursor_t *cursor) +static +int finalize_term_var( + const ecs_world_t *world, + ecs_term_t *term, + ecs_term_id_t *identifier, + const char *name) { - if (cursor->is_primitive_scope) { - cursor->is_primitive_scope = false; - return 0; + if (identifier->var == EcsVarDefault) { + const char *var = ecs_identifier_is_var(identifier->name); + if (var) { + char *var_dup = ecs_os_strdup(var); + ecs_os_free(identifier->name); + identifier->name = var_dup; + identifier->var = EcsVarIsVariable; + } } - ecs_meta_scope_t *scope = get_scope(cursor); - cursor->depth --; - if (cursor->depth < 0) { - ecs_err("unexpected end of scope"); - return -1; + if (identifier->var == EcsVarDefault && identifier->set.mask != EcsNothing){ + identifier->var = EcsVarIsEntity; } - ecs_meta_scope_t *next_scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(next_scope); - - if (!scope->is_inline_array) { - if (op->kind == EcsOpPush) { - next_scope->op_cur += op->op_count - 1; + if (!identifier->name) { + return 0; + } - /* push + op_count should point to the operation after pop */ - op = get_op(next_scope); - ecs_assert(op->kind == EcsOpPop, ECS_INTERNAL_ERROR, NULL); - } else if (op->kind == EcsOpArray || op->kind == EcsOpVector) { - /* Collection type, nothing else to do */ + if (identifier->var != EcsVarIsVariable) { + if (ecs_identifier_is_0(identifier->name)) { + identifier->entity = 0; } else { - /* should not have been able to push if the previous scope was not - * a complex or collection type */ - ecs_assert(false, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t e = ecs_lookup_symbol(world, identifier->name, true); + if (!e) { + term_error(world, term, name, + "unresolved identifier '%s'", identifier->name); + return -1; + } + + identifier->entity = e; } - } else { - /* Make sure that this was an inline array */ - ecs_assert(next_scope->op_count > 1, ECS_INTERNAL_ERROR, NULL); } - return 0; -} - -bool ecs_meta_is_collection( - const ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - return scope->is_collection; -} - -ecs_entity_t ecs_meta_get_type( - const ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - return op->type; -} - -ecs_entity_t ecs_meta_get_unit( - const ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - return op->unit; -} - -const char* ecs_meta_get_member( - const ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - return op->name; -} - -/* Utility macro's to let the compiler do the conversion work for us */ -#define set_T(T, ptr, value)\ - ((T*)ptr)[0] = ((T)value) - -#define case_T(kind, T, dst, src)\ -case kind:\ - set_T(T, dst, src);\ - break - -#define cases_T_float(dst, src)\ - case_T(EcsOpF32, ecs_f32_t, dst, src);\ - case_T(EcsOpF64, ecs_f64_t, dst, src) - -#define cases_T_signed(dst, src)\ - case_T(EcsOpChar, ecs_char_t, dst, src);\ - case_T(EcsOpI8, ecs_i8_t, dst, src);\ - case_T(EcsOpI16, ecs_i16_t, dst, src);\ - case_T(EcsOpI32, ecs_i32_t, dst, src);\ - case_T(EcsOpI64, ecs_i64_t, dst, src);\ - case_T(EcsOpIPtr, ecs_iptr_t, dst, src) - -#define cases_T_unsigned(dst, src)\ - case_T(EcsOpByte, ecs_byte_t, dst, src);\ - case_T(EcsOpU8, ecs_u8_t, dst, src);\ - case_T(EcsOpU16, ecs_u16_t, dst, src);\ - case_T(EcsOpU32, ecs_u32_t, dst, src);\ - case_T(EcsOpU64, ecs_u64_t, dst, src);\ - case_T(EcsOpUPtr, ecs_uptr_t, dst, src);\ - -#define cases_T_bool(dst, src)\ -case EcsOpBool:\ - set_T(ecs_bool_t, dst, value != 0);\ - break - -static -void conversion_error( - ecs_meta_cursor_t *cursor, - ecs_meta_type_op_t *op, - const char *from) -{ - char *path = ecs_get_fullpath(cursor->world, op->type); - ecs_err("unsupported conversion from %s to '%s'", from, path); - ecs_os_free(path); -} - -int ecs_meta_set_bool( - ecs_meta_cursor_t *cursor, - bool value) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - - switch(op->kind) { - cases_T_bool(ptr, value); - cases_T_unsigned(ptr, value); - default: - conversion_error(cursor, op, "bool"); + if ((identifier->set.mask == EcsNothing) && + (identifier->var != EcsVarDefault)) + { + term_error(world, term, name, "Invalid Nothing with entity"); return -1; } + if (identifier->var == EcsVarIsEntity) { + if (identifier->entity && !ecs_is_alive(world, identifier->entity)) { + term_error(world, term, name, + "cannot use not alive entity %u in query", + (uint32_t)identifier->entity); + return -1; + } + } + return 0; } -int ecs_meta_set_char( - ecs_meta_cursor_t *cursor, - char value) +static +int finalize_term_identifier( + const ecs_world_t *world, + ecs_term_t *term, + ecs_term_id_t *identifier, + const char *name) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - - switch(op->kind) { - cases_T_bool(ptr, value); - cases_T_signed(ptr, value); - default: - conversion_error(cursor, op, "char"); + if (finalize_term_set(world, term, identifier, name)) { + return -1; + } + if (finalize_term_var(world, term, identifier, name)) { return -1; } - return 0; } -int ecs_meta_set_int( - ecs_meta_cursor_t *cursor, - int64_t value) +static +bool term_can_inherit( + ecs_term_t *term) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - - switch(op->kind) { - cases_T_bool(ptr, value); - cases_T_signed(ptr, value); - cases_T_float(ptr, value); - default: { - conversion_error(cursor, op, "int"); - return -1; - } + /* Hardcoded components that can't be inherited. TODO: replace with + * relationship property. */ + if (term->pred.entity == EcsChildOf || + (term->id == ecs_pair(ecs_id(EcsIdentifier), EcsName)) || + (term->id == EcsPrefab) || + (term->id == EcsDisabled)) + { + return false; } - - return 0; + return true; } -int ecs_meta_set_uint( - ecs_meta_cursor_t *cursor, - uint64_t value) +static +ecs_entity_t term_id_entity( + const ecs_world_t *world, + ecs_term_id_t *term_id) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); + if (term_id->entity && term_id->entity != EcsThis && + term_id->entity != EcsWildcard && term_id->entity != EcsAny) + { + if (!(term_id->entity & ECS_ROLE_MASK)) { + return term_id->entity; + } else { + return 0; + } + } else if (term_id->name) { + if (term_id->var == EcsVarIsEntity || + (term_id->var == EcsVarDefault && + !ecs_identifier_is_var(term_id->name))) + { + ecs_entity_t e = ecs_lookup_fullpath(world, term_id->name); + if (e != EcsWildcard && e != EcsThis && e != EcsAny) { + return e; + } + return 0; + } else { + return 0; + } + } else { + return 0; + } +} - switch(op->kind) { - cases_T_bool(ptr, value); - cases_T_unsigned(ptr, value); - cases_T_float(ptr, value); - case EcsOpEntity: - set_T(ecs_entity_t, ptr, value); - break; - default: - conversion_error(cursor, op, "uint"); +static +int finalize_term_vars( + const ecs_world_t *world, + ecs_term_t *term, + const char *name) +{ + if (finalize_term_var(world, term, &term->pred, name)) { + return -1; + } + if (finalize_term_var(world, term, &term->subj, name)) { + return -1; + } + if (finalize_term_var(world, term, &term->obj, name)) { return -1; } - return 0; } -int ecs_meta_set_float( - ecs_meta_cursor_t *cursor, - double value) +static +bool entity_is_var( + ecs_entity_t e) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - - switch(op->kind) { - cases_T_bool(ptr, value); - cases_T_signed(ptr, value); - cases_T_unsigned(ptr, value); - cases_T_float(ptr, value); - default: - conversion_error(cursor, op, "float"); - return -1; + if (e == EcsThis || e == EcsWildcard || e == EcsAny) { + return true; } - - return 0; + return false; } static -int add_bitmask_constant( - ecs_meta_cursor_t *cursor, - ecs_meta_type_op_t *op, - void *out, - const char *value) +int finalize_term_identifiers( + const ecs_world_t *world, + ecs_term_t *term, + const char *name) { - ecs_assert(op->type != 0, ECS_INTERNAL_ERROR, NULL); + /* By default select subsets for predicates. For example, when the term + * matches "Tree", also include "Oak", "Pine", "Elm". */ + if (term->pred.set.mask == EcsDefaultSet) { + ecs_entity_t e = term_id_entity(world, &term->pred); - if (!ecs_os_strcmp(value, "0")) { - return 0; + if (e && !ecs_has_id(world, e, EcsFinal)) { + term->pred.set.mask = EcsSelf|EcsSubSet; + } else { + /* If predicate is final, don't search subsets */ + term->pred.set.mask = EcsSelf; + } } - ecs_entity_t c = ecs_lookup_child(cursor->world, op->type, value); - if (!c) { - char *path = ecs_get_fullpath(cursor->world, op->type); - ecs_err("unresolved bitmask constant '%s' for type '%s'", value, path); - ecs_os_free(path); + /* By default select supersets for subjects. For example, when an entity has + * (IsA, SpaceShip), also search the components of SpaceShip. */ + if (term->subj.set.mask == EcsDefaultSet) { + ecs_entity_t e = term_id_entity(world, &term->pred); + + /* If the component has the DontInherit tag, use EcsSelf */ + if (!e || !ecs_has_id(world, e, EcsDontInherit)) { + term->subj.set.mask = EcsSelf|EcsSuperSet; + } else { + term->subj.set.mask = EcsSelf; + } + } + + /* By default select self for objects. */ + if (term->obj.set.mask == EcsDefaultSet) { + term->obj.set.mask = EcsSelf; + } + + if (finalize_term_set(world, term, &term->pred, name)) { + return -1; + } + if (finalize_term_set(world, term, &term->subj, name)) { + return -1; + } + if (finalize_term_set(world, term, &term->obj, name)) { return -1; } - const ecs_u32_t *v = ecs_get_pair_object( - cursor->world, c, EcsConstant, ecs_u32_t); - if (v == NULL) { - char *path = ecs_get_fullpath(cursor->world, op->type); - ecs_err("'%s' is not an bitmask constant for type '%s'", value, path); - ecs_os_free(path); + if (term->pred.set.mask & EcsNothing) { + term_error(world, term, name, + "invalid Nothing value for predicate set mask"); return -1; } - *(ecs_u32_t*)out |= v[0]; + if (term->obj.set.mask & EcsNothing) { + term_error(world, term, name, + "invalid Nothing value for object set mask"); + return -1; + } + + if (!(term->subj.set.mask & EcsNothing) && + !term->subj.entity && + term->subj.var == EcsVarIsEntity) + { + term->subj.entity = EcsThis; + } + + if (entity_is_var(term->pred.entity)) { + term->pred.var = EcsVarIsVariable; + } + if (entity_is_var(term->subj.entity)) { + term->subj.var = EcsVarIsVariable; + } + if (entity_is_var(term->obj.entity)) { + term->obj.var = EcsVarIsVariable; + } return 0; } static -int parse_bitmask( - ecs_meta_cursor_t *cursor, - ecs_meta_type_op_t *op, - void *out, - const char *value) +ecs_entity_t entity_from_identifier( + const ecs_term_id_t *identifier) { - char token[ECS_MAX_TOKEN_SIZE]; - - const char *prev = value, *ptr = value; + if (identifier->var == EcsVarDefault) { + return 0; + } else if (identifier->var == EcsVarIsEntity) { + return identifier->entity; + } else if (identifier->var == EcsVarIsVariable) { + return EcsWildcard; + } else { + /* This should've been caught earlier */ + ecs_abort(ECS_INTERNAL_ERROR, NULL); + } +} - *(ecs_u32_t*)out = 0; +static +int finalize_term_id( + const ecs_world_t *world, + ecs_term_t *term, + const char *name) +{ + ecs_entity_t pred = entity_from_identifier(&term->pred); + ecs_entity_t obj = entity_from_identifier(&term->obj); + ecs_id_t role = term->role; - while ((ptr = strchr(ptr, '|'))) { - ecs_os_memcpy(token, prev, ptr - prev); - token[ptr - prev] = '\0'; - if (add_bitmask_constant(cursor, op, out, token) != 0) { + if (ECS_HAS_ROLE(pred, PAIR)) { + if (obj) { + term_error(world, term, name, + "cannot set term.pred to a pair and term.obj at the same time"); return -1; } - ptr ++; - prev = ptr; + obj = ECS_PAIR_SECOND(pred); + pred = ECS_PAIR_FIRST(pred); + + term->pred.entity = pred; + term->obj.entity = obj; + + if (finalize_term_identifier(world, term, &term->obj, name)) { + return -1; + } } - if (add_bitmask_constant(cursor, op, out, prev) != 0) { - return -1; + if (!obj && role != ECS_PAIR) { + term->id = pred | role; + } else { + if (role) { + if (role && role != ECS_PAIR && role != ECS_CASE) { + term_error(world, term, name, "invalid role for pair"); + return -1; + } + + term->role = role; + } else { + term->role = ECS_PAIR; + } + + term->id = term->role | ecs_entity_t_comb(obj, pred); } return 0; } -int ecs_meta_set_string( - ecs_meta_cursor_t *cursor, - const char *value) +static +int populate_from_term_id( + const ecs_world_t *world, + ecs_term_t *term, + const char *name) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); + ecs_entity_t pred = 0; + ecs_entity_t obj = 0; + ecs_id_t role = term->id & ECS_ROLE_MASK; - switch(op->kind) { - case EcsOpBool: - if (!ecs_os_strcmp(value, "true")) { - set_T(ecs_bool_t, ptr, true); - } else if (!ecs_os_strcmp(value, "false")) { - set_T(ecs_bool_t, ptr, false); - } else { - ecs_err("invalid value for boolean '%s'", value); + if (!role && term->role) { + role = term->role; + term->id |= role; + } + + if (term->role && term->role != role) { + term_error(world, term, name, "mismatch between term.id & term.role"); + return -1; + } + + term->role = role; + + if (ECS_HAS_ROLE(term->id, PAIR) || ECS_HAS_ROLE(term->id, CASE)) { + pred = ECS_PAIR_FIRST(term->id); + obj = ECS_PAIR_SECOND(term->id); + + if (!pred) { + term_error(world, term, name, "missing predicate in term.id pair"); + return -1; + } + if (!obj) { + if (pred != EcsChildOf) { + term_error(world, term, name, "missing object in term.id pair"); + return -1; + } + } + } else { + pred = term->id & ECS_COMPONENT_MASK; + if (!pred) { + term_error(world, term, name, "missing predicate in term.id"); return -1; } - break; - case EcsOpI8: - case EcsOpU8: - case EcsOpChar: - case EcsOpByte: - set_T(ecs_i8_t, ptr, atol(value)); - break; - case EcsOpI16: - case EcsOpU16: - set_T(ecs_i16_t, ptr, atol(value)); - break; - case EcsOpI32: - case EcsOpU32: - set_T(ecs_i32_t, ptr, atol(value)); - break; - case EcsOpI64: - case EcsOpU64: - set_T(ecs_i64_t, ptr, atol(value)); - break; - case EcsOpIPtr: - case EcsOpUPtr: - set_T(ecs_iptr_t, ptr, atol(value)); - break; - case EcsOpF32: - set_T(ecs_f32_t, ptr, atof(value)); - break; - case EcsOpF64: - set_T(ecs_f64_t, ptr, atof(value)); - break; - case EcsOpString: { - ecs_os_free(*(char**)ptr); - char *result = ecs_os_strdup(value); - set_T(ecs_string_t, ptr, result); - break; } - case EcsOpEnum: { - ecs_assert(op->type != 0, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t c = ecs_lookup_child(cursor->world, op->type, value); - if (!c) { - char *path = ecs_get_fullpath(cursor->world, op->type); - ecs_err("unresolved enum constant '%s' for type '%s'", value, path); - ecs_os_free(path); + + ecs_entity_t term_pred = entity_from_identifier(&term->pred); + if (term_pred) { + if (term_pred != pred) { + term_error(world, term, name, + "mismatch between term.id and term.pred"); + return -1; + } + } else { + term->pred.entity = pred; + if (finalize_term_identifier(world, term, &term->pred, name)) { return -1; } + } - const ecs_i32_t *v = ecs_get_pair_object( - cursor->world, c, EcsConstant, ecs_i32_t); - if (v == NULL) { - char *path = ecs_get_fullpath(cursor->world, op->type); - ecs_err("'%s' is not an enum constant for type '%s'", value, path); - ecs_os_free(path); + ecs_entity_t term_obj = entity_from_identifier(&term->obj); + if (term_obj) { + if (ecs_entity_t_lo(term_obj) != obj) { + term_error(world, term, name, + "mismatch between term.id and term.obj"); + return -1; + } + } else { + term->obj.entity = obj; + if (finalize_term_identifier(world, term, &term->obj, name)) { return -1; } + } - set_T(ecs_i32_t, ptr, v[0]); - break; + return 0; +} + +static +int verify_term_consistency( + const ecs_world_t *world, + const ecs_term_t *term, + const char *name) +{ + ecs_entity_t pred = entity_from_identifier(&term->pred); + ecs_entity_t obj = entity_from_identifier(&term->obj); + ecs_id_t role = term->role; + ecs_id_t id = term->id; + bool wildcard = pred == EcsWildcard || obj == EcsWildcard; + + if (obj && (!role || (role != ECS_PAIR && role != ECS_CASE))) { + term_error(world, term, name, + "invalid role for term with pair (expected ECS_PAIR)"); + return -1; } - case EcsOpBitmask: - if (parse_bitmask(cursor, op, ptr, value) != 0) { + + if (role == ECS_CASE && !obj) { + term_error(world, term, name, + "missing object for term with ECS_CASE role"); + return -1; + } + + if (!pred) { + term_error(world, term, name, "missing predicate for term"); + return -1; + } + + if (role != (id & ECS_ROLE_MASK)) { + term_error(world, term, name, "mismatch between term.role & term.id"); + return -1; + } + + if (obj && !ECS_HAS_ROLE(id, PAIR) && !ECS_HAS_ROLE(id, CASE)) { + term_error(world, term, name, "term has object but id is not a pair"); + return -1; + } + + if (ECS_HAS_ROLE(id, PAIR) || ECS_HAS_ROLE(id, CASE)) { + if (!wildcard) { + role = ECS_ROLE_MASK & id; + if (id != (role | ecs_entity_t_comb( + term->obj.entity, term->pred.entity))) + { + char *id_str = ecs_id_str(world, ecs_pair(pred, obj)); + term_error(world, term, name, + "term id does not match pred/obj (%s)", id_str); + ecs_os_free(id_str); + return -1; + } + } + } else if (term->pred.entity != (id & ECS_COMPONENT_MASK)) { + if (!wildcard) { + char *pred_str = ecs_get_fullpath(world, term->pred.entity); + term_error(world, term, name, "term id does not match pred '%s'", + pred_str); + ecs_os_free(pred_str); return -1; } - break; - case EcsOpEntity: { - ecs_entity_t e = 0; + } - if (ecs_os_strcmp(value, "0")) { - if (cursor->lookup_action) { - e = cursor->lookup_action( - cursor->world, value, - cursor->lookup_ctx); - } else { - e = ecs_lookup_path(cursor->world, 0, value); - } + if (term->pred.var == EcsVarIsEntity) { + const ecs_term_id_t *tsubj = &term->subj; + const ecs_term_id_t *tobj = &term->obj; - if (!e) { - ecs_err("unresolved entity identifier '%s'", value); - return -1; + if (ecs_term_id_is_set(tsubj) && ecs_term_id_is_set(tobj)) { + if (tsubj->var == tobj->var) { + bool is_same = false; + + if (tsubj->var == EcsVarIsEntity) { + is_same = tsubj->entity == tobj->entity; + } else if (tsubj->name && tobj->name) { + is_same = !ecs_os_strcmp(tsubj->name, tobj->name); + } + + if (is_same && ecs_has_id(world, term->pred.entity, EcsAcyclic) + && !ecs_has_id(world, term->pred.entity, EcsReflexive)) + { + char *pred_str = ecs_get_fullpath(world, term->pred.entity); + term_error(world, term, name, "term with acyclic relation" + " '%s' cannot have same subject and object", + pred_str); + ecs_os_free(pred_str); + return -1; + } } } - - set_T(ecs_entity_t, ptr, e); - break; } - case EcsOpPop: - ecs_err("excess element '%s' in scope", value); - return -1; - default: - ecs_err("unsupported conversion from string '%s' to '%s'", - value, op_kind_str(op->kind)); - return -1; + + if (term->subj.set.relation && !term->subj.set.max_depth) { + if (!ecs_has_id(world, term->subj.set.relation, EcsAcyclic)) { + char *r_str = ecs_get_fullpath(world, term->subj.set.relation); + term_error(world, term, name, + "relation '%s' is used with SuperSet/SubSet but is not acyclic", + r_str); + ecs_os_free(r_str); + return -1; + } } return 0; } -int ecs_meta_set_string_literal( - ecs_meta_cursor_t *cursor, - const char *value) +bool ecs_identifier_is_0( + const char *id) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); + return id[0] == '0' && !id[1]; +} - ecs_size_t len = ecs_os_strlen(value); - if (value[0] != '\"' || value[len - 1] != '\"') { - ecs_err("invalid string literal '%s'", value); - return -1; +const char* ecs_identifier_is_var( + const char *id) +{ + if (!id) { + return NULL; } - switch(op->kind) { - case EcsOpChar: - set_T(ecs_char_t, ptr, value[1]); - break; - - default: - case EcsOpEntity: - case EcsOpString: - len -= 2; - - char *result = ecs_os_malloc(len + 1); - ecs_os_memcpy(result, value + 1, len); - result[len] = '\0'; - - if (ecs_meta_set_string(cursor, result)) { - ecs_os_free(result); - return -1; - } - - ecs_os_free(result); + /* Variable identifiers cannot start with a number */ + if (isdigit(id[0])) { + return NULL; + } - break; + /* Identifiers that start with _ are variables */ + if (id[0] == '_' && id[1] != 0) { + return &id[1]; } - return 0; + return NULL; } -int ecs_meta_set_entity( - ecs_meta_cursor_t *cursor, - ecs_entity_t value) +bool ecs_id_match( + ecs_id_t id, + ecs_id_t pattern) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - - switch(op->kind) { - case EcsOpEntity: - set_T(ecs_entity_t, ptr, value); - break; - default: - conversion_error(cursor, op, "entity"); - return -1; + if (id == pattern) { + return true; } - return 0; -} + if (ECS_HAS_ROLE(pattern, PAIR)) { + if (!ECS_HAS_ROLE(id, PAIR)) { + return false; + } -int ecs_meta_set_null( - ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch (op->kind) { - case EcsOpString: - ecs_os_free(*(char**)ptr); - set_T(ecs_string_t, ptr, NULL); - break; - default: - conversion_error(cursor, op, "null"); - return -1; - } + ecs_entity_t id_rel = ECS_PAIR_FIRST(id); + ecs_entity_t id_obj = ECS_PAIR_SECOND(id); + ecs_entity_t pattern_rel = ECS_PAIR_FIRST(pattern); + ecs_entity_t pattern_obj = ECS_PAIR_SECOND(pattern); - return 0; -} + ecs_check(id_rel != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(id_obj != 0, ECS_INVALID_PARAMETER, NULL); -bool ecs_meta_get_bool( - const ecs_meta_cursor_t *cursor) -{ - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpBool: return *(ecs_bool_t*)ptr; - case EcsOpI8: return *(ecs_i8_t*)ptr != 0; - case EcsOpU8: return *(ecs_u8_t*)ptr != 0; - case EcsOpChar: return *(ecs_char_t*)ptr != 0; - case EcsOpByte: return *(ecs_u8_t*)ptr != 0; - case EcsOpI16: return *(ecs_i16_t*)ptr != 0; - case EcsOpU16: return *(ecs_u16_t*)ptr != 0; - case EcsOpI32: return *(ecs_i32_t*)ptr != 0; - case EcsOpU32: return *(ecs_u32_t*)ptr != 0; - case EcsOpI64: return *(ecs_i64_t*)ptr != 0; - case EcsOpU64: return *(ecs_u64_t*)ptr != 0; - case EcsOpIPtr: return *(ecs_iptr_t*)ptr != 0; - case EcsOpUPtr: return *(ecs_uptr_t*)ptr != 0; - case EcsOpF32: return *(ecs_f32_t*)ptr != 0; - case EcsOpF64: return *(ecs_f64_t*)ptr != 0; - case EcsOpString: return *(const char**)ptr != NULL; - case EcsOpEnum: return *(ecs_i32_t*)ptr != 0; - case EcsOpBitmask: return *(ecs_u32_t*)ptr != 0; - case EcsOpEntity: return *(ecs_entity_t*)ptr != 0; - default: ecs_throw(ECS_INVALID_PARAMETER, - "invalid element for bool"); + ecs_check(pattern_rel != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(pattern_obj != 0, ECS_INVALID_PARAMETER, NULL); + + if (pattern_rel == EcsWildcard) { + if (pattern_obj == EcsWildcard || pattern_obj == id_obj) { + return true; + } + } else if (pattern_obj == EcsWildcard) { + if (pattern_rel == id_rel) { + return true; + } + } + } else { + if ((id & ECS_ROLE_MASK) != (pattern & ECS_ROLE_MASK)) { + return false; + } + + if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) { + return true; + } } + error: - return 0; + return false; } -char ecs_meta_get_char( - const ecs_meta_cursor_t *cursor) +bool ecs_id_is_pair( + ecs_id_t id) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpChar: return *(ecs_char_t*)ptr != 0; - default: ecs_throw(ECS_INVALID_PARAMETER, - "invalid element for char"); - } -error: - return 0; + return ECS_HAS_ROLE(id, PAIR); } -int64_t ecs_meta_get_int( - const ecs_meta_cursor_t *cursor) +bool ecs_id_is_wildcard( + ecs_id_t id) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpBool: return *(ecs_bool_t*)ptr; - case EcsOpI8: return *(ecs_i8_t*)ptr; - case EcsOpU8: return *(ecs_u8_t*)ptr; - case EcsOpChar: return *(ecs_char_t*)ptr; - case EcsOpByte: return *(ecs_u8_t*)ptr; - case EcsOpI16: return *(ecs_i16_t*)ptr; - case EcsOpU16: return *(ecs_u16_t*)ptr; - case EcsOpI32: return *(ecs_i32_t*)ptr; - case EcsOpU32: return *(ecs_u32_t*)ptr; - case EcsOpI64: return *(ecs_i64_t*)ptr; - case EcsOpU64: return flecs_uto(int64_t, *(ecs_u64_t*)ptr); - case EcsOpIPtr: return *(ecs_iptr_t*)ptr; - case EcsOpUPtr: return flecs_uto(int64_t, *(ecs_uptr_t*)ptr); - case EcsOpF32: return (int64_t)*(ecs_f32_t*)ptr; - case EcsOpF64: return (int64_t)*(ecs_f64_t*)ptr; - case EcsOpString: return atoi(*(const char**)ptr); - case EcsOpEnum: return *(ecs_i32_t*)ptr; - case EcsOpBitmask: return *(ecs_u32_t*)ptr; - case EcsOpEntity: - ecs_throw(ECS_INVALID_PARAMETER, - "invalid conversion from entity to int"); - break; - default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for int"); - } -error: - return 0; + return + (id == EcsWildcard) || (ECS_HAS_ROLE(id, PAIR) && ( + (ECS_PAIR_FIRST(id) == EcsWildcard) || + (ECS_PAIR_SECOND(id) == EcsWildcard) + )); } -uint64_t ecs_meta_get_uint( - const ecs_meta_cursor_t *cursor) +bool ecs_term_id_is_set( + const ecs_term_id_t *id) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpBool: return *(ecs_bool_t*)ptr; - case EcsOpI8: return flecs_ito(uint64_t, *(ecs_i8_t*)ptr); - case EcsOpU8: return *(ecs_u8_t*)ptr; - case EcsOpChar: return flecs_ito(uint64_t, *(ecs_char_t*)ptr); - case EcsOpByte: return flecs_ito(uint64_t, *(ecs_u8_t*)ptr); - case EcsOpI16: return flecs_ito(uint64_t, *(ecs_i16_t*)ptr); - case EcsOpU16: return *(ecs_u16_t*)ptr; - case EcsOpI32: return flecs_ito(uint64_t, *(ecs_i32_t*)ptr); - case EcsOpU32: return *(ecs_u32_t*)ptr; - case EcsOpI64: return flecs_ito(uint64_t, *(ecs_i64_t*)ptr); - case EcsOpU64: return *(ecs_u64_t*)ptr; - case EcsOpIPtr: return flecs_ito(uint64_t, *(ecs_i64_t*)ptr); - case EcsOpUPtr: return *(ecs_uptr_t*)ptr; - case EcsOpF32: return flecs_ito(uint64_t, *(ecs_f32_t*)ptr); - case EcsOpF64: return flecs_ito(uint64_t, *(ecs_f64_t*)ptr); - case EcsOpString: return flecs_ito(uint64_t, atoi(*(const char**)ptr)); - case EcsOpEnum: return flecs_ito(uint64_t, *(ecs_i32_t*)ptr); - case EcsOpBitmask: return *(ecs_u32_t*)ptr; - case EcsOpEntity: return *(ecs_entity_t*)ptr; - default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for uint"); - } -error: - return 0; + return id->entity != 0 || id->name != NULL; } -double ecs_meta_get_float( - const ecs_meta_cursor_t *cursor) +bool ecs_term_is_initialized( + const ecs_term_t *term) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpBool: return *(ecs_bool_t*)ptr; - case EcsOpI8: return *(ecs_i8_t*)ptr; - case EcsOpU8: return *(ecs_u8_t*)ptr; - case EcsOpChar: return *(ecs_char_t*)ptr; - case EcsOpByte: return *(ecs_u8_t*)ptr; - case EcsOpI16: return *(ecs_i16_t*)ptr; - case EcsOpU16: return *(ecs_u16_t*)ptr; - case EcsOpI32: return *(ecs_i32_t*)ptr; - case EcsOpU32: return *(ecs_u32_t*)ptr; - case EcsOpI64: return (double)*(ecs_i64_t*)ptr; - case EcsOpU64: return (double)*(ecs_u64_t*)ptr; - case EcsOpIPtr: return (double)*(ecs_iptr_t*)ptr; - case EcsOpUPtr: return (double)*(ecs_uptr_t*)ptr; - case EcsOpF32: return (double)*(ecs_f32_t*)ptr; - case EcsOpF64: return *(ecs_f64_t*)ptr; - case EcsOpString: return atof(*(const char**)ptr); - case EcsOpEnum: return *(ecs_i32_t*)ptr; - case EcsOpBitmask: return *(ecs_u32_t*)ptr; - case EcsOpEntity: - ecs_throw(ECS_INVALID_PARAMETER, - "invalid conversion from entity to float"); - break; - default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for float"); - } -error: - return 0; + return term->id != 0 || ecs_term_id_is_set(&term->pred); } -const char* ecs_meta_get_string( - const ecs_meta_cursor_t *cursor) +bool ecs_term_is_trivial( + const ecs_term_t *term) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpString: return *(const char**)ptr; - default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for string"); + if (term->inout != EcsInOutDefault) { + return false; } -error: - return 0; + + if (term->subj.entity != EcsThis) { + return false; + } + + if (term->subj.set.mask && (term->subj.set.mask != EcsSelf)) { + return false; + } + + if (term->oper != EcsAnd && term->oper != EcsAndFrom) { + return false; + } + + if (term->name != NULL) { + return false; + } + + return true; } -ecs_entity_t ecs_meta_get_entity( - const ecs_meta_cursor_t *cursor) +int ecs_term_finalize( + const ecs_world_t *world, + const char *name, + ecs_term_t *term) { - ecs_meta_scope_t *scope = get_scope(cursor); - ecs_meta_type_op_t *op = get_op(scope); - void *ptr = get_ptr(cursor->world, scope); - switch(op->kind) { - case EcsOpEntity: return *(ecs_entity_t*)ptr; - default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for entity"); + if (finalize_term_vars(world, term, name)) { + return -1; } -error: - return 0; -} -#endif + if (!term->id) { + if (finalize_term_id(world, term, name)) { + return -1; + } + } else { + if (populate_from_term_id(world, term, name)) { + return -1; + } + } + if (finalize_term_identifiers(world, term, name)) { + return -1; + } + if (!term_can_inherit(term)) { + if (term->subj.set.relation == EcsIsA) { + term->subj.set.relation = 0; + term->subj.set.mask = EcsSelf; + } + } -#ifdef FLECS_EXPR + if (term->role == ECS_AND || term->role == ECS_OR || term->role == ECS_NOT){ + /* AND/OR terms match >1 component, which is only valid as filter */ + if (term->inout != EcsInOutDefault && term->inout != EcsInOutFilter) { + term_error(world, term, name, "AND/OR terms must be filters"); + return -1; + } -static -int expr_ser_type( - const ecs_world_t *world, - ecs_vector_t *ser, - const void *base, - ecs_strbuf_t *str); + term->inout = EcsInOutFilter; -static -int expr_ser_type_ops( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - ecs_strbuf_t *str); + /* Translate role to operator */ + if (term->role == ECS_AND) { + term->oper = EcsAndFrom; + } else + if (term->role == ECS_OR) { + term->oper = EcsOrFrom; + } else + if (term->role == ECS_NOT) { + term->oper = EcsNotFrom; + } -static -int expr_ser_type_op( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str); + /* Zero out role & strip from id */ + term->id &= ECS_COMPONENT_MASK; + term->role = 0; + } -static -ecs_primitive_kind_t expr_op_to_primitive_kind(ecs_meta_type_op_kind_t kind) { - return kind - EcsOpPrimitive; + if (verify_term_consistency(world, term, name)) { + return -1; + } + + return 0; } -/* Serialize a primitive value */ -static -int expr_ser_primitive( - const ecs_world_t *world, - ecs_primitive_kind_t kind, - const void *base, - ecs_strbuf_t *str) +ecs_term_t ecs_term_copy( + const ecs_term_t *src) { - const char *bool_str[] = { "false", "true" }; + ecs_term_t dst = *src; + dst.name = ecs_os_strdup(src->name); + dst.pred.name = ecs_os_strdup(src->pred.name); + dst.subj.name = ecs_os_strdup(src->subj.name); + dst.obj.name = ecs_os_strdup(src->obj.name); + return dst; +} - switch(kind) { - case EcsBool: - ecs_strbuf_appendstr(str, bool_str[(int)*(bool*)base]); - break; - case EcsChar: { - char chbuf[3]; - char ch = *(char*)base; - if (ch) { - ecs_chresc(chbuf, *(char*)base, '"'); - ecs_strbuf_appendstrn(str, "\"", 1); - ecs_strbuf_appendstr(str, chbuf); - ecs_strbuf_appendstrn(str, "\"", 1); - } else { - ecs_strbuf_appendstr(str, "0"); - } - break; +ecs_term_t ecs_term_move( + ecs_term_t *src) +{ + if (src->move) { + ecs_term_t dst = *src; + src->name = NULL; + src->pred.name = NULL; + src->subj.name = NULL; + src->obj.name = NULL; + dst.move = false; + return dst; + } else { + ecs_term_t dst = ecs_term_copy(src); + dst.move = false; + return dst; } - case EcsByte: - ecs_strbuf_append(str, "%u", *(uint8_t*)base); - break; - case EcsU8: - ecs_strbuf_append(str, "%u", *(uint8_t*)base); - break; - case EcsU16: - ecs_strbuf_append(str, "%u", *(uint16_t*)base); - break; - case EcsU32: - ecs_strbuf_append(str, "%u", *(uint32_t*)base); - break; - case EcsU64: - ecs_strbuf_append(str, "%llu", *(uint64_t*)base); - break; - case EcsI8: - ecs_strbuf_append(str, "%d", *(int8_t*)base); - break; - case EcsI16: - ecs_strbuf_append(str, "%d", *(int16_t*)base); - break; - case EcsI32: - ecs_strbuf_append(str, "%d", *(int32_t*)base); - break; - case EcsI64: - ecs_strbuf_append(str, "%lld", *(int64_t*)base); - break; - case EcsF32: - ecs_strbuf_appendflt(str, (double)*(float*)base, 0); - break; - case EcsF64: - ecs_strbuf_appendflt(str, *(double*)base, 0); - break; - case EcsIPtr: - ecs_strbuf_append(str, "%i", *(intptr_t*)base); - break; - case EcsUPtr: - ecs_strbuf_append(str, "%u", *(uintptr_t*)base); - break; - case EcsString: { - char *value = *(char**)base; - if (value) { - ecs_size_t length = ecs_stresc(NULL, 0, '"', value); - if (length == ecs_os_strlen(value)) { - ecs_strbuf_appendstrn(str, "\"", 1); - ecs_strbuf_appendstr(str, value); - ecs_strbuf_appendstrn(str, "\"", 1); - } else { - char *out = ecs_os_malloc(length + 3); - ecs_stresc(out + 1, length, '"', value); - out[0] = '"'; - out[length + 1] = '"'; - out[length + 2] = '\0'; - ecs_strbuf_appendstr_zerocpy(str, out); +} + +void ecs_term_fini( + ecs_term_t *term) +{ + ecs_os_free(term->pred.name); + ecs_os_free(term->subj.name); + ecs_os_free(term->obj.name); + ecs_os_free(term->name); + + term->pred.name = NULL; + term->subj.name = NULL; + term->obj.name = NULL; + term->name = NULL; +} + +int ecs_filter_finalize( + const ecs_world_t *world, + ecs_filter_t *f) +{ + int32_t i, term_count = f->term_count, actual_count = 0; + ecs_term_t *terms = f->terms; + bool is_or = false, prev_or = false; + int32_t filter_terms = 0; + + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; + + if (ecs_term_finalize(world, f->name, term)) { + return -1; + } + + is_or = term->oper == EcsOr; + actual_count += !(is_or && prev_or); + term->index = actual_count - 1; + prev_or = is_or; + + if (term->subj.entity == EcsThis) { + f->match_this = true; + if (term->subj.set.mask != EcsSelf) { + f->match_only_this = false; } } else { - ecs_strbuf_appendstr(str, "null"); + f->match_only_this = false; } - break; - } - case EcsEntity: { - ecs_entity_t e = *(ecs_entity_t*)base; - if (!e) { - ecs_strbuf_appendstr(str, "0"); - } else { - char *path = ecs_get_fullpath(world, e); - ecs_assert(path != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_strbuf_appendstr(str, path); - ecs_os_free(path); + + if (term->id == EcsPrefab) { + f->match_prefab = true; + } + if (term->id == EcsDisabled) { + f->match_disabled = true; + } + + if (f->filter) { + term->inout = EcsInOutFilter; + } + + if (term->inout == EcsInOutFilter) { + filter_terms ++; + } + + if (term->oper != EcsNot || term->subj.entity != EcsThis) { + f->match_anything = false; } - break; } - default: - ecs_err("invalid primitive kind"); - return -1; + + f->term_count_actual = actual_count; + + if (filter_terms == term_count) { + f->filter = true; } return 0; } -/* Serialize enumeration */ +/* Implementation for iterable mixin */ static -int expr_ser_enum( +void filter_iter_init( const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str) + const ecs_poly_t *poly, + ecs_iter_t *iter, + ecs_term_t *filter) { - const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum); - ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_poly_assert(poly, ecs_filter_t); - int32_t value = *(int32_t*)base; - - /* Enumeration constants are stored in a map that is keyed on the - * enumeration value. */ - ecs_enum_constant_t *constant = ecs_map_get( - enum_type->constants, ecs_enum_constant_t, value); - if (!constant) { - char *path = ecs_get_fullpath(world, op->type); - ecs_err("value %d is not valid for enum type '%s'", value, path); - ecs_os_free(path); - goto error; + if (filter) { + iter[1] = ecs_filter_iter(world, (ecs_filter_t*)poly); + iter[0] = ecs_term_chain_iter(&iter[1], filter); + } else { + iter[0] = ecs_filter_iter(world, (ecs_filter_t*)poly); } - - ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant)); - - return 0; -error: - return -1; } -/* Serialize bitmask */ -static -int expr_ser_bitmask( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) +int ecs_filter_init( + const ecs_world_t *stage, + ecs_filter_t *filter_out, + const ecs_filter_desc_t *desc) { - const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask); - ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_filter_t f; + ecs_poly_init(&f, ecs_filter_t); - uint32_t value = *(uint32_t*)ptr; - ecs_map_key_t key; - ecs_bitmask_constant_t *constant; - int count = 0; + ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(filter_out != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); - ecs_strbuf_list_push(str, "", "|"); + const ecs_world_t *world = ecs_get_world(stage); - /* Multiple flags can be set at a given time. Iterate through all the flags - * and append the ones that are set. */ - ecs_map_iter_t it = ecs_map_iter(bitmask_type->constants); - while ((constant = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { - if ((value & key) == key) { - ecs_strbuf_list_appendstr(str, - ecs_get_name(world, constant->constant)); - count ++; - value -= (uint32_t)key; + int i, term_count = 0; + ecs_term_t *terms = desc->terms_buffer; + const char *name = desc->name; + const char *expr = desc->expr; + + /* Temporarily set the fields to the values provided in desc, until the + * filter has been validated. */ + f.name = (char*)name; + f.expr = (char*)expr; + f.filter = desc->filter; + f.instanced = desc->instanced; + f.match_empty_tables = desc->match_empty_tables; + f.match_anything = true; + + if (terms) { + term_count = desc->terms_buffer_count; + } else { + terms = (ecs_term_t*)desc->terms; + for (i = 0; i < ECS_TERM_DESC_CACHE_SIZE; i ++) { + if (!ecs_term_is_initialized(&terms[i])) { + break; + } + + term_count ++; } } - if (value != 0) { - /* All bits must have been matched by a constant */ - char *path = ecs_get_fullpath(world, op->type); - ecs_err( - "value for bitmask %s contains bits (%u) that cannot be mapped to constant", - path, value); - ecs_os_free(path); - goto error; - } + /* Temporarily set array from desc to filter, until the filter has been + * validated. */ + f.terms = terms; + f.term_count = term_count; - if (!count) { - ecs_strbuf_list_appendstr(str, "0"); - } + if (expr) { +#ifdef FLECS_PARSER + int32_t buffer_count = 0; - ecs_strbuf_list_pop(str, ""); + /* If terms have already been set, copy buffer to allocated one */ + if (terms && term_count) { + terms = ecs_os_memdup(terms, term_count * ECS_SIZEOF(ecs_term_t)); + buffer_count = term_count; + } else { + terms = NULL; + } - return 0; -error: - return -1; -} + /* Parse expression into array of terms */ + const char *ptr = desc->expr; + ecs_term_t term = {0}; + while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term))){ + if (!ecs_term_is_initialized(&term)) { + break; + } + + if (term_count == buffer_count) { + buffer_count = buffer_count ? buffer_count * 2 : 8; + terms = ecs_os_realloc(terms, + buffer_count * ECS_SIZEOF(ecs_term_t)); + } -/* Serialize elements of a contiguous array */ -static -int expr_ser_elements( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - int32_t elem_count, - int32_t elem_size, - ecs_strbuf_t *str) -{ - ecs_strbuf_list_push(str, "[", ", "); + /* Check for identifiers that have a name that starts with _. If the + * variable kind is left to Default, the kind should be set to + * variable and the _ prefix should be removed. */ + finalize_term_vars(world, &term, name); - const void *ptr = base; + terms[term_count] = term; + term_count ++; - int i; - for (i = 0; i < elem_count; i ++) { - ecs_strbuf_list_next(str); - if (expr_ser_type_ops(world, ops, op_count, ptr, str)) { - return -1; + if (ptr[0] == '\n') { + break; + } } - ptr = ECS_OFFSET(ptr, elem_size); + + f.terms = terms; + f.term_count = term_count; + + if (!ptr) { + goto error; + } +#else + ecs_abort(ECS_UNSUPPORTED, "parser addon is not available"); +#endif } - ecs_strbuf_list_pop(str, "]"); + /* Copy term resources. */ + if (term_count) { + ecs_term_t *dst_terms = terms; + if (!f.expr) { + if (term_count <= ECS_TERM_CACHE_SIZE) { + dst_terms = f.term_cache; + f.term_cache_used = true; + } else { + dst_terms = ecs_os_malloc_n(ecs_term_t, term_count); + } + } - return 0; -} + for (i = 0; i < term_count; i ++) { + dst_terms[i] = ecs_term_move(&terms[i]); + } + f.terms = dst_terms; + } else { + f.terms = NULL; + } -static -int expr_ser_type_elements( - const ecs_world_t *world, - ecs_entity_t type, - const void *base, - int32_t elem_count, - ecs_strbuf_t *str) -{ - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); + /* Ensure all fields are consistent and properly filled out */ + if (ecs_filter_finalize(world, &f)) { + goto error; + } - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + *filter_out = f; + if (f.term_cache_used) { + filter_out->terms = filter_out->term_cache; + } + filter_out->name = ecs_os_strdup(desc->name); + filter_out->expr = ecs_os_strdup(desc->expr); - ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); - int32_t op_count = ecs_vector_count(ser->ops); + ecs_assert(!filter_out->term_cache_used || + filter_out->terms == filter_out->term_cache, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(filter_out->term_count == f.term_count, + ECS_INTERNAL_ERROR, NULL); - return expr_ser_elements( - world, ops, op_count, base, elem_count, comp->size, str); -} + filter_out->iterable.init = filter_iter_init; -/* Serialize array */ -static -int expr_ser_array( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) -{ - const EcsArray *a = ecs_get(world, op->type, EcsArray); - ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL); + return 0; +error: + /* NULL members that point to non-owned resources */ + if (!f.expr) { + f.terms = NULL; + } - return expr_ser_type_elements( - world, a->type, ptr, a->count, str); + f.name = NULL; + f.expr = NULL; + + ecs_filter_fini(&f); + + return -1; } -/* Serialize vector */ -static -int expr_ser_vector( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str) +void ecs_filter_copy( + ecs_filter_t *dst, + const ecs_filter_t *src) { - ecs_vector_t *value = *(ecs_vector_t**)base; - if (!value) { - ecs_strbuf_appendstr(str, "null"); - return 0; - } - - const EcsVector *v = ecs_get(world, op->type, EcsVector); - ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL); + if (src) { + *dst = *src; - const EcsComponent *comp = ecs_get(world, v->type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + int32_t term_count = src->term_count; - int32_t count = ecs_vector_count(value); - void *array = ecs_vector_first_t(value, comp->size, comp->alignment); + if (src->term_cache_used) { + dst->terms = dst->term_cache; + } else { + dst->terms = ecs_os_memdup_n(src->terms, ecs_term_t, term_count); + } - /* Serialize contiguous buffer of vector */ - return expr_ser_type_elements(world, v->type, array, count, str); + int i; + for (i = 0; i < term_count; i ++) { + dst->terms[i] = ecs_term_copy(&src->terms[i]); + } + } else { + ecs_os_memset_t(dst, 0, ecs_filter_t); + } } -/* Forward serialization to the different type kinds */ -static -int expr_ser_type_op( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) +void ecs_filter_move( + ecs_filter_t *dst, + ecs_filter_t *src) { - switch(op->kind) { - case EcsOpPush: - case EcsOpPop: - /* Should not be parsed as single op */ - ecs_throw(ECS_INVALID_PARAMETER, NULL); - break; - case EcsOpEnum: - if (expr_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; - } - break; - case EcsOpBitmask: - if (expr_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; + if (src) { + *dst = *src; + + if (src->term_cache_used) { + dst->terms = dst->term_cache; } - break; - case EcsOpArray: - if (expr_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; + + if (dst != src) { + src->terms = NULL; + src->term_count = 0; } - break; - case EcsOpVector: - if (expr_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; + } else { + ecs_os_memset_t(dst, 0, ecs_filter_t); + } +} + +void ecs_filter_fini( + ecs_filter_t *filter) +{ + if (filter->terms) { + int i, count = filter->term_count; + for (i = 0; i < count; i ++) { + ecs_term_fini(&filter->terms[i]); } - break; - default: - if (expr_ser_primitive(world, expr_op_to_primitive_kind(op->kind), - ECS_OFFSET(ptr, op->offset), str)) - { - /* Unknown operation */ - ecs_err("unknown serializer operation kind (%d)", op->kind); - goto error; + + if (!filter->term_cache_used) { + ecs_os_free(filter->terms); } - break; } - return 0; -error: - return -1; + ecs_os_free(filter->name); + ecs_os_free(filter->expr); + + filter->terms = NULL; + filter->name = NULL; + filter->expr = NULL; } -/* Iterate over a slice of the type ops array */ static -int expr_ser_type_ops( +void filter_str_add_id( const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - ecs_strbuf_t *str) + ecs_strbuf_t *buf, + const ecs_term_id_t *id, + bool is_subject, + uint8_t default_set_mask) { - for (int i = 0; i < op_count; i ++) { - ecs_meta_type_op_t *op = &ops[i]; + if (id->name) { + ecs_strbuf_appendstr(buf, id->name); + } else if (id->entity) { + bool id_added = false; + if (!is_subject || id->entity != EcsThis) { + char *path = ecs_get_fullpath(world, id->entity); + ecs_strbuf_appendstr(buf, path); + ecs_os_free(path); + id_added = true; + } - if (op != ops) { - if (op->name) { - ecs_strbuf_list_next(str); - ecs_strbuf_append(str, "%s: ", op->name); + if (id->set.mask != default_set_mask) { + if (id_added) { + ecs_strbuf_list_push(buf, ":", "|"); + } else { + ecs_strbuf_list_push(buf, "", "|"); + } + if (id->set.mask & EcsSelf) { + ecs_strbuf_list_appendstr(buf, "self"); + } + if (id->set.mask & EcsSuperSet) { + ecs_strbuf_list_appendstr(buf, "superset"); + } + if (id->set.mask & EcsSubSet) { + ecs_strbuf_list_appendstr(buf, "subset"); } - int32_t elem_count = op->count; - if (elem_count > 1 && op != ops) { - /* Serialize inline array */ - if (expr_ser_elements(world, op, op->op_count, base, - elem_count, op->size, str)) - { - return -1; - } + if (id->set.relation != EcsIsA) { + ecs_strbuf_list_push(buf, "(", ""); - i += op->op_count - 1; - continue; - } - } - - switch(op->kind) { - case EcsOpPush: - ecs_strbuf_list_push(str, "{", ", "); - break; - case EcsOpPop: - ecs_strbuf_list_pop(str, "}"); - break; - default: - if (expr_ser_type_op(world, op, base, str)) { - goto error; + char *rel_path = ecs_get_fullpath(world, id->set.relation); + ecs_strbuf_appendstr(buf, rel_path); + ecs_os_free(rel_path); + + ecs_strbuf_list_pop(buf, ")"); } - break; + + ecs_strbuf_list_pop(buf, ""); } + } else { + ecs_strbuf_appendstr(buf, "0"); } - - return 0; -error: - return -1; } -/* Iterate over the type ops of a type */ static -int expr_ser_type( +void term_str_w_strbuf( const ecs_world_t *world, - ecs_vector_t *v_ops, - const void *base, - ecs_strbuf_t *str) + const ecs_term_t *term, + ecs_strbuf_t *buf) { - ecs_meta_type_op_t *ops = ecs_vector_first(v_ops, ecs_meta_type_op_t); - int32_t count = ecs_vector_count(v_ops); - return expr_ser_type_ops(world, ops, count, base, str); -} + const ecs_term_id_t *subj = &term->subj; + const ecs_term_id_t *obj = &term->obj; -int ecs_ptr_to_expr_buf( - const ecs_world_t *world, - ecs_entity_t type, - const void *ptr, - ecs_strbuf_t *buf_out) -{ - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - if (ser == NULL) { - char *path = ecs_get_fullpath(world, type); - ecs_err("cannot serialize value for type '%s'", path); - ecs_os_free(path); - goto error; + const uint8_t def_pred_mask = EcsSelf|EcsSubSet; + const uint8_t def_subj_mask = EcsSelf|EcsSuperSet; + const uint8_t def_obj_mask = EcsSelf; + + bool pred_set = ecs_term_id_is_set(&term->pred); + bool subj_set = ecs_term_id_is_set(subj); + bool obj_set = ecs_term_id_is_set(obj); + + if (term->role && term->role != ECS_PAIR) { + ecs_strbuf_appendstr(buf, ecs_role_str(term->role)); + ecs_strbuf_appendstr(buf, " "); } - if (expr_ser_type(world, ser->ops, ptr, buf_out)) { - goto error; + if (term->oper == EcsNot) { + ecs_strbuf_appendstr(buf, "!"); + } else if (term->oper == EcsOptional) { + ecs_strbuf_appendstr(buf, "?"); } - return 0; -error: - return -1; + if (!subj_set) { + filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); + ecs_strbuf_appendstr(buf, "()"); + } else if (subj_set && subj->entity == EcsThis && subj->set.mask == def_subj_mask) + { + if (term->id) { + char *str = ecs_id_str(world, term->id); + ecs_strbuf_appendstr(buf, str); + ecs_os_free(str); + } else if (pred_set) { + filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); + } + } else { + filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); + ecs_strbuf_appendstr(buf, "("); + filter_str_add_id(world, buf, &term->subj, true, def_subj_mask); + if (obj_set) { + ecs_strbuf_appendstr(buf, ","); + filter_str_add_id(world, buf, &term->obj, false, def_obj_mask); + } + ecs_strbuf_appendstr(buf, ")"); + } } -char* ecs_ptr_to_expr( - const ecs_world_t *world, - ecs_entity_t type, - const void* ptr) +char* ecs_term_str( + const ecs_world_t *world, + const ecs_term_t *term) { - ecs_strbuf_t str = ECS_STRBUF_INIT; - - if (ecs_ptr_to_expr_buf(world, type, ptr, &str) != 0) { - ecs_strbuf_reset(&str); - return NULL; - } - - return ecs_strbuf_get(&str); + ecs_strbuf_t buf = ECS_STRBUF_INIT; + term_str_w_strbuf(world, term, &buf); + return ecs_strbuf_get(&buf); } -int ecs_primitive_to_expr_buf( +char* ecs_filter_str( const ecs_world_t *world, - ecs_primitive_kind_t kind, - const void *base, - ecs_strbuf_t *str) + const ecs_filter_t *filter) { - return expr_ser_primitive(world, kind, base, str); -} + ecs_strbuf_t buf = ECS_STRBUF_INIT; -#endif + ecs_check(!filter->term_cache_used || filter->terms == filter->term_cache, + ECS_INVALID_PARAMETER, NULL); + ecs_term_t *terms = filter->terms; + int32_t i, count = filter->term_count; + int32_t or_count = 0; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; -#ifdef FLECS_EXPR + if (i) { + if (terms[i - 1].oper == EcsOr && term->oper == EcsOr) { + ecs_strbuf_appendstr(&buf, " || "); + } else { + ecs_strbuf_appendstr(&buf, ", "); + } + } -char* ecs_chresc( - char *out, - char in, - char delimiter) -{ - char *bptr = out; - switch(in) { - case '\a': - *bptr++ = '\\'; - *bptr = 'a'; - break; - case '\b': - *bptr++ = '\\'; - *bptr = 'b'; - break; - case '\f': - *bptr++ = '\\'; - *bptr = 'f'; - break; - case '\n': - *bptr++ = '\\'; - *bptr = 'n'; - break; - case '\r': - *bptr++ = '\\'; - *bptr = 'r'; - break; - case '\t': - *bptr++ = '\\'; - *bptr = 't'; - break; - case '\v': - *bptr++ = '\\'; - *bptr = 'v'; - break; - case '\\': - *bptr++ = '\\'; - *bptr = '\\'; - break; - default: - if (in == delimiter) { - *bptr++ = '\\'; - *bptr = delimiter; - } else { - *bptr = in; + if (term->oper != EcsOr) { + or_count = 0; } - break; + + if (or_count < 1) { + if (term->inout == EcsIn) { + ecs_strbuf_appendstr(&buf, "[in] "); + } else if (term->inout == EcsInOut) { + ecs_strbuf_appendstr(&buf, "[inout] "); + } else if (term->inout == EcsOut) { + ecs_strbuf_appendstr(&buf, "[out] "); + } else if (term->inout == EcsInOutFilter) { + ecs_strbuf_appendstr(&buf, "[filter] "); + } + } + + if (term->oper == EcsOr) { + or_count ++; + } + + term_str_w_strbuf(world, term, &buf); } - *(++bptr) = '\0'; + return ecs_strbuf_get(&buf); +error: + return NULL; +} - return bptr; +static +ecs_id_t actual_match_id( + ecs_id_t id) +{ + /* Table types don't store CASE, so replace it with corresponding SWITCH */ + if (ECS_HAS_ROLE(id, CASE)) { + return ECS_SWITCH | ECS_PAIR_FIRST(id); + } + + return id; } -const char* ecs_chrparse( - const char *in, - char *out) +static +bool flecs_n_term_match_table( + ecs_world_t *world, + const ecs_term_t *term, + const ecs_table_t *table, + ecs_type_t type, + ecs_id_t *id_out, + int32_t *column_out, + ecs_entity_t *subject_out, + int32_t *match_index_out, + bool first) { - const char *result = in + 1; - char ch; + (void)column_out; + + ecs_entity_t type_id = term->id; + ecs_oper_kind_t oper = term->oper; - if (in[0] == '\\') { - result ++; + const EcsType *term_type = ecs_get(world, type_id, EcsType); + ecs_check(term_type != NULL, ECS_INVALID_PARAMETER, NULL); - switch(in[1]) { - case 'a': - ch = '\a'; - break; - case 'b': - ch = '\b'; - break; - case 'f': - ch = '\f'; - break; - case 'n': - ch = '\n'; - break; - case 'r': - ch = '\r'; - break; - case 't': - ch = '\t'; - break; - case 'v': - ch = '\v'; - break; - case '\\': - ch = '\\'; - break; - case '"': - ch = '"'; - break; - case '0': - ch = '\0'; - break; - case ' ': - ch = ' '; - break; - case '$': - ch = '$'; - break; - default: - goto error; + ecs_id_t *ids = ecs_vector_first(term_type->normalized->type, ecs_id_t); + int32_t i, count = ecs_vector_count(term_type->normalized->type); + ecs_term_t temp = *term; + temp.oper = EcsAnd; + + for (i = 0; i < count; i ++) { + temp.id = ids[i]; + bool result = flecs_term_match_table(world, &temp, table, type, id_out, + 0, subject_out, match_index_out, first); + if (!result && oper == EcsAndFrom) { + return false; + } else + if (result && oper == EcsOrFrom) { + return true; } - } else { - ch = in[0]; } - if (out) { - *out = ch; + if (oper == EcsAndFrom) { + return true; + } else + if (oper == EcsOrFrom) { + return false; } - return result; error: - return NULL; + return false; } -ecs_size_t ecs_stresc( - char *out, - ecs_size_t n, - char delimiter, - const char *in) +bool flecs_term_match_table( + ecs_world_t *world, + const ecs_term_t *term, + const ecs_table_t *table, + ecs_type_t type, + ecs_id_t *id_out, + int32_t *column_out, + ecs_entity_t *subject_out, + int32_t *match_index_out, + bool first) { - const char *ptr = in; - char ch, *bptr = out, buff[3]; - ecs_size_t written = 0; - while ((ch = *ptr++)) { - if ((written += (ecs_size_t)(ecs_chresc( - buff, ch, delimiter) - buff)) <= n) - { - /* If size != 0, an out buffer must be provided. */ - ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL); - *bptr++ = buff[0]; - if ((ch = buff[1])) { - *bptr = ch; - bptr++; - } - } + const ecs_term_id_t *subj = &term->subj; + ecs_oper_kind_t oper = term->oper; + const ecs_table_t *match_table = table; + ecs_type_t match_type = type; + ecs_id_t id = term->id; + + ecs_entity_t subj_entity = subj->entity; + if (!subj_entity) { + id_out[0] = id; /* no source corresponds with Nothing set mask */ + return true; } - if (bptr) { - while (written < n) { - *bptr = '\0'; - bptr++; - written++; + if (oper == EcsAndFrom || oper == EcsOrFrom) { + return flecs_n_term_match_table(world, term, table, type, id_out, column_out, + subject_out, match_index_out, first); + } + + /* If source is not This, search in table of source */ + if (subj_entity != EcsThis) { + match_table = ecs_get_table(world, subj_entity); + if (match_table) { + match_type = match_table->type; + } else { + return false; } + } else { + /* If filter contains This terms, a table must be provided */ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); } - return written; -error: - return 0; -} -char* ecs_astresc( - char delimiter, - const char *in) -{ - if (!in) { - return NULL; + if (!match_type) { + return false; } - ecs_size_t len = ecs_stresc(NULL, 0, delimiter, in); - char *out = ecs_os_malloc_n(char, len + 1); - ecs_stresc(out, len, delimiter, in); - out[len] = '\0'; - return out; -} + ecs_entity_t source = 0; -#endif + /* If first = false, we're searching from an offset. This supports returning + * multiple results when using wildcard filters. */ + int32_t column = 0; + if (!first && column_out && column_out[0] != 0) { + column = column_out[0]; + if (column < 0) { + /* In case column is not from This, flip sign */ + column = -column; + } + /* Remove base 1 offset */ + column --; + } + /* Find location, source and id of match in table type */ + ecs_table_record_t *tr = 0; + column = ecs_search_relation(world, match_table, + column, actual_match_id(id), subj->set.relation, subj->set.min_depth, + subj->set.max_depth, &source, id_out, &tr); -#ifdef FLECS_EXPR + if (tr && match_index_out) { + match_index_out[0] = tr->count; + } -const char *ecs_parse_expr_token( - const char *name, - const char *expr, - const char *ptr, - char *token) -{ - const char *start = ptr; - char *token_ptr = token; + bool result = column != -1; - while ((ptr = ecs_parse_token(name, expr, ptr, token_ptr))) { - if (ptr[0] == '|') { - token_ptr = &token_ptr[ptr - start]; - token_ptr[0] = '|'; - token_ptr[1] = '\0'; - token_ptr ++; - ptr ++; - start = ptr; - } else { - break; + if (oper == EcsNot) { + if (match_index_out) { + match_index_out[0] = 1; } + result = !result; } - return ptr; -} - -const char* ecs_parse_expr( - const ecs_world_t *world, - const char *ptr, - ecs_entity_t type, - void *data_out, - const ecs_parse_expr_desc_t *desc) -{ - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - char token[ECS_MAX_TOKEN_SIZE]; - int depth = 0; - - const char *name = NULL; - const char *expr = NULL; - - ptr = ecs_parse_fluff(ptr, NULL); - - ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, data_out); - if (cur.valid == false) { - return NULL; + if (oper == EcsOptional) { + result = true; } - if (desc) { - name = desc->name; - expr = desc->expr; - cur.lookup_action = desc->lookup_action; - cur.lookup_ctx = desc->lookup_ctx; + if (!result) { + return false; } - while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) { + if (subj_entity != EcsThis) { + if (!source) { + source = subj_entity; + } + } - if (!ecs_os_strcmp(token, "{")) { - ecs_entity_t scope_type = ecs_meta_get_type(&cur); - depth ++; - if (ecs_meta_push(&cur) != 0) { - goto error; - } + if (id_out && column < 0) { + id_out[0] = id; + } - if (ecs_meta_is_collection(&cur)) { - char *path = ecs_get_fullpath(world, scope_type); - ecs_parser_error(name, expr, ptr - expr, - "expected '[' for collection type '%s'", path); - ecs_os_free(path); - return NULL; + if (column_out) { + if (column >= 0) { + column ++; + if (source != 0) { + column *= -1; } + column_out[0] = column; + } else { + column_out[0] = 0; } + } - else if (!ecs_os_strcmp(token, "}")) { - depth --; + if (subject_out) { + subject_out[0] = source; + } - if (ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected ']'"); - return NULL; - } + return result; +} + +bool flecs_filter_match_table( + ecs_world_t *world, + const ecs_filter_t *filter, + const ecs_table_t *table, + ecs_id_t *ids, + int32_t *columns, + ecs_entity_t *subjects, + int32_t *match_indices, + int32_t *matches_left, + bool first, + int32_t skip_term) +{ + ecs_assert(!filter->term_cache_used || filter->terms == filter->term_cache, + ECS_INTERNAL_ERROR, NULL); + + ecs_type_t type = NULL; + if (table) { + type = table->type; + } - if (ecs_meta_pop(&cur) != 0) { - goto error; - } - } + ecs_term_t *terms = filter->terms; + int32_t i, count = filter->term_count; - else if (!ecs_os_strcmp(token, "[")) { - depth ++; - if (ecs_meta_push(&cur) != 0) { - goto error; - } + bool is_or = false; + bool or_result = false; + int32_t match_count = 1; + if (matches_left) { + match_count = *matches_left; + } - if (!ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected '{'"); - return NULL; - } + for (i = 0; i < count; i ++) { + if (i == skip_term) { + continue; } - else if (!ecs_os_strcmp(token, "]")) { - depth --; + ecs_term_t *term = &terms[i]; + ecs_term_id_t *subj = &term->subj; + ecs_oper_kind_t oper = term->oper; + const ecs_table_t *match_table = table; + ecs_type_t match_type = type; + int32_t t_i = term->index; - if (!ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected '}'"); - return NULL; + if (!is_or && oper == EcsOr) { + is_or = true; + or_result = false; + } else if (is_or && oper != EcsOr) { + if (!or_result) { + return false; } - if (ecs_meta_pop(&cur) != 0) { - goto error; - } + is_or = false; } - else if (!ecs_os_strcmp(token, ",")) { - if (ecs_meta_next(&cur) != 0) { - goto error; + ecs_entity_t subj_entity = subj->entity; + if (!subj_entity) { + if (ids) { + ids[t_i] = term->id; } + continue; } - else if (!ecs_os_strcmp(token, "null")) { - if (ecs_meta_set_null(&cur) != 0) { - goto error; + if (subj_entity != EcsThis) { + match_table = ecs_get_table(world, subj_entity); + if (match_table) { + match_type = match_table->type; + } else { + match_type = NULL; } + } else { + /* If filter contains This terms, table must be provided */ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); } - else if (token[0] == '\"') { - if (ecs_meta_set_string_literal(&cur, token) != 0) { - goto error; - } - } + int32_t match_index = 0; - else { - ptr = ecs_parse_fluff(ptr, NULL); + bool result = flecs_term_match_table(world, term, match_table, + match_type, + ids ? &ids[t_i] : NULL, + columns ? &columns[t_i] : NULL, + subjects ? &subjects[t_i] : NULL, + &match_index, + first); - if (ptr[0] == ':') { - /* Member assignment */ - ptr ++; - if (ecs_meta_member(&cur, token) != 0) { - goto error; - } - } else { - if (ecs_meta_set_string(&cur, token) != 0) { - goto error; - } - } + if (is_or) { + or_result |= result; + } else if (!result) { + return false; } - if (!depth) { - break; + if (first && match_index) { + match_count *= match_index; + } + if (match_indices) { + match_indices[t_i] = match_index; } - - ptr = ecs_parse_fluff(ptr, NULL); } - return ptr; -error: - return NULL; -} - -#endif - - - -#ifdef FLECS_SYSTEM -#endif - -#ifdef FLECS_PIPELINE -#endif - -#ifdef FLECS_STATS - -#include + if (matches_left) { + *matches_left = match_count; + } -static -int32_t t_next( - int32_t t) -{ - return (t + 1) % ECS_STAT_WINDOW; + return !is_or || or_result; } static -int32_t t_prev( - int32_t t) +void term_iter_init_no_data( + ecs_term_iter_t *iter) { - return (t - 1 + ECS_STAT_WINDOW) % ECS_STAT_WINDOW; + iter->term = (ecs_term_t){ .index = -1 }; + iter->self_index = NULL; + iter->index = 0; } static -void _record_gauge( - ecs_gauge_t *m, - int32_t t, - float value) +void term_iter_init_wildcard( + const ecs_world_t *world, + ecs_term_iter_t *iter) { - m->avg[t] = value; - m->min[t] = value; - m->max[t] = value; + iter->term = (ecs_term_t){ .index = -1 }; + iter->self_index = flecs_get_id_record(world, EcsAny); + iter->cur = iter->self_index; + flecs_table_cache_iter(&iter->self_index->cache, &iter->it); + iter->index = 0; } static -float _record_counter( - ecs_counter_t *m, - int32_t t, - float value) -{ - int32_t tp = t_prev(t); - float prev = m->value[tp]; - m->value[t] = value; - _record_gauge((ecs_gauge_t*)m, t, value - prev); - return value - prev; -} - -/* Macro's to silence conversion warnings without adding casts everywhere */ -#define record_gauge(m, t, value)\ - _record_gauge(m, t, (float)value) - -#define record_counter(m, t, value)\ - _record_counter(m, t, (float)value) +void term_iter_init( + const ecs_world_t *world, + ecs_term_t *term, + ecs_term_iter_t *iter, + bool empty_tables) +{ + const ecs_term_id_t *subj = &term->subj; -static -void print_value( - const char *name, - float value) -{ - ecs_size_t len = ecs_os_strlen(name); - printf("%s: %*s %.2f\n", name, 32 - len, "", (double)value); -} + iter->term = *term; -static -void print_gauge( - const char *name, - int32_t t, - const ecs_gauge_t *m) -{ - print_value(name, m->avg[t]); -} + if (subj->set.mask == EcsDefaultSet || subj->set.mask & EcsSelf) { + iter->self_index = flecs_get_id_record(world, + actual_match_id(term->id)); + } -static -void print_counter( - const char *name, - int32_t t, - const ecs_counter_t *m) -{ - print_value(name, m->rate.avg[t]); -} + if (subj->set.mask & EcsSuperSet) { + iter->set_index = flecs_get_id_record(world, + ecs_pair(subj->set.relation, EcsWildcard)); + } -void ecs_gauge_reduce( - ecs_gauge_t *dst, - int32_t t_dst, - ecs_gauge_t *src, - int32_t t_src) -{ - ecs_check(dst != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(src != NULL, ECS_INVALID_PARAMETER, NULL); + iter->index = 0; - bool min_set = false; - dst->min[t_dst] = 0; - dst->avg[t_dst] = 0; - dst->max[t_dst] = 0; + ecs_id_record_t *idr; + if (iter->self_index) { + idr = iter->cur = iter->self_index; + } else { + idr = iter->cur = iter->set_index; + } - int32_t i; - for (i = 0; i < ECS_STAT_WINDOW; i ++) { - int32_t t = (t_src + i) % ECS_STAT_WINDOW; - dst->avg[t_dst] += src->avg[t] / (float)ECS_STAT_WINDOW; - if (!min_set || (src->min[t] < dst->min[t_dst])) { - dst->min[t_dst] = src->min[t]; - min_set = true; + if (idr) { + if (empty_tables) { + if ((empty_tables = flecs_table_cache_empty_iter( + &idr->cache, &iter->it))) + { + iter->empty_tables = true; + } } - if ((src->max[t] > dst->max[t_dst])) { - dst->max[t_dst] = src->max[t]; + + if (!empty_tables) { + flecs_table_cache_iter(&idr->cache, &iter->it); } + } else { + term_iter_init_no_data(iter); } -error: - return; } -void ecs_get_world_stats( - const ecs_world_t *world, - ecs_world_stats_t *s) +ecs_iter_t ecs_term_iter( + const ecs_world_t *stage, + ecs_term_t *term) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); - - world = ecs_get_world(world); - - int32_t t = s->t = t_next(s->t); + ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(term->id != 0, ECS_INVALID_PARAMETER, NULL); - float delta_world_time = record_counter(&s->world_time_total_raw, t, world->stats.world_time_total_raw); - record_counter(&s->world_time_total, t, world->stats.world_time_total); - record_counter(&s->frame_time_total, t, world->stats.frame_time_total); - record_counter(&s->system_time_total, t, world->stats.system_time_total); - record_counter(&s->merge_time_total, t, world->stats.merge_time_total); + const ecs_world_t *world = ecs_get_world(stage); - float delta_frame_count = record_counter(&s->frame_count_total, t, world->stats.frame_count_total); - record_counter(&s->merge_count_total, t, world->stats.merge_count_total); - record_counter(&s->pipeline_build_count_total, t, world->stats.pipeline_build_count_total); - record_counter(&s->systems_ran_frame, t, world->stats.systems_ran_frame); + flecs_process_pending_tables(world); - if (delta_world_time != 0.0f && delta_frame_count != 0.0f) { - record_gauge( - &s->fps, t, 1.0f / (delta_world_time / (float)delta_frame_count)); - } else { - record_gauge(&s->fps, t, 0); + if (ecs_term_finalize(world, NULL, term)) { + ecs_throw(ECS_INVALID_PARAMETER, NULL); } - record_gauge(&s->entity_count, t, flecs_sparse_count(ecs_eis(world))); - record_gauge(&s->component_count, t, ecs_count_id(world, ecs_id(EcsComponent))); - record_gauge(&s->query_count, t, flecs_sparse_count(world->queries)); - record_gauge(&s->system_count, t, ecs_count_id(world, ecs_id(EcsSystem))); + ecs_iter_t it = { + .real_world = (ecs_world_t*)world, + .world = (ecs_world_t*)stage, + .term_count = 1, + .next = ecs_term_next + }; - record_counter(&s->new_count, t, world->new_count); - record_counter(&s->bulk_new_count, t, world->bulk_new_count); - record_counter(&s->delete_count, t, world->delete_count); - record_counter(&s->clear_count, t, world->clear_count); - record_counter(&s->add_count, t, world->add_count); - record_counter(&s->remove_count, t, world->remove_count); - record_counter(&s->set_count, t, world->set_count); - record_counter(&s->discard_count, t, world->discard_count); + term_iter_init(world, term, &it.priv.iter.term, false); - /* Compute table statistics */ - int32_t empty_table_count = 0; - int32_t singleton_table_count = 0; - int32_t matched_table_count = 0, matched_entity_count = 0; + return it; +error: + return (ecs_iter_t){ 0 }; +} - int32_t i, count = flecs_sparse_count(&world->store.tables); - for (i = 0; i < count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense(&world->store.tables, - ecs_table_t, i); - int32_t entity_count = ecs_table_count(table); +ecs_iter_t ecs_term_chain_iter( + const ecs_iter_t *chain_it, + ecs_term_t *term) +{ + ecs_check(chain_it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - if (!entity_count) { - empty_table_count ++; - } + ecs_world_t *world = chain_it->real_world; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - /* Singleton tables are tables that have just one entity that also has - * itself in the table type. */ - if (entity_count == 1) { - ecs_entity_t *entities = ecs_vector_first( - table->storage.entities, ecs_entity_t); - if (ecs_search_relation(world, table, 0, entities[0], EcsIsA, - 0, 0, 0, 0, 0) != -1) - { - singleton_table_count ++; - } - } + if (ecs_term_finalize(world, NULL, term)) { + ecs_throw(ECS_INVALID_PARAMETER, NULL); } - record_gauge(&s->matched_table_count, t, matched_table_count); - record_gauge(&s->matched_entity_count, t, matched_entity_count); - - record_gauge(&s->table_count, t, count); - record_gauge(&s->empty_table_count, t, empty_table_count); - record_gauge(&s->singleton_table_count, t, singleton_table_count); + ecs_iter_t it = { + .real_world = (ecs_world_t*)world, + .world = chain_it->world, + .terms = term, + .term_count = 1, + .chain_it = (ecs_iter_t*)chain_it, + .next = ecs_term_next + }; + + term_iter_init(world, term, &it.priv.iter.term, false); + return it; error: - return; + return (ecs_iter_t){ 0 }; } -void ecs_get_query_stats( - const ecs_world_t *world, - const ecs_query_t *query, - ecs_query_stats_t *s) +static +const ecs_table_record_t *next_table( + ecs_term_iter_t *iter) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); - (void)world; + ecs_id_record_t *idr = iter->cur; + if (!idr) { + return NULL; + } - int32_t t = s->t = t_next(s->t); + const ecs_table_record_t *tr; + if (!(tr = flecs_table_cache_next(&iter->it, ecs_table_record_t))) { + if (iter->empty_tables) { + iter->empty_tables = false; + flecs_table_cache_iter(&idr->cache, &iter->it); + tr = flecs_table_cache_next(&iter->it, ecs_table_record_t); + } + } - ecs_iter_t it = ecs_query_iter(world, (ecs_query_t*)query); - record_gauge(&s->matched_entity_count, t, ecs_iter_count(&it)); - record_gauge(&s->matched_table_count, t, ecs_query_table_count(query)); - record_gauge(&s->matched_empty_table_count, t, - ecs_query_empty_table_count(query)); -error: - return; + return tr; } -#ifdef FLECS_SYSTEM -bool ecs_get_system_stats( - const ecs_world_t *world, - ecs_entity_t system, - ecs_system_stats_t *s) +static +bool term_iter_next( + ecs_world_t *world, + ecs_term_iter_t *iter, + bool match_prefab, + bool match_disabled) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); + ecs_table_t *table = iter->table; + ecs_entity_t source = 0; + const ecs_table_record_t *tr; + ecs_term_t *term = &iter->term; - world = ecs_get_world(world); + do { + if (table) { + iter->cur_match ++; + if (iter->cur_match >= iter->match_count) { + table = NULL; + } else { + iter->last_column = ecs_search_offset( + world, table, iter->last_column + 1, term->id, 0); + iter->column = iter->last_column + 1; + if (iter->last_column >= 0) { + iter->id = ecs_vector_get( + table->type, ecs_id_t, iter->last_column)[0]; + } + } + } - const EcsSystem *ptr = ecs_get(world, system, EcsSystem); - if (!ptr) { - return false; - } + if (!table) { + if (!(tr = next_table(iter))) { + if (iter->cur != iter->set_index && iter->set_index != NULL) { + iter->cur = iter->set_index; + flecs_table_cache_iter(&iter->set_index->cache, &iter->it); + iter->index = 0; + tr = next_table(iter); + } - ecs_get_query_stats(world, ptr->query, &s->query_stats); - int32_t t = s->query_stats.t; + if (!tr) { + return false; + } + } - record_counter(&s->time_spent, t, ptr->time_spent); - record_counter(&s->invoke_count, t, ptr->invoke_count); - record_gauge(&s->active, t, !ecs_has_id(world, system, EcsInactive)); - record_gauge(&s->enabled, t, !ecs_has_id(world, system, EcsDisabled)); + table = tr->hdr.table; - return true; -error: - return false; -} -#endif + if (!match_prefab && (table->flags & EcsTableIsPrefab)) { + continue; + } + if (!match_disabled && (table->flags & EcsTableIsDisabled)) { + continue; + } -#ifdef FLECS_PIPELINE + iter->table = table; + iter->match_count = tr->count; + iter->cur_match = 0; + iter->last_column = tr->column; + iter->column = tr->column + 1; + iter->id = ecs_vector_get(table->type, ecs_id_t, tr->column)[0]; + } -static -ecs_system_stats_t* get_system_stats( - ecs_map_t *systems, - ecs_entity_t system) -{ - ecs_check(systems != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); + if (iter->cur == iter->set_index) { + const ecs_term_id_t *subj = &term->subj; - ecs_system_stats_t *s = ecs_map_get(systems, ecs_system_stats_t, system); - if (!s) { - s = ecs_map_ensure(systems, ecs_system_stats_t, system); - } + if (iter->self_index) { + if (flecs_id_record_table(iter->self_index, table) != NULL) { + /* If the table has the id itself and this term matched Self + * we already matched it */ + continue; + } + } - return s; -error: - return NULL; -} + /* Test if following the relation finds the id */ + int32_t index = ecs_search_relation(world, table, 0, + term->id, subj->set.relation, subj->set.min_depth, + subj->set.max_depth, &source, &iter->id, NULL); -bool ecs_get_pipeline_stats( - ecs_world_t *stage, - ecs_entity_t pipeline, - ecs_pipeline_stats_t *s) -{ - ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(pipeline != 0, ECS_INVALID_PARAMETER, NULL); + if (index == -1) { + source = 0; + continue; + } + + ecs_assert(source != 0, ECS_INTERNAL_ERROR, NULL); - const ecs_world_t *world = ecs_get_world(stage); + iter->column = (index + 1) * -1; + } - const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); - if (!pq) { - return false; - } + break; + } while (true); - int32_t sys_count = 0, active_sys_count = 0; + iter->subject = source; - /* Count number of active systems */ - ecs_iter_t it = ecs_query_iter(stage, pq->query); - while (ecs_query_next(&it)) { - active_sys_count += it.count; - } + return true; +} - /* Count total number of systems in pipeline */ - it = ecs_query_iter(stage, pq->build_query); - while (ecs_query_next(&it)) { - sys_count += it.count; - } +bool ecs_term_next( + ecs_iter_t *it) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_term_next, ECS_INVALID_PARAMETER, NULL); - /* Also count synchronization points */ - ecs_vector_t *ops = pq->ops; - ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); - ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); - int32_t pip_count = active_sys_count + ecs_vector_count(ops); + ecs_term_iter_t *iter = &it->priv.iter.term; + ecs_term_t *term = &iter->term; + ecs_world_t *world = it->real_world; + ecs_table_t *table; - if (!sys_count) { - return false; - } + it->ids = &iter->id; + it->subjects = &iter->subject; + it->columns = &iter->column; + it->terms = &iter->term; - if (s->system_stats && !sys_count) { - ecs_map_free(s->system_stats); - } - if (!s->system_stats && sys_count) { - s->system_stats = ecs_map_new(ecs_system_stats_t, sys_count); - } - if (!sys_count) { - s->system_stats = NULL; + if (term->inout != EcsInOutFilter) { + it->sizes = &iter->size; + it->ptrs = &iter->ptr; + } else { + it->sizes = NULL; + it->ptrs = NULL; } - /* Make sure vector is large enough to store all systems & sync points */ - ecs_entity_t *systems = NULL; - if (pip_count) { - ecs_vector_set_count(&s->systems, ecs_entity_t, pip_count); - systems = ecs_vector_first(s->systems, ecs_entity_t); + ecs_iter_t *chain_it = it->chain_it; + if (chain_it) { + ecs_iter_next_action_t next = chain_it->next; + bool match; - /* Populate systems vector, keep track of sync points */ - it = ecs_query_iter(stage, pq->query); - - int32_t i, i_system = 0, ran_since_merge = 0; - while (ecs_query_next(&it)) { - for (i = 0; i < it.count; i ++) { - systems[i_system ++] = it.entities[i]; - ran_since_merge ++; - if (op != op_last && ran_since_merge == op->count) { - ran_since_merge = 0; - op++; - systems[i_system ++] = 0; /* 0 indicates a merge point */ - } + do { + if (!next(chain_it)) { + goto done; } - } - systems[i_system ++] = 0; /* Last merge */ - ecs_assert(pip_count == i_system, ECS_INTERNAL_ERROR, NULL); - } else { - ecs_vector_free(s->systems); - s->systems = NULL; - } + table = chain_it->table; + match = flecs_term_match_table(world, term, table, table->type, + it->ids, it->columns, it->subjects, it->match_indices, true); + } while (!match); + goto yield; - /* Separately populate system stats map from build query, which includes - * systems that aren't currently active */ - it = ecs_query_iter(stage, pq->build_query); - while (ecs_query_next(&it)) { - int i; - for (i = 0; i < it.count; i ++) { - ecs_system_stats_t *sys_stats = get_system_stats( - s->system_stats, it.entities[i]); - ecs_get_system_stats(world, it.entities[i], sys_stats); + } else { + if (!term_iter_next(world, iter, false, false)) { + goto done; } + + table = iter->table; + + /* Source must either be 0 (EcsThis) or nonzero in case of substitution */ + ecs_assert(iter->subject || iter->cur != iter->set_index, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(iter->table != NULL, ECS_INTERNAL_ERROR, NULL); } +yield: + flecs_iter_populate_data(world, it, table, 0, 0, it->ptrs, it->sizes); + it->is_valid = true; return true; +done: error: return false; } -void ecs_pipeline_stats_fini( - ecs_pipeline_stats_t *stats) -{ - ecs_map_free(stats->system_stats); - ecs_vector_free(stats->systems); -} - -#endif - -void ecs_dump_world_stats( +static +const ecs_filter_t* init_filter_iter( const ecs_world_t *world, - const ecs_world_stats_t *s) + ecs_iter_t *it, + const ecs_filter_t *filter) { - int32_t t = s->t; + ecs_filter_iter_t *iter = &it->priv.iter.filter; - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); + if (filter) { + iter->filter = *filter; - world = ecs_get_world(world); - - print_counter("Frame", t, &s->frame_count_total); - printf("-------------------------------------\n"); - print_counter("pipeline rebuilds", t, &s->pipeline_build_count_total); - print_counter("systems ran last frame", t, &s->systems_ran_frame); - printf("\n"); - print_value("target FPS", world->stats.target_fps); - print_value("time scale", world->stats.time_scale); - printf("\n"); - print_gauge("actual FPS", t, &s->fps); - print_counter("frame time", t, &s->frame_time_total); - print_counter("system time", t, &s->system_time_total); - print_counter("merge time", t, &s->merge_time_total); - print_counter("simulation time elapsed", t, &s->world_time_total); - printf("\n"); - print_gauge("entity count", t, &s->entity_count); - print_gauge("component count", t, &s->component_count); - print_gauge("query count", t, &s->query_count); - print_gauge("system count", t, &s->system_count); - print_gauge("table count", t, &s->table_count); - print_gauge("singleton table count", t, &s->singleton_table_count); - print_gauge("empty table count", t, &s->empty_table_count); - printf("\n"); - print_counter("deferred new operations", t, &s->new_count); - print_counter("deferred bulk_new operations", t, &s->bulk_new_count); - print_counter("deferred delete operations", t, &s->delete_count); - print_counter("deferred clear operations", t, &s->clear_count); - print_counter("deferred add operations", t, &s->add_count); - print_counter("deferred remove operations", t, &s->remove_count); - print_counter("deferred set operations", t, &s->set_count); - print_counter("discarded operations", t, &s->discard_count); - printf("\n"); - -error: - return; -} + if (filter->term_cache_used) { + iter->filter.terms = iter->filter.term_cache; + } -#endif + ecs_filter_finalize(world, &iter->filter); + ecs_assert(!filter->term_cache_used || + filter->terms == filter->term_cache, ECS_INTERNAL_ERROR, NULL); + } else { + ecs_filter_init(world, &iter->filter, &(ecs_filter_desc_t) { + .terms = {{ .id = EcsAny }} + }); + filter = &iter->filter; + } -#ifdef FLECS_UNITS + it->term_count = filter->term_count_actual; -ECS_DECLARE(EcsUnitPrefixes); + return filter; +} -ECS_DECLARE(EcsYocto); -ECS_DECLARE(EcsZepto); -ECS_DECLARE(EcsAtto); -ECS_DECLARE(EcsFemto); -ECS_DECLARE(EcsPico); -ECS_DECLARE(EcsNano); -ECS_DECLARE(EcsMicro); -ECS_DECLARE(EcsMilli); -ECS_DECLARE(EcsCenti); -ECS_DECLARE(EcsDeci); -ECS_DECLARE(EcsDeca); -ECS_DECLARE(EcsHecto); -ECS_DECLARE(EcsKilo); -ECS_DECLARE(EcsMega); -ECS_DECLARE(EcsGiga); -ECS_DECLARE(EcsTera); -ECS_DECLARE(EcsPeta); -ECS_DECLARE(EcsExa); -ECS_DECLARE(EcsZetta); -ECS_DECLARE(EcsYotta); +int32_t ecs_filter_pivot_term( + const ecs_world_t *world, + const ecs_filter_t *filter) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL); -ECS_DECLARE(EcsKibi); -ECS_DECLARE(EcsMebi); -ECS_DECLARE(EcsGibi); -ECS_DECLARE(EcsTebi); -ECS_DECLARE(EcsPebi); -ECS_DECLARE(EcsExbi); -ECS_DECLARE(EcsZebi); -ECS_DECLARE(EcsYobi); + ecs_term_t *terms = filter->terms; + int32_t i, term_count = filter->term_count; + int32_t pivot_term = -1, min_count = -1; -ECS_DECLARE(EcsDuration); - ECS_DECLARE(EcsPicoSeconds); - ECS_DECLARE(EcsNanoSeconds); - ECS_DECLARE(EcsMicroSeconds); - ECS_DECLARE(EcsMilliSeconds); - ECS_DECLARE(EcsSeconds); - ECS_DECLARE(EcsMinutes); - ECS_DECLARE(EcsHours); - ECS_DECLARE(EcsDays); + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; + ecs_id_t id = term->id; -ECS_DECLARE(EcsTime); - ECS_DECLARE(EcsDate); + if (term->oper != EcsAnd) { + continue; + } -ECS_DECLARE(EcsMass); - ECS_DECLARE(EcsGrams); - ECS_DECLARE(EcsKiloGrams); + if (term->subj.entity != EcsThis) { + continue; + } -ECS_DECLARE(EcsElectricCurrent); - ECS_DECLARE(EcsAmpere); + ecs_id_record_t *idr = flecs_get_id_record(world, + actual_match_id(id)); + if (!idr) { + /* If one of the terms does not match with any data, iterator + * should not return anything */ + return -2; /* -2 indicates filter doesn't match anything */ + } -ECS_DECLARE(EcsAmount); - ECS_DECLARE(EcsMole); + int32_t table_count = ecs_table_cache_count(&idr->cache); + if (min_count == -1 || table_count < min_count) { + min_count = table_count; + pivot_term = i; + } + } -ECS_DECLARE(EcsLuminousIntensity); - ECS_DECLARE(EcsCandela); + return pivot_term; +error: + return -2; +} -ECS_DECLARE(EcsForce); - ECS_DECLARE(EcsNewton); +ecs_iter_t ecs_filter_iter( + const ecs_world_t *stage, + const ecs_filter_t *filter) +{ + ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); -ECS_DECLARE(EcsLength); - ECS_DECLARE(EcsMeters); - ECS_DECLARE(EcsPicoMeters); - ECS_DECLARE(EcsNanoMeters); - ECS_DECLARE(EcsMicroMeters); - ECS_DECLARE(EcsMilliMeters); - ECS_DECLARE(EcsCentiMeters); - ECS_DECLARE(EcsKiloMeters); - ECS_DECLARE(EcsMiles); + const ecs_world_t *world = ecs_get_world(stage); + + flecs_process_pending_tables(world); -ECS_DECLARE(EcsPressure); - ECS_DECLARE(EcsPascal); - ECS_DECLARE(EcsBar); + ecs_iter_t it = { + .real_world = (ecs_world_t*)world, + .world = (ecs_world_t*)stage, + .terms = filter ? filter->terms : NULL, + .next = ecs_filter_next, + .is_instanced = filter ? filter->instanced : false + }; -ECS_DECLARE(EcsSpeed); - ECS_DECLARE(EcsMetersPerSecond); - ECS_DECLARE(EcsKiloMetersPerSecond); - ECS_DECLARE(EcsKiloMetersPerHour); - ECS_DECLARE(EcsMilesPerHour); + ecs_filter_iter_t *iter = &it.priv.iter.filter; -ECS_DECLARE(EcsAcceleration); + filter = init_filter_iter(world, &it, filter); -ECS_DECLARE(EcsTemperature); - ECS_DECLARE(EcsKelvin); - ECS_DECLARE(EcsCelsius); - ECS_DECLARE(EcsFahrenheit); + /* Find term that represents smallest superset */ + if (filter->match_this) { + ecs_term_t *terms = filter->terms; + int32_t pivot_term = -1; + ecs_check(terms != NULL, ECS_INVALID_PARAMETER, NULL); -ECS_DECLARE(EcsData); - ECS_DECLARE(EcsBits); - ECS_DECLARE(EcsKiloBits); - ECS_DECLARE(EcsMegaBits); - ECS_DECLARE(EcsGigaBits); - ECS_DECLARE(EcsBytes); - ECS_DECLARE(EcsKiloBytes); - ECS_DECLARE(EcsMegaBytes); - ECS_DECLARE(EcsGigaBytes); - ECS_DECLARE(EcsKibiBytes); - ECS_DECLARE(EcsGibiBytes); - ECS_DECLARE(EcsMebiBytes); + iter->kind = EcsIterEvalIndex; -ECS_DECLARE(EcsDataRate); - ECS_DECLARE(EcsBitsPerSecond); - ECS_DECLARE(EcsKiloBitsPerSecond); - ECS_DECLARE(EcsMegaBitsPerSecond); - ECS_DECLARE(EcsGigaBitsPerSecond); - ECS_DECLARE(EcsBytesPerSecond); - ECS_DECLARE(EcsKiloBytesPerSecond); - ECS_DECLARE(EcsMegaBytesPerSecond); - ECS_DECLARE(EcsGigaBytesPerSecond); + pivot_term = ecs_filter_pivot_term(world, filter); -ECS_DECLARE(EcsPercentage); + if (pivot_term == -2) { + /* One or more terms have no matching results */ + term_iter_init_no_data(&iter->term_iter); + return it; + } else if (pivot_term == -1) { + /* No terms meet the criteria to be a pivot term, evaluate filter + * against all tables */ + term_iter_init_wildcard(world, &iter->term_iter); + } else { + ecs_assert(pivot_term >= 0, ECS_INTERNAL_ERROR, NULL); + term_iter_init(world, &terms[pivot_term], &iter->term_iter, + filter->match_empty_tables); + } -ECS_DECLARE(EcsAngle); - ECS_DECLARE(EcsRadians); - ECS_DECLARE(EcsDegrees); + iter->term_iter.empty_tables = filter->match_empty_tables; + } else { + if (!filter->match_anything) { + iter->kind = EcsIterEvalCondition; + term_iter_init_no_data(&iter->term_iter); + } else { + iter->kind = EcsIterEvalNone; + } + } -ECS_DECLARE(EcsBel); -ECS_DECLARE(EcsDeciBel); + if (filter->terms == filter->term_cache) { + /* Because we're returning the iterator by value, the address of the + * term cache changes. The ecs_filter_next function will set the correct + * address when it detects that terms is set to NULL */ + iter->filter.terms = NULL; + } -void FlecsUnitsImport( - ecs_world_t *world) -{ - ECS_MODULE(world, FlecsUnits); + it.is_filter = filter->filter; - ecs_set_name_prefix(world, "Ecs"); + return it; +error: + return (ecs_iter_t){ 0 }; +} - EcsUnitPrefixes = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = "prefixes", - .add = { EcsModule } - }); +ecs_iter_t ecs_filter_chain_iter( + const ecs_iter_t *chain_it, + const ecs_filter_t *filter) +{ + ecs_iter_t it = { + .terms = filter->terms, + .term_count = filter->term_count, + .world = chain_it->world, + .real_world = chain_it->real_world, + .chain_it = (ecs_iter_t*)chain_it, + .next = ecs_filter_next + }; - /* Initialize unit prefixes */ + ecs_filter_iter_t *iter = &it.priv.iter.filter; + init_filter_iter(it.world, &it, filter); - ecs_entity_t prev_scope = ecs_set_scope(world, EcsUnitPrefixes); + iter->kind = EcsIterEvalChain; - EcsYocto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Yocto", - .symbol = "y", - .translation = { .factor = 10, .power = -24 } - }); - EcsZepto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Zepto", - .symbol = "z", - .translation = { .factor = 10, .power = -21 } - }); - EcsAtto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Atto", - .symbol = "a", - .translation = { .factor = 10, .power = -18 } - }); - EcsFemto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Femto", - .symbol = "a", - .translation = { .factor = 10, .power = -15 } - }); - EcsPico = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Pico", - .symbol = "p", - .translation = { .factor = 10, .power = -12 } - }); - EcsNano = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Nano", - .symbol = "n", - .translation = { .factor = 10, .power = -9 } - }); - EcsMicro = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Micro", - .symbol = "μ", - .translation = { .factor = 10, .power = -6 } - }); - EcsMilli = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Milli", - .symbol = "m", - .translation = { .factor = 10, .power = -3 } - }); - EcsCenti = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Centi", - .symbol = "c", - .translation = { .factor = 10, .power = -2 } - }); - EcsDeci = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Deci", - .symbol = "d", - .translation = { .factor = 10, .power = -1 } - }); - EcsDeca = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Deca", - .symbol = "da", - .translation = { .factor = 10, .power = 1 } - }); - EcsHecto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Hecto", - .symbol = "h", - .translation = { .factor = 10, .power = 2 } - }); - EcsKilo = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Kilo", - .symbol = "k", - .translation = { .factor = 10, .power = 3 } - }); - EcsMega = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Mega", - .symbol = "M", - .translation = { .factor = 10, .power = 6 } - }); - EcsGiga = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Giga", - .symbol = "G", - .translation = { .factor = 10, .power = 9 } - }); - EcsTera = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Tera", - .symbol = "T", - .translation = { .factor = 10, .power = 12 } - }); - EcsPeta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Peta", - .symbol = "P", - .translation = { .factor = 10, .power = 15 } - }); - EcsExa = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Exa", - .symbol = "E", - .translation = { .factor = 10, .power = 18 } - }); - EcsZetta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Zetta", - .symbol = "Z", - .translation = { .factor = 10, .power = 21 } - }); - EcsYotta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Yotta", - .symbol = "Y", - .translation = { .factor = 10, .power = 24 } - }); + if (filter->terms == filter->term_cache) { + /* See ecs_filter_iter */ + iter->filter.terms = NULL; + } - EcsKibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Kibi", - .symbol = "Ki", - .translation = { .factor = 1024, .power = 1 } - }); - EcsMebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Mebi", - .symbol = "Mi", - .translation = { .factor = 1024, .power = 2 } - }); - EcsGibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Gibi", - .symbol = "Gi", - .translation = { .factor = 1024, .power = 3 } - }); - EcsTebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Tebi", - .symbol = "Ti", - .translation = { .factor = 1024, .power = 4 } - }); - EcsPebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Pebi", - .symbol = "Pi", - .translation = { .factor = 1024, .power = 5 } - }); - EcsExbi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Exbi", - .symbol = "Ei", - .translation = { .factor = 1024, .power = 6 } - }); - EcsZebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Zebi", - .symbol = "Zi", - .translation = { .factor = 1024, .power = 7 } - }); - EcsYobi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { - .entity.name = "Yobi", - .symbol = "Yi", - .translation = { .factor = 1024, .power = 8 } - }); + return it; +} - ecs_set_scope(world, prev_scope); +bool ecs_filter_next( + ecs_iter_t *it) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL); - /* Duration units */ + if (flecs_iter_next_row(it)) { + return true; + } - EcsDuration = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Duration" }); - prev_scope = ecs_set_scope(world, EcsDuration); + return flecs_iter_next_instanced(it, ecs_filter_next_instanced(it)); +error: + return false; +} - EcsSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Seconds", - .quantity = EcsDuration, - .symbol = "s" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsSeconds, - .kind = EcsF32 - }); - EcsPicoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "PicoSeconds", - .quantity = EcsDuration, - .base = EcsSeconds, - .prefix = EcsPico }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsPicoSeconds, - .kind = EcsF32 - }); +bool ecs_filter_next_instanced( + ecs_iter_t *it) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->chain_it != it, ECS_INVALID_PARAMETER, NULL); + ecs_filter_iter_t *iter = &it->priv.iter.filter; + ecs_filter_t *filter = &iter->filter; + ecs_world_t *world = it->real_world; + ecs_table_t *table = NULL; + bool match; - EcsNanoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "NanoSeconds", - .quantity = EcsDuration, - .base = EcsSeconds, - .prefix = EcsNano }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsNanoSeconds, - .kind = EcsF32 - }); + if (!filter->terms) { + filter->terms = filter->term_cache; + } - EcsMicroSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MicroSeconds", - .quantity = EcsDuration, - .base = EcsSeconds, - .prefix = EcsMicro }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMicroSeconds, - .kind = EcsF32 - }); + flecs_iter_init(it); - EcsMilliSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MilliSeconds", - .quantity = EcsDuration, - .base = EcsSeconds, - .prefix = EcsMilli }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMilliSeconds, - .kind = EcsF32 - }); + ecs_iter_t *chain_it = it->chain_it; + ecs_iter_kind_t kind = iter->kind; - EcsMinutes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Minutes", - .quantity = EcsDuration, - .base = EcsSeconds, - .symbol = "min", - .translation = { .factor = 60, .power = 1 } }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMinutes, - .kind = EcsU32 - }); + if (chain_it) { + ecs_assert(kind == EcsIterEvalChain, ECS_INVALID_PARAMETER, NULL); + + ecs_iter_next_action_t next = chain_it->next; + do { + if (!next(chain_it)) { + goto done; + } - EcsHours = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Hours", - .quantity = EcsDuration, - .base = EcsMinutes, - .symbol = "h", - .translation = { .factor = 60, .power = 1 } }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsHours, - .kind = EcsU32 - }); + table = chain_it->table; + match = flecs_filter_match_table(world, filter, table, + it->ids, it->columns, it->subjects, it->match_indices, NULL, + true, -1); + } while (!match); - EcsDays = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Days", - .quantity = EcsDuration, - .base = EcsHours, - .symbol = "d", - .translation = { .factor = 24, .power = 1 } }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsDays, - .kind = EcsU32 - }); - ecs_set_scope(world, prev_scope); + goto yield; + } else if (kind == EcsIterEvalIndex || kind == EcsIterEvalCondition) { + ecs_term_iter_t *term_iter = &iter->term_iter; + ecs_term_t *term = &term_iter->term; + int32_t pivot_term = term->index; + bool first; - /* Time units */ + do { + first = iter->matches_left == 0; - EcsTime = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Time" }); - prev_scope = ecs_set_scope(world, EcsTime); + if (first) { + if (kind != EcsIterEvalCondition) { + /* Find new match, starting with the leading term */ + if (!term_iter_next(world, term_iter, + filter->match_prefab, filter->match_disabled)) + { + goto done; + } - EcsDate = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Date", - .quantity = EcsTime }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsDate, - .kind = EcsU32 - }); - ecs_set_scope(world, prev_scope); + ecs_assert(term_iter->match_count != 0, + ECS_INTERNAL_ERROR, NULL); - /* Mass units */ + if (pivot_term == -1) { + /* Without a pivot term, we're iterating all tables with + * a wildcard, so the match count is meaningless. */ + term_iter->match_count = 1; + } - EcsMass = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Mass" }); - prev_scope = ecs_set_scope(world, EcsMass); - EcsGrams = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Grams", - .quantity = EcsMass, - .symbol = "g" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGrams, - .kind = EcsF32 - }); - EcsKiloGrams = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloGrams", - .quantity = EcsMass, - .prefix = EcsKilo, - .base = EcsGrams }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloGrams, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + iter->matches_left = term_iter->match_count; - /* Electric current units */ + /* Filter iterator takes control over iterating all the + * permutations that match the wildcard. */ + term_iter->match_count = 1; - EcsElectricCurrent = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "ElectricCurrent" }); - prev_scope = ecs_set_scope(world, EcsElectricCurrent); - EcsAmpere = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Ampere", - .quantity = EcsElectricCurrent, - .symbol = "A" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsAmpere, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + table = term_iter->table; + if (pivot_term != -1) { + it->ids[pivot_term] = term_iter->id; + it->subjects[pivot_term] = term_iter->subject; + it->columns[pivot_term] = term_iter->column; + } + } else { + /* Progress iterator to next match for table, if any */ + table = it->table; + if (term_iter->index == 0) { + iter->matches_left = 1; + term_iter->index = 1; /* prevents looping again */ + } else { + goto done; + } + } - /* Amount of substance units */ + /* Match the remainder of the terms */ + match = flecs_filter_match_table(world, filter, table, + it->ids, it->columns, it->subjects, + it->match_indices, &iter->matches_left, first, + pivot_term); + if (!match) { + iter->matches_left = 0; + continue; + } + + ecs_assert(iter->matches_left != 0, ECS_INTERNAL_ERROR, NULL); + } - EcsAmount = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Amount" }); - prev_scope = ecs_set_scope(world, EcsAmount); - EcsMole = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Mole", - .quantity = EcsAmount, - .symbol = "mol" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMole, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + /* If this is not the first result for the table, and the table + * is matched more than once, iterate remaining matches */ + if (!first && (iter->matches_left > 0)) { + table = it->table; + + /* Find first term that still has matches left */ + int32_t i, j, count = it->term_count; + for (i = count - 1; i >= 0; i --) { + int32_t mi = -- it->match_indices[i]; + if (mi) { + break; + } + } - /* Luminous intensity units */ + /* Progress first term to next match (must be at least one) */ + it->columns[i] ++; + flecs_term_match_table(world, &filter->terms[i], table, + table->type, &it->ids[i], &it->columns[i], &it->subjects[i], + &it->match_indices[i], false); - EcsLuminousIntensity = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "LuminousIntensity" }); - prev_scope = ecs_set_scope(world, EcsLuminousIntensity); - EcsCandela = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Candela", - .quantity = EcsLuminousIntensity, - .symbol = "cd" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsCandela, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + /* Reset remaining terms (if any) to first match */ + for (j = i + 1; j < count; j ++) { + flecs_term_match_table(world, &filter->terms[j], table, + table->type, &it->ids[j], &it->columns[j], + &it->subjects[j], &it->match_indices[j], true); + } + } - /* Force units */ + match = iter->matches_left != 0; + iter->matches_left --; - EcsForce = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Force" }); - prev_scope = ecs_set_scope(world, EcsForce); - EcsNewton = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Newton", - .quantity = EcsForce, - .symbol = "N" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsNewton, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + ecs_assert(iter->matches_left >= 0, ECS_INTERNAL_ERROR, NULL); + } while (!match); - /* Length units */ + goto yield; + } - EcsLength = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Length" }); - prev_scope = ecs_set_scope(world, EcsLength); - EcsMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Meters", - .quantity = EcsLength, - .symbol = "m" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMeters, - .kind = EcsF32 - }); +done: +error: + ecs_iter_fini(it); + return false; - EcsPicoMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "PicoMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsPico }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsPicoMeters, - .kind = EcsF32 - }); +yield: + it->offset = 0; + flecs_iter_populate_data(world, it, table, 0, 0, it->ptrs, it->sizes); + it->is_valid = true; + return true; +} - EcsNanoMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "NanoMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsNano }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsNanoMeters, - .kind = EcsF32 - }); - EcsMicroMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MicroMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsMicro }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMicroMeters, - .kind = EcsF32 - }); +#ifdef FLECS_TIMER - EcsMilliMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MilliMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsMilli }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMilliMeters, - .kind = EcsF32 - }); +static +void AddTickSource(ecs_iter_t *it) { + int32_t i; + for (i = 0; i < it->count; i ++) { + ecs_set(it->world, it->entities[i], EcsTickSource, {0}); + } +} - EcsCentiMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "CentiMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsCenti }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsCentiMeters, - .kind = EcsF32 - }); +static +void ProgressTimers(ecs_iter_t *it) { + EcsTimer *timer = ecs_term(it, EcsTimer, 1); + EcsTickSource *tick_source = ecs_term(it, EcsTickSource, 2); - EcsKiloMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloMeters", - .quantity = EcsLength, - .base = EcsMeters, - .prefix = EcsKilo }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloMeters, - .kind = EcsF32 - }); - - EcsMiles = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Miles", - .quantity = EcsLength, - .symbol = "mi" - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMiles, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + ecs_assert(timer != NULL, ECS_INTERNAL_ERROR, NULL); - /* Pressure units */ + int i; + for (i = 0; i < it->count; i ++) { + tick_source[i].tick = false; - EcsPressure = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Pressure" }); - prev_scope = ecs_set_scope(world, EcsPressure); - EcsPascal = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Pascal", - .quantity = EcsPressure, - .symbol = "Pa" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsPascal, - .kind = EcsF32 - }); - EcsBar = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Bar", - .quantity = EcsPressure, - .symbol = "bar" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBar, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); + if (!timer[i].active) { + continue; + } + + const ecs_world_info_t *info = ecs_get_world_info(it->world); + FLECS_FLOAT time_elapsed = timer[i].time + info->delta_time_raw; + FLECS_FLOAT timeout = timer[i].timeout; + + if (time_elapsed >= timeout) { + FLECS_FLOAT t = time_elapsed - timeout; + if (t > timeout) { + t = 0; + } + + timer[i].time = t; /* Initialize with remainder */ + tick_source[i].tick = true; + tick_source[i].time_elapsed = time_elapsed; + + if (timer[i].single_shot) { + timer[i].active = false; + } + } else { + timer[i].time = time_elapsed; + } + } +} + +static +void ProgressRateFilters(ecs_iter_t *it) { + EcsRateFilter *filter = ecs_term(it, EcsRateFilter, 1); + EcsTickSource *tick_dst = ecs_term(it, EcsTickSource, 2); + + int i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t src = filter[i].src; + bool inc = false; + + filter[i].time_elapsed += it->delta_time; + + if (src) { + const EcsTickSource *tick_src = ecs_get(it->world, src, EcsTickSource); + if (tick_src) { + inc = tick_src->tick; + } else { + inc = true; + } + } else { + inc = true; + } - /* Speed units */ + if (inc) { + filter[i].tick_count ++; + bool triggered = !(filter[i].tick_count % filter[i].rate); + tick_dst[i].tick = triggered; + tick_dst[i].time_elapsed = filter[i].time_elapsed; - EcsSpeed = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Speed" }); - prev_scope = ecs_set_scope(world, EcsSpeed); - EcsMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MetersPerSecond", - .quantity = EcsSpeed, - .base = EcsMeters, - .over = EcsSeconds }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMetersPerSecond, - .kind = EcsF32 - }); - EcsKiloMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloMetersPerSecond", - .quantity = EcsSpeed, - .base = EcsKiloMeters, - .over = EcsSeconds }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloMetersPerSecond, - .kind = EcsF32 - }); - EcsKiloMetersPerHour = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloMetersPerHour", - .quantity = EcsSpeed, - .base = EcsKiloMeters, - .over = EcsHours }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloMetersPerHour, - .kind = EcsF32 - }); - EcsMilesPerHour = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MilesPerHour", - .quantity = EcsSpeed, - .base = EcsMiles, - .over = EcsHours }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMilesPerHour, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); - - /* Acceleration */ + if (triggered) { + filter[i].time_elapsed = 0; + } + } else { + tick_dst[i].tick = false; + } + } +} - EcsAcceleration = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Acceleration", - .base = EcsMetersPerSecond, - .over = EcsSeconds }); - ecs_quantity_init(world, &(ecs_entity_desc_t) { - .entity = EcsAcceleration - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsAcceleration, - .kind = EcsF32 - }); +static +void ProgressTickSource(ecs_iter_t *it) { + EcsTickSource *tick_src = ecs_term(it, EcsTickSource, 1); - /* Temperature units */ + /* If tick source has no filters, tick unconditionally */ + int i; + for (i = 0; i < it->count; i ++) { + tick_src[i].tick = true; + tick_src[i].time_elapsed = it->delta_time; + } +} - EcsTemperature = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Temperature" }); - prev_scope = ecs_set_scope(world, EcsTemperature); - EcsKelvin = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Kelvin", - .quantity = EcsTemperature, - .symbol = "K" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKelvin, - .kind = EcsF32 - }); - EcsCelsius = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Celsius", - .quantity = EcsTemperature, - .symbol = "°C" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsCelsius, - .kind = EcsF32 - }); - EcsFahrenheit = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Fahrenheit", - .quantity = EcsTemperature, - .symbol = "F" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsFahrenheit, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); +ecs_entity_t ecs_set_timeout( + ecs_world_t *world, + ecs_entity_t timer, + FLECS_FLOAT timeout) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - /* Data units */ + timer = ecs_set(world, timer, EcsTimer, { + .timeout = timeout, + .single_shot = true, + .active = true + }); - EcsData = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Data" }); - prev_scope = ecs_set_scope(world, EcsData); + EcsSystem *system_data = ecs_get_mut(world, timer, EcsSystem, NULL); + if (system_data) { + system_data->tick_source = timer; + } - EcsBits = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Bits", - .quantity = EcsData, - .symbol = "bit" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBits, - .kind = EcsU64 - }); +error: + return timer; +} - EcsKiloBits = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloBits", - .quantity = EcsData, - .base = EcsBits, - .prefix = EcsKilo }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloBits, - .kind = EcsU64 - }); +FLECS_FLOAT ecs_get_timeout( + const ecs_world_t *world, + ecs_entity_t timer) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(timer != 0, ECS_INVALID_PARAMETER, NULL); - EcsMegaBits = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MegaBits", - .quantity = EcsData, - .base = EcsBits, - .prefix = EcsMega }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMegaBits, - .kind = EcsU64 - }); + const EcsTimer *value = ecs_get(world, timer, EcsTimer); + if (value) { + return value->timeout; + } +error: + return 0; +} - EcsGigaBits = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "GigaBits", - .quantity = EcsData, - .base = EcsBits, - .prefix = EcsGiga }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGigaBits, - .kind = EcsU64 - }); +ecs_entity_t ecs_set_interval( + ecs_world_t *world, + ecs_entity_t timer, + FLECS_FLOAT interval) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - EcsBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Bytes", - .quantity = EcsData, - .symbol = "B", - .base = EcsBits, - .translation = { .factor = 8, .power = 1 } }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBytes, - .kind = EcsU64 - }); + timer = ecs_set(world, timer, EcsTimer, { + .timeout = interval, + .active = true + }); - EcsKiloBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsKilo }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloBytes, - .kind = EcsU64 - }); + EcsSystem *system_data = ecs_get_mut(world, timer, EcsSystem, NULL); + if (system_data) { + system_data->tick_source = timer; + } +error: + return timer; +} - EcsMegaBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MegaBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsMega }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMegaBytes, - .kind = EcsU64 - }); +FLECS_FLOAT ecs_get_interval( + const ecs_world_t *world, + ecs_entity_t timer) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - EcsGigaBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "GigaBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsGiga }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGigaBytes, - .kind = EcsU64 - }); + if (!timer) { + return 0; + } - EcsKibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KibiBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsKibi }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKibiBytes, - .kind = EcsU64 - }); + const EcsTimer *value = ecs_get(world, timer, EcsTimer); + if (value) { + return value->timeout; + } +error: + return 0; +} - EcsMebiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MebiBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsMebi }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMebiBytes, - .kind = EcsU64 - }); +void ecs_start_timer( + ecs_world_t *world, + ecs_entity_t timer) +{ + EcsTimer *ptr = ecs_get_mut(world, timer, EcsTimer, NULL); + ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ptr->active = true; + ptr->time = 0; +error: + return; +} - EcsGibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "GibiBytes", - .quantity = EcsData, - .base = EcsBytes, - .prefix = EcsGibi }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGibiBytes, - .kind = EcsU64 - }); +void ecs_stop_timer( + ecs_world_t *world, + ecs_entity_t timer) +{ + EcsTimer *ptr = ecs_get_mut(world, timer, EcsTimer, NULL); + ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ptr->active = false; +error: + return; +} - ecs_set_scope(world, prev_scope); +ecs_entity_t ecs_set_rate( + ecs_world_t *world, + ecs_entity_t filter, + int32_t rate, + ecs_entity_t source) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - /* DataRate units */ + filter = ecs_set(world, filter, EcsRateFilter, { + .rate = rate, + .src = source + }); - EcsDataRate = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "DataRate" }); - prev_scope = ecs_set_scope(world, EcsDataRate); + EcsSystem *system_data = ecs_get_mut(world, filter, EcsSystem, NULL); + if (system_data) { + system_data->tick_source = filter; + } - EcsBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "BitsPerSecond", - .quantity = EcsDataRate, - .base = EcsBits, - .over = EcsSeconds }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBitsPerSecond, - .kind = EcsU64 - }); +error: + return filter; +} - EcsKiloBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloBitsPerSecond", - .quantity = EcsDataRate, - .base = EcsKiloBits, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloBitsPerSecond, - .kind = EcsU64 - }); +void ecs_set_tick_source( + ecs_world_t *world, + ecs_entity_t system, + ecs_entity_t tick_source) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(tick_source != 0, ECS_INVALID_PARAMETER, NULL); - EcsMegaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MegaBitsPerSecond", - .quantity = EcsDataRate, - .base = EcsMegaBits, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMegaBitsPerSecond, - .kind = EcsU64 - }); + EcsSystem *system_data = ecs_get_mut(world, system, EcsSystem, NULL); + ecs_check(system_data != NULL, ECS_INVALID_PARAMETER, NULL); - EcsGigaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "GigaBitsPerSecond", - .quantity = EcsDataRate, - .base = EcsGigaBits, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGigaBitsPerSecond, - .kind = EcsU64 - }); + system_data->tick_source = tick_source; +error: + return; +} - EcsBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "BytesPerSecond", - .quantity = EcsDataRate, - .base = EcsBytes, - .over = EcsSeconds }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBytesPerSecond, - .kind = EcsU64 - }); +void FlecsTimerImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsTimer); - EcsKiloBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "KiloBytesPerSecond", - .quantity = EcsDataRate, - .base = EcsKiloBytes, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsKiloBytesPerSecond, - .kind = EcsU64 - }); + ECS_IMPORT(world, FlecsPipeline); - EcsMegaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "MegaBytesPerSecond", - .quantity = EcsDataRate, - .base = EcsMegaBytes, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsMegaBytesPerSecond, - .kind = EcsU64 - }); + ecs_set_name_prefix(world, "Ecs"); - EcsGigaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "GigaBytesPerSecond", - .quantity = EcsDataRate, - .base = EcsGigaBytes, - .over = EcsSeconds - }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsGigaBytesPerSecond, - .kind = EcsU64 - }); + flecs_bootstrap_component(world, EcsTimer); + flecs_bootstrap_component(world, EcsRateFilter); - ecs_set_scope(world, prev_scope); + /* Add EcsTickSource to timers and rate filters */ + ecs_system_init(world, &(ecs_system_desc_t) { + .entity = { .name = "AddTickSource", .add = { EcsPreFrame } }, + .query.filter.terms = { + { .id = ecs_id(EcsTimer), .oper = EcsOr, .inout = EcsIn }, + { .id = ecs_id(EcsRateFilter), .oper = EcsOr, .inout = EcsIn }, + { .id = ecs_id(EcsTickSource), .oper = EcsNot, .inout = EcsOut} + }, + .callback = AddTickSource + }); - /* Percentage */ + /* Timer handling */ + ecs_system_init(world, &(ecs_system_desc_t) { + .entity = { .name = "ProgressTimers", .add = { EcsPreFrame } }, + .query.filter.terms = { + { .id = ecs_id(EcsTimer) }, + { .id = ecs_id(EcsTickSource) } + }, + .callback = ProgressTimers + }); - EcsPercentage = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Percentage" }); - ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.entity = EcsPercentage, - .symbol = "%" + /* Rate filter handling */ + ecs_system_init(world, &(ecs_system_desc_t) { + .entity = { .name = "ProgressRateFilters", .add = { EcsPreFrame } }, + .query.filter.terms = { + { .id = ecs_id(EcsRateFilter), .inout = EcsIn }, + { .id = ecs_id(EcsTickSource), .inout = EcsOut } + }, + .callback = ProgressRateFilters }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsPercentage, - .kind = EcsF32 + + /* TickSource without a timer or rate filter just increases each frame */ + ecs_system_init(world, &(ecs_system_desc_t) { + .entity = { .name = "ProgressTickSource", .add = { EcsPreFrame } }, + .query.filter.terms = { + { .id = ecs_id(EcsTickSource), .inout = EcsOut }, + { .id = ecs_id(EcsRateFilter), .oper = EcsNot }, + { .id = ecs_id(EcsTimer), .oper = EcsNot } + }, + .callback = ProgressTickSource }); +} - /* Angles */ +#endif - EcsAngle = ecs_quantity_init(world, &(ecs_entity_desc_t) { - .name = "Angle" }); - prev_scope = ecs_set_scope(world, EcsAngle); - EcsRadians = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Radians", - .quantity = EcsAngle, - .symbol = "rad" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsRadians, - .kind = EcsF32 - }); - EcsDegrees = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Degrees", - .quantity = EcsAngle, - .symbol = "°" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsDegrees, - .kind = EcsF32 - }); - ecs_set_scope(world, prev_scope); - /* DeciBel */ +#ifdef FLECS_EXPR + +static +int expr_ser_type( + const ecs_world_t *world, + ecs_vector_t *ser, + const void *base, + ecs_strbuf_t *str); + +static +int expr_ser_type_ops( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + ecs_strbuf_t *str); + +static +int expr_ser_type_op( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str); + +static +ecs_primitive_kind_t expr_op_to_primitive_kind(ecs_meta_type_op_kind_t kind) { + return kind - EcsOpPrimitive; +} + +/* Serialize a primitive value */ +static +int expr_ser_primitive( + const ecs_world_t *world, + ecs_primitive_kind_t kind, + const void *base, + ecs_strbuf_t *str) +{ + const char *bool_str[] = { "false", "true" }; - EcsBel = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "Bel", - .symbol = "B" }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsBel, - .kind = EcsF32 - }); - EcsDeciBel = ecs_unit_init(world, &(ecs_unit_desc_t) { - .entity.name = "DeciBel", - .prefix = EcsDeci, - .base = EcsBel }); - ecs_primitive_init(world, &(ecs_primitive_desc_t) { - .entity.entity = EcsDeciBel, - .kind = EcsF32 - }); + switch(kind) { + case EcsBool: + ecs_strbuf_appendstr(str, bool_str[(int)*(bool*)base]); + break; + case EcsChar: { + char chbuf[3]; + char ch = *(char*)base; + if (ch) { + ecs_chresc(chbuf, *(char*)base, '"'); + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, chbuf); + ecs_strbuf_appendstrn(str, "\"", 1); + } else { + ecs_strbuf_appendstr(str, "0"); + } + break; + } + case EcsByte: + ecs_strbuf_append(str, "%u", *(uint8_t*)base); + break; + case EcsU8: + ecs_strbuf_append(str, "%u", *(uint8_t*)base); + break; + case EcsU16: + ecs_strbuf_append(str, "%u", *(uint16_t*)base); + break; + case EcsU32: + ecs_strbuf_append(str, "%u", *(uint32_t*)base); + break; + case EcsU64: + ecs_strbuf_append(str, "%llu", *(uint64_t*)base); + break; + case EcsI8: + ecs_strbuf_append(str, "%d", *(int8_t*)base); + break; + case EcsI16: + ecs_strbuf_append(str, "%d", *(int16_t*)base); + break; + case EcsI32: + ecs_strbuf_append(str, "%d", *(int32_t*)base); + break; + case EcsI64: + ecs_strbuf_append(str, "%lld", *(int64_t*)base); + break; + case EcsF32: + ecs_strbuf_appendflt(str, (double)*(float*)base, 0); + break; + case EcsF64: + ecs_strbuf_appendflt(str, *(double*)base, 0); + break; + case EcsIPtr: + ecs_strbuf_append(str, "%i", *(intptr_t*)base); + break; + case EcsUPtr: + ecs_strbuf_append(str, "%u", *(uintptr_t*)base); + break; + case EcsString: { + char *value = *(char**)base; + if (value) { + ecs_size_t length = ecs_stresc(NULL, 0, '"', value); + if (length == ecs_os_strlen(value)) { + ecs_strbuf_appendstrn(str, "\"", 1); + ecs_strbuf_appendstr(str, value); + ecs_strbuf_appendstrn(str, "\"", 1); + } else { + char *out = ecs_os_malloc(length + 3); + ecs_stresc(out + 1, length, '"', value); + out[0] = '"'; + out[length + 1] = '"'; + out[length + 2] = '\0'; + ecs_strbuf_appendstr_zerocpy(str, out); + } + } else { + ecs_strbuf_appendstr(str, "null"); + } + break; + } + case EcsEntity: { + ecs_entity_t e = *(ecs_entity_t*)base; + if (!e) { + ecs_strbuf_appendstr(str, "0"); + } else { + char *path = ecs_get_fullpath(world, e); + ecs_assert(path != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_appendstr(str, path); + ecs_os_free(path); + } + break; + } + default: + ecs_err("invalid primitive kind"); + return -1; + } - /* Documentation */ -#ifdef FLECS_DOC - ECS_IMPORT(world, FlecsDoc); + return 0; +} - ecs_doc_set_brief(world, EcsDuration, - "Time amount (e.g. \"20 seconds\", \"2 hours\")"); - ecs_doc_set_brief(world, EcsSeconds, "Time amount in seconds"); - ecs_doc_set_brief(world, EcsMinutes, "60 seconds"); - ecs_doc_set_brief(world, EcsHours, "60 minutes"); - ecs_doc_set_brief(world, EcsDays, "24 hours"); +/* Serialize enumeration */ +static +int expr_ser_enum( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum); + ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_doc_set_brief(world, EcsTime, - "Time passed since an epoch (e.g. \"5pm\", \"March 3rd 2022\")"); - ecs_doc_set_brief(world, EcsDate, - "Seconds passed since January 1st 1970"); + int32_t value = *(int32_t*)base; + + /* Enumeration constants are stored in a map that is keyed on the + * enumeration value. */ + ecs_enum_constant_t *constant = ecs_map_get( + enum_type->constants, ecs_enum_constant_t, value); + if (!constant) { + char *path = ecs_get_fullpath(world, op->type); + ecs_err("value %d is not valid for enum type '%s'", value, path); + ecs_os_free(path); + goto error; + } - ecs_doc_set_brief(world, EcsMass, "Units of mass (e.g. \"5 kilograms\")"); + ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant)); - ecs_doc_set_brief(world, EcsElectricCurrent, - "Units of electrical current (e.g. \"2 ampere\")"); + return 0; +error: + return -1; +} - ecs_doc_set_brief(world, EcsAmount, - "Units of amount of substance (e.g. \"2 mole\")"); +/* Serialize bitmask */ +static +int expr_ser_bitmask( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) +{ + const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask); + ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_doc_set_brief(world, EcsLuminousIntensity, - "Units of luminous intensity (e.g. \"1 candela\")"); + uint32_t value = *(uint32_t*)ptr; + ecs_map_key_t key; + ecs_bitmask_constant_t *constant; + int count = 0; - ecs_doc_set_brief(world, EcsForce, "Units of force (e.g. \"10 newton\")"); + ecs_strbuf_list_push(str, "", "|"); - ecs_doc_set_brief(world, EcsLength, - "Units of length (e.g. \"5 meters\", \"20 miles\")"); + /* Multiple flags can be set at a given time. Iterate through all the flags + * and append the ones that are set. */ + ecs_map_iter_t it = ecs_map_iter(bitmask_type->constants); + while ((constant = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { + if ((value & key) == key) { + ecs_strbuf_list_appendstr(str, + ecs_get_name(world, constant->constant)); + count ++; + value -= (uint32_t)key; + } + } - ecs_doc_set_brief(world, EcsPressure, - "Units of pressure (e.g. \"1 bar\", \"1000 pascal\")"); + if (value != 0) { + /* All bits must have been matched by a constant */ + char *path = ecs_get_fullpath(world, op->type); + ecs_err( + "value for bitmask %s contains bits (%u) that cannot be mapped to constant", + path, value); + ecs_os_free(path); + goto error; + } - ecs_doc_set_brief(world, EcsSpeed, - "Units of movement (e.g. \"5 meters/second\")"); + if (!count) { + ecs_strbuf_list_appendstr(str, "0"); + } - ecs_doc_set_brief(world, EcsAcceleration, - "Unit of speed increase (e.g. \"5 meters/second/second\")"); + ecs_strbuf_list_pop(str, ""); - ecs_doc_set_brief(world, EcsTemperature, - "Units of temperature (e.g. \"5 degrees Celsius\")"); + return 0; +error: + return -1; +} - ecs_doc_set_brief(world, EcsData, - "Units of information (e.g. \"8 bits\", \"100 megabytes\")"); +/* Serialize elements of a contiguous array */ +static +int expr_ser_elements( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + int32_t elem_count, + int32_t elem_size, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_push(str, "[", ", "); - ecs_doc_set_brief(world, EcsDataRate, - "Units of data transmission (e.g. \"100 megabits/second\")"); + const void *ptr = base; - ecs_doc_set_brief(world, EcsAngle, - "Units of rotation (e.g. \"1.2 radians\", \"180 degrees\")"); + int i; + for (i = 0; i < elem_count; i ++) { + ecs_strbuf_list_next(str); + if (expr_ser_type_ops(world, ops, op_count, ptr, str)) { + return -1; + } + ptr = ECS_OFFSET(ptr, elem_size); + } -#endif + ecs_strbuf_list_pop(str, "]"); + + return 0; } -#endif +static +int expr_ser_type_elements( + const ecs_world_t *world, + ecs_entity_t type, + const void *base, + int32_t elem_count, + ecs_strbuf_t *str) +{ + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); -#ifdef FLECS_SNAPSHOT + ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); + int32_t op_count = ecs_vector_count(ser->ops); + return expr_ser_elements( + world, ops, op_count, base, elem_count, comp->size, str); +} -/* World snapshot */ -struct ecs_snapshot_t { - ecs_world_t *world; - ecs_sparse_t *entity_index; - ecs_vector_t *tables; - ecs_entity_t last_id; - ecs_filter_t filter; -}; +/* Serialize array */ +static +int expr_ser_array( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) +{ + const EcsArray *a = ecs_get(world, op->type, EcsArray); + ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL); -/** Small footprint data structure for storing data associated with a table. */ -typedef struct ecs_table_leaf_t { - ecs_table_t *table; - ecs_vector_t *type; - ecs_data_t *data; -} ecs_table_leaf_t; + return expr_ser_type_elements( + world, a->type, ptr, a->count, str); +} +/* Serialize vector */ static -ecs_data_t* duplicate_data( +int expr_ser_vector( const ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *main_data) + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str) { - if (!ecs_table_count(table)) { - return NULL; + ecs_vector_t *value = *(ecs_vector_t**)base; + if (!value) { + ecs_strbuf_appendstr(str, "null"); + return 0; } - ecs_data_t *result = ecs_os_calloc(ECS_SIZEOF(ecs_data_t)); - - ecs_type_t storage_type = table->storage_type; - int32_t i, column_count = ecs_vector_count(storage_type); - ecs_entity_t *components = ecs_vector_first(storage_type, ecs_entity_t); - - result->columns = ecs_os_memdup( - main_data->columns, ECS_SIZEOF(ecs_column_t) * column_count); + const EcsVector *v = ecs_get(world, op->type, EcsVector); + ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL); - /* Copy entities */ - result->entities = ecs_vector_copy(main_data->entities, ecs_entity_t); - ecs_entity_t *entities = ecs_vector_first(result->entities, ecs_entity_t); + const EcsComponent *comp = ecs_get(world, v->type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); - /* Copy record ptrs */ - result->record_ptrs = ecs_vector_copy( - main_data->record_ptrs, ecs_record_t*); + int32_t count = ecs_vector_count(value); + void *array = ecs_vector_first_t(value, comp->size, comp->alignment); - ecs_size_t to_alloc = ecs_vector_size(result->entities); + /* Serialize contiguous buffer of vector */ + return expr_ser_type_elements(world, v->type, array, count, str); +} - /* Copy each column */ - for (i = 0; i < column_count; i ++) { - ecs_entity_t component = components[i]; - ecs_column_t *column = &result->columns[i]; +/* Forward serialization to the different type kinds */ +static +int expr_ser_type_op( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) +{ + switch(op->kind) { + case EcsOpPush: + case EcsOpPop: + /* Should not be parsed as single op */ + ecs_throw(ECS_INVALID_PARAMETER, NULL); + break; + case EcsOpEnum: + if (expr_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) { + goto error; + } + break; + case EcsOpBitmask: + if (expr_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) { + goto error; + } + break; + case EcsOpArray: + if (expr_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) { + goto error; + } + break; + case EcsOpVector: + if (expr_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) { + goto error; + } + break; + default: + if (expr_ser_primitive(world, expr_op_to_primitive_kind(op->kind), + ECS_OFFSET(ptr, op->offset), str)) + { + /* Unknown operation */ + ecs_err("unknown serializer operation kind (%d)", op->kind); + goto error; + } + break; + } - component = ecs_get_typeid(world, component); + return 0; +error: + return -1; +} - const ecs_type_info_t *ti = flecs_get_type_info(world, component); - int16_t size = column->size; - int16_t alignment = column->alignment; - ecs_copy_t copy; +/* Iterate over a slice of the type ops array */ +static +int expr_ser_type_ops( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + ecs_strbuf_t *str) +{ + for (int i = 0; i < op_count; i ++) { + ecs_meta_type_op_t *op = &ops[i]; - if (ti && (copy = ti->lifecycle.copy)) { - int32_t count = ecs_vector_count(column->data); - ecs_vector_t *dst_vec = ecs_vector_new_t(size, alignment, to_alloc); - ecs_vector_set_count_t(&dst_vec, size, alignment, count); - void *dst_ptr = ecs_vector_first_t(dst_vec, size, alignment); - - ecs_xtor_t ctor = ti->lifecycle.ctor; - if (ctor) { - ctor((ecs_world_t*)world, entities, dst_ptr, count, ti); + if (op != ops) { + if (op->name) { + ecs_strbuf_list_next(str); + ecs_strbuf_append(str, "%s: ", op->name); } - void *src_ptr = ecs_vector_first_t(column->data, size, alignment); - copy((ecs_world_t*)world, entities, entities, dst_ptr, - src_ptr, count, ti); + int32_t elem_count = op->count; + if (elem_count > 1 && op != ops) { + /* Serialize inline array */ + if (expr_ser_elements(world, op, op->op_count, base, + elem_count, op->size, str)) + { + return -1; + } - column->data = dst_vec; - } else { - column->data = ecs_vector_copy_t(column->data, size, alignment); + i += op->op_count - 1; + continue; + } + } + + switch(op->kind) { + case EcsOpPush: + ecs_strbuf_list_push(str, "{", ", "); + break; + case EcsOpPop: + ecs_strbuf_list_pop(str, "}"); + break; + default: + if (expr_ser_type_op(world, op, base, str)) { + goto error; + } + break; } } - return result; + return 0; +error: + return -1; } +/* Iterate over the type ops of a type */ static -void snapshot_table( +int expr_ser_type( const ecs_world_t *world, - ecs_snapshot_t *snapshot, - ecs_table_t *table) + ecs_vector_t *v_ops, + const void *base, + ecs_strbuf_t *str) { - if (table->flags & EcsTableHasBuiltins) { - return; + ecs_meta_type_op_t *ops = ecs_vector_first(v_ops, ecs_meta_type_op_t); + int32_t count = ecs_vector_count(v_ops); + return expr_ser_type_ops(world, ops, count, base, str); +} + +int ecs_ptr_to_expr_buf( + const ecs_world_t *world, + ecs_entity_t type, + const void *ptr, + ecs_strbuf_t *buf_out) +{ + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + if (ser == NULL) { + char *path = ecs_get_fullpath(world, type); + ecs_err("cannot serialize value for type '%s'", path); + ecs_os_free(path); + goto error; } - - ecs_table_leaf_t *l = ecs_vector_get( - snapshot->tables, ecs_table_leaf_t, (int32_t)table->id); - ecs_assert(l != NULL, ECS_INTERNAL_ERROR, NULL); - - l->table = table; - l->type = ecs_vector_copy(table->type, ecs_id_t); - l->data = duplicate_data(world, table, &table->storage); + + if (expr_ser_type(world, ser->ops, ptr, buf_out)) { + goto error; + } + + return 0; +error: + return -1; +} + +char* ecs_ptr_to_expr( + const ecs_world_t *world, + ecs_entity_t type, + const void* ptr) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + + if (ecs_ptr_to_expr_buf(world, type, ptr, &str) != 0) { + ecs_strbuf_reset(&str); + return NULL; + } + + return ecs_strbuf_get(&str); } -static -ecs_snapshot_t* snapshot_create( +int ecs_primitive_to_expr_buf( const ecs_world_t *world, - const ecs_sparse_t *entity_index, - ecs_iter_t *iter, - ecs_iter_next_action_t next) + ecs_primitive_kind_t kind, + const void *base, + ecs_strbuf_t *str) { - ecs_snapshot_t *result = ecs_os_calloc_t(ecs_snapshot_t); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - - ecs_force_aperiodic((ecs_world_t*)world); + return expr_ser_primitive(world, kind, base, str); +} - result->world = (ecs_world_t*)world; +#endif - /* If no iterator is provided, the snapshot will be taken of the entire - * world, and we can simply copy the entity index as it will be restored - * entirely upon snapshote restore. */ - if (!iter && entity_index) { - result->entity_index = flecs_sparse_copy(entity_index); - } - /* Create vector with as many elements as tables, so we can store the - * snapshot tables at their element ids. When restoring a snapshot, the code - * will run a diff between the tables in the world and the snapshot, to see - * which of the world tables still exist, no longer exist, or need to be - * deleted. */ - uint64_t t, table_count = flecs_sparse_last_id(&world->store.tables) + 1; - result->tables = ecs_vector_new(ecs_table_leaf_t, (int32_t)table_count); - ecs_vector_set_count(&result->tables, ecs_table_leaf_t, (int32_t)table_count); - ecs_table_leaf_t *arr = ecs_vector_first(result->tables, ecs_table_leaf_t); - /* Array may have holes, so initialize with 0 */ - ecs_os_memset_n(arr, 0, ecs_table_leaf_t, table_count); +#ifdef FLECS_EXPR - /* Iterate tables in iterator */ - if (iter) { - while (next(iter)) { - ecs_table_t *table = iter->table; - snapshot_table(world, result, table); - } - } else { - for (t = 0; t < table_count; t ++) { - ecs_table_t *table = flecs_sparse_get( - &world->store.tables, ecs_table_t, t); - snapshot_table(world, result, table); +char* ecs_chresc( + char *out, + char in, + char delimiter) +{ + char *bptr = out; + switch(in) { + case '\a': + *bptr++ = '\\'; + *bptr = 'a'; + break; + case '\b': + *bptr++ = '\\'; + *bptr = 'b'; + break; + case '\f': + *bptr++ = '\\'; + *bptr = 'f'; + break; + case '\n': + *bptr++ = '\\'; + *bptr = 'n'; + break; + case '\r': + *bptr++ = '\\'; + *bptr = 'r'; + break; + case '\t': + *bptr++ = '\\'; + *bptr = 't'; + break; + case '\v': + *bptr++ = '\\'; + *bptr = 'v'; + break; + case '\\': + *bptr++ = '\\'; + *bptr = '\\'; + break; + default: + if (in == delimiter) { + *bptr++ = '\\'; + *bptr = delimiter; + } else { + *bptr = in; } + break; } - return result; + *(++bptr) = '\0'; + + return bptr; } -/** Create a snapshot */ -ecs_snapshot_t* ecs_snapshot_take( - ecs_world_t *stage) +const char* ecs_chrparse( + const char *in, + char *out) { - const ecs_world_t *world = ecs_get_world(stage); + const char *result = in + 1; + char ch; - ecs_snapshot_t *result = snapshot_create( - world, ecs_eis(world), NULL, NULL); + if (in[0] == '\\') { + result ++; - result->last_id = world->stats.last_id; + switch(in[1]) { + case 'a': + ch = '\a'; + break; + case 'b': + ch = '\b'; + break; + case 'f': + ch = '\f'; + break; + case 'n': + ch = '\n'; + break; + case 'r': + ch = '\r'; + break; + case 't': + ch = '\t'; + break; + case 'v': + ch = '\v'; + break; + case '\\': + ch = '\\'; + break; + case '"': + ch = '"'; + break; + case '0': + ch = '\0'; + break; + case ' ': + ch = ' '; + break; + case '$': + ch = '$'; + break; + default: + goto error; + } + } else { + ch = in[0]; + } + + if (out) { + *out = ch; + } return result; +error: + return NULL; } -/** Create a filtered snapshot */ -ecs_snapshot_t* ecs_snapshot_take_w_iter( - ecs_iter_t *iter) +ecs_size_t ecs_stresc( + char *out, + ecs_size_t n, + char delimiter, + const char *in) { - ecs_world_t *world = iter->world; - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_snapshot_t *result = snapshot_create( - world, ecs_eis(world), iter, iter ? iter->next : NULL); - - result->last_id = world->stats.last_id; + const char *ptr = in; + char ch, *bptr = out, buff[3]; + ecs_size_t written = 0; + while ((ch = *ptr++)) { + if ((written += (ecs_size_t)(ecs_chresc( + buff, ch, delimiter) - buff)) <= n) + { + /* If size != 0, an out buffer must be provided. */ + ecs_check(out != NULL, ECS_INVALID_PARAMETER, NULL); + *bptr++ = buff[0]; + if ((ch = buff[1])) { + *bptr = ch; + bptr++; + } + } + } - return result; + if (bptr) { + while (written < n) { + *bptr = '\0'; + bptr++; + written++; + } + } + return written; +error: + return 0; } -/* Restoring an unfiltered snapshot restores the world to the exact state it was - * when the snapshot was taken. */ -static -void restore_unfiltered( - ecs_world_t *world, - ecs_snapshot_t *snapshot) +char* ecs_astresc( + char delimiter, + const char *in) { - flecs_sparse_restore(ecs_eis(world), snapshot->entity_index); - flecs_sparse_free(snapshot->entity_index); - - world->stats.last_id = snapshot->last_id; - - ecs_table_leaf_t *leafs = ecs_vector_first( - snapshot->tables, ecs_table_leaf_t); - int32_t i, count = (int32_t)flecs_sparse_last_id(&world->store.tables); - int32_t snapshot_count = ecs_vector_count(snapshot->tables); - - for (i = 0; i <= count; i ++) { - ecs_table_t *world_table = flecs_sparse_get( - &world->store.tables, ecs_table_t, (uint32_t)i); + if (!in) { + return NULL; + } - if (world_table && (world_table->flags & EcsTableHasBuiltins)) { - continue; - } + ecs_size_t len = ecs_stresc(NULL, 0, delimiter, in); + char *out = ecs_os_malloc_n(char, len + 1); + ecs_stresc(out, len, delimiter, in); + out[len] = '\0'; + return out; +} - ecs_table_leaf_t *snapshot_table = NULL; - if (i < snapshot_count) { - snapshot_table = &leafs[i]; - if (!snapshot_table->table) { - snapshot_table = NULL; - } - } +#endif - /* If the world table no longer exists but the snapshot table does, - * reinsert it */ - if (!world_table && snapshot_table) { - ecs_ids_t type = { - .array = ecs_vector_first(snapshot_table->type, ecs_id_t), - .count = ecs_vector_count(snapshot_table->type) - }; - ecs_table_t *table = flecs_table_find_or_create(world, &type); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - if (snapshot_table->data) { - flecs_table_replace_data(world, table, snapshot_table->data); - } - - /* If the world table still exists, replace its data */ - } else if (world_table && snapshot_table) { - ecs_assert(snapshot_table->table == world_table, - ECS_INTERNAL_ERROR, NULL); +#ifdef FLECS_EXPR - if (snapshot_table->data) { - flecs_table_replace_data( - world, world_table, snapshot_table->data); - } else { - flecs_table_clear_data( - world, world_table, &world_table->storage); - flecs_table_init_data(world, world_table); - } - - /* If the snapshot table doesn't exist, this table was created after the - * snapshot was taken and needs to be deleted */ - } else if (world_table && !snapshot_table) { - /* Deleting a table invokes OnRemove triggers & updates the entity - * index. That is not what we want, since entities may no longer be - * valid (if they don't exist in the snapshot) or may have been - * restored in a different table. Therefore first clear the data - * from the table (which doesn't invoke triggers), and then delete - * the table. */ - flecs_table_clear_data(world, world_table, &world_table->storage); - flecs_delete_table(world, world_table); - - /* If there is no world & snapshot table, nothing needs to be done */ - } else { } +const char *ecs_parse_expr_token( + const char *name, + const char *expr, + const char *ptr, + char *token) +{ + const char *start = ptr; + char *token_ptr = token; - if (snapshot_table) { - ecs_os_free(snapshot_table->data); - ecs_os_free(snapshot_table->type); + while ((ptr = ecs_parse_token(name, expr, ptr, token_ptr))) { + if (ptr[0] == '|') { + token_ptr = &token_ptr[ptr - start]; + token_ptr[0] = '|'; + token_ptr[1] = '\0'; + token_ptr ++; + ptr ++; + start = ptr; + } else { + break; } } - /* Now that all tables have been restored and world is in a consistent - * state, run OnSet systems */ - int32_t world_count = flecs_sparse_count(&world->store.tables); - for (i = 0; i < world_count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense( - &world->store.tables, ecs_table_t, i); - if (table->flags & EcsTableHasBuiltins) { - continue; - } - - int32_t tcount = ecs_table_count(table); - if (tcount) { - flecs_notify_on_set(world, table, 0, tcount, NULL, true); - } - } + return ptr; } -/* Restoring a filtered snapshots only restores the entities in the snapshot - * to their previous state. */ -static -void restore_filtered( - ecs_world_t *world, - ecs_snapshot_t *snapshot) +const char* ecs_parse_expr( + const ecs_world_t *world, + const char *ptr, + ecs_entity_t type, + void *data_out, + const ecs_parse_expr_desc_t *desc) { - ecs_table_leaf_t *leafs = ecs_vector_first( - snapshot->tables, ecs_table_leaf_t); - int32_t l = 0, snapshot_count = ecs_vector_count(snapshot->tables); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + char token[ECS_MAX_TOKEN_SIZE]; + int depth = 0; - for (l = 0; l < snapshot_count; l ++) { - ecs_table_leaf_t *snapshot_table = &leafs[l]; - ecs_table_t *table = snapshot_table->table; + const char *name = NULL; + const char *expr = NULL; - if (!table) { - continue; - } + ptr = ecs_parse_fluff(ptr, NULL); - ecs_data_t *data = snapshot_table->data; - if (!data) { - ecs_vector_free(snapshot_table->type); - continue; - } + ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, data_out); + if (cur.valid == false) { + return NULL; + } - /* Delete entity from storage first, so that when we restore it to the - * current table we can be sure that there won't be any duplicates */ - int32_t i, entity_count = ecs_vector_count(data->entities); - ecs_entity_t *entities = ecs_vector_first( - snapshot_table->data->entities, ecs_entity_t); - for (i = 0; i < entity_count; i ++) { - ecs_entity_t e = entities[i]; - ecs_record_t *r = ecs_eis_get(world, e); - if (r && r->table) { - flecs_table_delete(world, r->table, &r->table->storage, - ECS_RECORD_TO_ROW(r->row), true); - } else { - /* Make sure that the entity has the same generation count */ - ecs_eis_set_generation(world, e); + if (desc) { + name = desc->name; + expr = desc->expr; + cur.lookup_action = desc->lookup_action; + cur.lookup_ctx = desc->lookup_ctx; + } + + while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) { + + if (!ecs_os_strcmp(token, "{")) { + ecs_entity_t scope_type = ecs_meta_get_type(&cur); + depth ++; + if (ecs_meta_push(&cur) != 0) { + goto error; + } + + if (ecs_meta_is_collection(&cur)) { + char *path = ecs_get_fullpath(world, scope_type); + ecs_parser_error(name, expr, ptr - expr, + "expected '[' for collection type '%s'", path); + ecs_os_free(path); + return NULL; } } - /* Merge data from snapshot table with world table */ - int32_t old_count = ecs_table_count(snapshot_table->table); - int32_t new_count = flecs_table_data_count(snapshot_table->data); + else if (!ecs_os_strcmp(token, "}")) { + depth --; - flecs_table_merge(world, table, table, &table->storage, snapshot_table->data); + if (ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected ']'"); + return NULL; + } - /* Run OnSet systems for merged entities */ - if (new_count) { - flecs_notify_on_set( - world, table, old_count, new_count, NULL, true); + if (ecs_meta_pop(&cur) != 0) { + goto error; + } } - ecs_os_free(snapshot_table->data->columns); - ecs_os_free(snapshot_table->data); - ecs_vector_free(snapshot_table->type); - } -} + else if (!ecs_os_strcmp(token, "[")) { + depth ++; + if (ecs_meta_push(&cur) != 0) { + goto error; + } -/** Restore a snapshot */ -void ecs_snapshot_restore( - ecs_world_t *world, - ecs_snapshot_t *snapshot) -{ - ecs_force_aperiodic(world); - - if (snapshot->entity_index) { - /* Unfiltered snapshots have a copy of the entity index which is - * copied back entirely when the snapshot is restored */ - restore_unfiltered(world, snapshot); - } else { - restore_filtered(world, snapshot); - } + if (!ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected '{'"); + return NULL; + } + } - ecs_vector_free(snapshot->tables); + else if (!ecs_os_strcmp(token, "]")) { + depth --; - ecs_os_free(snapshot); -} + if (!ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected '}'"); + return NULL; + } -ecs_iter_t ecs_snapshot_iter( - ecs_snapshot_t *snapshot) -{ - ecs_snapshot_iter_t iter = { - .tables = snapshot->tables, - .index = 0 - }; + if (ecs_meta_pop(&cur) != 0) { + goto error; + } + } - return (ecs_iter_t){ - .world = snapshot->world, - .table_count = ecs_vector_count(snapshot->tables), - .priv.iter.snapshot = iter, - .next = ecs_snapshot_next - }; -} + else if (!ecs_os_strcmp(token, ",")) { + if (ecs_meta_next(&cur) != 0) { + goto error; + } + } -bool ecs_snapshot_next( - ecs_iter_t *it) -{ - ecs_snapshot_iter_t *iter = &it->priv.iter.snapshot; - ecs_table_leaf_t *tables = ecs_vector_first(iter->tables, ecs_table_leaf_t); - int32_t count = ecs_vector_count(iter->tables); - int32_t i; + else if (!ecs_os_strcmp(token, "null")) { + if (ecs_meta_set_null(&cur) != 0) { + goto error; + } + } - for (i = iter->index; i < count; i ++) { - ecs_table_t *table = tables[i].table; - if (!table) { - continue; + else if (token[0] == '\"') { + if (ecs_meta_set_string_literal(&cur, token) != 0) { + goto error; + } } - ecs_data_t *data = tables[i].data; + else { + ptr = ecs_parse_fluff(ptr, NULL); - it->table = table; - it->count = ecs_table_count(table); - if (data) { - it->entities = ecs_vector_first(data->entities, ecs_entity_t); - } else { - it->entities = NULL; + if (ptr[0] == ':') { + /* Member assignment */ + ptr ++; + if (ecs_meta_member(&cur, token) != 0) { + goto error; + } + } else { + if (ecs_meta_set_string(&cur, token) != 0) { + goto error; + } + } } - it->is_valid = true; - iter->index = i + 1; - - goto yield; - } + if (!depth) { + break; + } - it->is_valid = false; - return false; + ptr = ecs_parse_fluff(ptr, NULL); + } -yield: - it->is_valid = true; - return true; + return ptr; +error: + return NULL; } -/** Cleanup snapshot */ -void ecs_snapshot_free( - ecs_snapshot_t *snapshot) -{ - flecs_sparse_free(snapshot->entity_index); +#endif - ecs_table_leaf_t *tables = ecs_vector_first(snapshot->tables, ecs_table_leaf_t); - int32_t i, count = ecs_vector_count(snapshot->tables); - for (i = 0; i < count; i ++) { - ecs_table_leaf_t *snapshot_table = &tables[i]; - ecs_table_t *table = snapshot_table->table; - if (table) { - ecs_data_t *data = snapshot_table->data; - if (data) { - flecs_table_clear_data(snapshot->world, table, data); - ecs_os_free(data); - } - ecs_vector_free(snapshot_table->type); - } - } +#include - ecs_vector_free(snapshot->tables); - ecs_os_free(snapshot); -} +/* Utilities for C++ API */ -#endif +#ifdef FLECS_CPP +/* Convert compiler-specific typenames extracted from __PRETTY_FUNCTION__ to + * a uniform identifier */ -#ifdef FLECS_SYSTEM +#define ECS_CONST_PREFIX "const " +#define ECS_STRUCT_PREFIX "struct " +#define ECS_CLASS_PREFIX "class " +#define ECS_ENUM_PREFIX "enum " +#define ECS_CONST_LEN (-1 + (ecs_size_t)sizeof(ECS_CONST_PREFIX)) +#define ECS_STRUCT_LEN (-1 + (ecs_size_t)sizeof(ECS_STRUCT_PREFIX)) +#define ECS_CLASS_LEN (-1 + (ecs_size_t)sizeof(ECS_CLASS_PREFIX)) +#define ECS_ENUM_LEN (-1 + (ecs_size_t)sizeof(ECS_ENUM_PREFIX)) static -void invoke_status_action( - ecs_world_t *world, - ecs_entity_t system, - const EcsSystem *system_data, - ecs_system_status_t status) +ecs_size_t ecs_cpp_strip_prefix( + char *typeName, + ecs_size_t len, + const char *prefix, + ecs_size_t prefix_len) { - ecs_system_status_action_t action = system_data->status_action; - if (action) { - action(world, system, status, system_data->status_ctx); + if ((len > prefix_len) && !ecs_os_strncmp(typeName, prefix, prefix_len)) { + ecs_os_memmove(typeName, typeName + prefix_len, len - prefix_len); + typeName[len - prefix_len] = '\0'; + len -= prefix_len; } + return len; } -/* Invoked when system becomes active or inactive */ -void ecs_system_activate( - ecs_world_t *world, - ecs_entity_t system, - bool activate, - const EcsSystem *system_data) +static +void ecs_cpp_trim_type_name( + char *typeName) { - ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); + ecs_size_t len = ecs_os_strlen(typeName); - if (activate) { - /* If activating system, ensure that it doesn't have the Inactive tag. - * Systems are implicitly activated so they are kept out of the main - * loop as long as they aren't used. They are not implicitly deactivated - * to prevent overhead in case of oscillating app behavior. - * After activation, systems that aren't matched with anything can be - * deactivated again by explicitly calling ecs_deactivate_systems. - */ - ecs_remove_id(world, system, EcsInactive); - } + len = ecs_cpp_strip_prefix(typeName, len, ECS_CONST_PREFIX, ECS_CONST_LEN); + len = ecs_cpp_strip_prefix(typeName, len, ECS_STRUCT_PREFIX, ECS_STRUCT_LEN); + len = ecs_cpp_strip_prefix(typeName, len, ECS_CLASS_PREFIX, ECS_CLASS_LEN); + len = ecs_cpp_strip_prefix(typeName, len, ECS_ENUM_PREFIX, ECS_ENUM_LEN); - if (!system_data) { - system_data = ecs_get(world, system, EcsSystem); + while (typeName[len - 1] == ' ' || + typeName[len - 1] == '&' || + typeName[len - 1] == '*') + { + len --; + typeName[len] = '\0'; } - if (!system_data || !system_data->query) { - return; + + /* Remove const at end of string */ + if (len > ECS_CONST_LEN) { + if (!ecs_os_strncmp(&typeName[len - ECS_CONST_LEN], " const", ECS_CONST_LEN)) { + typeName[len - ECS_CONST_LEN] = '\0'; + } + len -= ECS_CONST_LEN; } - if (!activate) { - if (ecs_has_id(world, system, EcsDisabled)) { - if (!ecs_query_table_count(system_data->query)) { - /* If deactivating a disabled system that isn't matched with - * any active tables, there is nothing to deactivate. */ - return; + /* Check if there are any remaining "struct " strings, which can happen + * if this is a template type on msvc. */ + if (len > ECS_STRUCT_LEN) { + char *ptr = typeName; + while ((ptr = strstr(ptr + 1, ECS_STRUCT_PREFIX)) != 0) { + /* Make sure we're not matched with part of a longer identifier + * that contains 'struct' */ + if (ptr[-1] == '<' || ptr[-1] == ',' || isspace(ptr[-1])) { + ecs_os_memmove(ptr, ptr + ECS_STRUCT_LEN, + ecs_os_strlen(ptr + ECS_STRUCT_LEN) + 1); + len -= ECS_STRUCT_LEN; } - } + } } +} - /* Invoke system status action */ - invoke_status_action(world, system, system_data, - activate ? EcsSystemActivated : EcsSystemDeactivated); - - ecs_dbg_1("#[green]system#[reset] %s %s", - ecs_get_name(world, system), - activate ? "activated" : "deactivated"); +char* ecs_cpp_get_type_name( + char *type_name, + const char *func_name, + size_t len) +{ + memcpy(type_name, func_name + ECS_FUNC_NAME_FRONT(const char*, type_name), len); + type_name[len] = '\0'; + ecs_cpp_trim_type_name(type_name); + return type_name; } -/* Actually enable or disable system */ -static -void ecs_enable_system( - ecs_world_t *world, - ecs_entity_t system, - EcsSystem *system_data, - bool enabled) +char* ecs_cpp_get_symbol_name( + char *symbol_name, + const char *type_name, + size_t len) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); + // Symbol is same as name, but with '::' replaced with '.' + ecs_os_strcpy(symbol_name, type_name); - ecs_query_t *query = system_data->query; - if (!query) { - return; + char *ptr; + size_t i; + for (i = 0, ptr = symbol_name; i < len && *ptr; i ++, ptr ++) { + if (*ptr == ':') { + symbol_name[i] = '.'; + ptr ++; + } else { + symbol_name[i] = *ptr; + } } - if (ecs_query_table_count(query)) { - /* Only (de)activate system if it has non-empty tables. */ - ecs_system_activate(world, system, enabled, system_data); - system_data = ecs_get_mut(world, system, EcsSystem, NULL); + symbol_name[i] = '\0'; + + return symbol_name; +} + +static +const char* cpp_func_rchr( + const char *func_name, + ecs_size_t func_name_len, + char ch) +{ + const char *r = strrchr(func_name, ch); + if ((r - func_name) >= (func_name_len - flecs_uto(ecs_size_t, ECS_FUNC_NAME_BACK))) { + return NULL; } - - /* Invoke action for enable/disable status */ - invoke_status_action( - world, system, system_data, - enabled ? EcsSystemEnabled : EcsSystemDisabled); + return r; } -/* -- Public API -- */ +static +const char* cpp_func_max( + const char *a, + const char *b) +{ + if (a > b) return a; + return b; +} -ecs_entity_t ecs_run_intern( - ecs_world_t *world, - ecs_stage_t *stage, - ecs_entity_t system, - EcsSystem *system_data, - int32_t stage_current, - int32_t stage_count, - FLECS_FLOAT delta_time, - int32_t offset, - int32_t limit, - void *param) +char* ecs_cpp_get_constant_name( + char *constant_name, + const char *func_name, + size_t func_name_len) { - FLECS_FLOAT time_elapsed = delta_time; - ecs_entity_t tick_source = system_data->tick_source; + ecs_size_t f_len = flecs_uto(ecs_size_t, func_name_len); + const char *start = cpp_func_rchr(func_name, f_len, ' '); + start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ')')); + start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ':')); + start = cpp_func_max(start, cpp_func_rchr(func_name, f_len, ',')); + ecs_assert(start != NULL, ECS_INVALID_PARAMETER, func_name); + start ++; + + ecs_size_t len = flecs_uto(ecs_size_t, + (f_len - (start - func_name) - flecs_uto(ecs_size_t, ECS_FUNC_NAME_BACK))); + ecs_os_memcpy_n(constant_name, start, char, len); + constant_name[len] = '\0'; + return constant_name; +} - /* Support legacy behavior */ - if (!param) { - param = system_data->ctx; +// Names returned from the name_helper class do not start with :: +// but are relative to the root. If the namespace of the type +// overlaps with the namespace of the current module, strip it from +// the implicit identifier. +// This allows for registration of component types that are not in the +// module namespace to still be registered under the module scope. +const char* ecs_cpp_trim_module( + ecs_world_t *world, + const char *type_name) +{ + ecs_entity_t scope = ecs_get_scope(world); + if (!scope) { + return type_name; } - if (tick_source) { - const EcsTickSource *tick = ecs_get( - world, tick_source, EcsTickSource); - - if (tick) { - time_elapsed = tick->time_elapsed; - - /* If timer hasn't fired we shouldn't run the system */ - if (!tick->tick) { - return 0; + char *path = ecs_get_path_w_sep(world, 0, scope, "::", NULL); + if (path) { + const char *ptr = strrchr(type_name, ':'); + ecs_assert(ptr != type_name, ECS_INTERNAL_ERROR, NULL); + if (ptr) { + ptr --; + ecs_assert(ptr[0] == ':', ECS_INTERNAL_ERROR, NULL); + ecs_size_t name_path_len = (ecs_size_t)(ptr - type_name); + if (name_path_len <= ecs_os_strlen(path)) { + if (!ecs_os_strncmp(type_name, path, name_path_len)) { + type_name = &type_name[name_path_len + 2]; + } } - } else { - /* If a timer has been set but the timer entity does not have the - * EcsTimer component, don't run the system. This can be the result - * of a single-shot timer that has fired already. Not resetting the - * timer field of the system will ensure that the system won't be - * ran after the timer has fired. */ - return 0; } } + ecs_os_free(path); - ecs_time_t time_start; - bool measure_time = world->measure_system_time; - if (measure_time) { - ecs_os_get_time(&time_start); - } + return type_name; +} - ecs_world_t *thread_ctx = world; - if (stage) { - thread_ctx = stage->thread_ctx; +// Validate registered component +void ecs_cpp_component_validate( + ecs_world_t *world, + ecs_entity_t id, + const char *name, + size_t size, + size_t alignment, + bool implicit_name) +{ + /* If entity has a name check if it matches */ + if (ecs_is_valid(world, id) && ecs_get_name(world, id) != NULL) { + if (!implicit_name && id >= EcsFirstUserComponentId) { +# ifndef FLECS_NDEBUG + char *path = ecs_get_path_w_sep( + world, 0, id, "::", NULL); + if (ecs_os_strcmp(path, name)) { + ecs_err( + "component '%s' already registered with name '%s'", + name, path); + ecs_abort(ECS_INCONSISTENT_NAME, NULL); + } + ecs_os_free(path); +# endif + } + } else { + /* Ensure that the entity id valid */ + if (!ecs_is_alive(world, id)) { + ecs_ensure(world, id); + } + + /* Register name with entity, so that when the entity is created the + * correct id will be resolved from the name. Only do this when the + * entity is empty. */ + ecs_add_path_w_sep(world, id, 0, name, "::", "::"); } - ecs_defer_begin(thread_ctx); + /* If a component was already registered with this id but with a + * different size, the ecs_component_init function will fail. */ - /* Prepare the query iterator */ - ecs_iter_t pit, wit, qit = ecs_query_iter(thread_ctx, system_data->query); - ecs_iter_t *it = &qit; + /* We need to explicitly call ecs_component_init here again. Even though + * the component was already registered, it may have been registered + * with a different world. This ensures that the component is registered + * with the same id for the current world. + * If the component was registered already, nothing will change. */ + ecs_entity_t ent = ecs_component_init(world, &(ecs_component_desc_t) { + .entity.entity = id, + .size = size, + .alignment = alignment + }); + (void)ent; + ecs_assert(ent == id, ECS_INTERNAL_ERROR, NULL); +} - if (offset || limit) { - pit = ecs_page_iter(it, offset, limit); - it = &pit; - } +ecs_entity_t ecs_cpp_component_register( + ecs_world_t *world, + ecs_entity_t id, + const char *name, + const char *symbol, + ecs_size_t size, + ecs_size_t alignment) +{ + (void)size; + (void)alignment; - if (stage_count > 1 && system_data->multi_threaded) { - wit = ecs_worker_iter(it, stage_current, stage_count); - it = &wit; + /* If the component is not yet registered, ensure no other component + * or entity has been registered with this name. Ensure component is + * looked up from root. */ + ecs_entity_t prev_scope = ecs_set_scope(world, 0); + ecs_entity_t ent; + if (id) { + ent = id; + } else { + ent = ecs_lookup_path_w_sep(world, 0, name, "::", "::", false); } + ecs_set_scope(world, prev_scope); - qit.system = system; - qit.self = system_data->self; - qit.delta_time = delta_time; - qit.delta_system_time = time_elapsed; - qit.frame_offset = offset; - qit.param = param; - qit.ctx = system_data->ctx; - qit.binding_ctx = system_data->binding_ctx; + /* If entity exists, compare symbol name to ensure that the component + * we are trying to register under this name is the same */ + if (ent) { + if (!id && ecs_has(world, ent, EcsComponent)) { + const char *sym = ecs_get_symbol(world, ent); + ecs_assert(sym != NULL, ECS_MISSING_SYMBOL, + ecs_get_name(world, ent)); + (void)sym; - ecs_iter_action_t action = system_data->action; - it->callback = action; - - ecs_run_action_t run = system_data->run; - if (run) { - run(it); - } else { - if (it == &qit) { - while (ecs_query_next(&qit)) { - action(&qit); +# ifndef FLECS_NDEBUG + if (ecs_os_strcmp(sym, symbol)) { + ecs_err( + "component with name '%s' is already registered for"\ + " type '%s' (trying to register for type '%s')", + name, sym, symbol); + ecs_abort(ECS_NAME_IN_USE, NULL); } +# endif + + /* If an existing id was provided, it's possible that this id was + * registered with another type. Make sure that in this case at + * least the component size/alignment matches. + * This allows applications to alias two different types to the same + * id, which enables things like redefining a C type in C++ by + * inheriting from it & adding utility functions etc. */ } else { - while (ecs_iter_next(it)) { - action(it); + const EcsComponent *comp = ecs_get(world, ent, EcsComponent); + if (comp) { + ecs_assert(comp->size == size, + ECS_INVALID_COMPONENT_SIZE, NULL); + ecs_assert(comp->alignment == alignment, + ECS_INVALID_COMPONENT_ALIGNMENT, NULL); + } else { + /* If the existing id is not a component, no checking is + * needed. */ } } - } - if (measure_time) { - system_data->time_spent += (float)ecs_time_measure(&time_start); + /* If no entity is found, lookup symbol to check if the component was + * registered under a different name. */ + } else { + ent = ecs_lookup_symbol(world, symbol, false); + ecs_assert(ent == 0, ECS_INCONSISTENT_COMPONENT_ID, symbol); } - system_data->invoke_count ++; - - ecs_defer_end(thread_ctx); - - return it->interrupted_by; + return id; } -/* -- Public API -- */ - -ecs_entity_t ecs_run_w_filter( +ecs_entity_t ecs_cpp_component_register_explicit( ecs_world_t *world, - ecs_entity_t system, - FLECS_FLOAT delta_time, - int32_t offset, - int32_t limit, - void *param) + ecs_entity_t s_id, + ecs_entity_t id, + const char *name, + const char *type_name, + const char *symbol, + size_t size, + size_t alignment, + bool is_component) { - ecs_stage_t *stage = flecs_stage_from_world(&world); - - EcsSystem *system_data = (EcsSystem*)ecs_get( - world, system, EcsSystem); - assert(system_data != NULL); - - return ecs_run_intern(world, stage, system, system_data, 0, 0, delta_time, - offset, limit, param); -} + // If an explicit id is provided, it is possible that the symbol and + // name differ from the actual type, as the application may alias + // one type to another. + if (!id) { + if (!name) { + // If no name was provided, retrieve the name implicitly from + // the name_helper class. + name = ecs_cpp_trim_module(world, type_name); + } + } else { + // If an explicit id is provided but it has no name, inherit + // the name from the type. + if (!ecs_is_valid(world, id) || !ecs_get_name(world, id)) { + name = ecs_cpp_trim_module(world, type_name); + } + } -ecs_entity_t ecs_run_worker( - ecs_world_t *world, - ecs_entity_t system, - int32_t stage_current, - int32_t stage_count, - FLECS_FLOAT delta_time, - void *param) -{ - ecs_stage_t *stage = flecs_stage_from_world(&world); + ecs_entity_t entity; + if (is_component || size != 0) { + entity = ecs_component_init(world, &(ecs_component_desc_t){ + .entity.entity = s_id, + .entity.name = name, + .entity.sep = "::", + .entity.root_sep = "::", + .entity.symbol = symbol, + .size = size, + .alignment = alignment + }); + } else { + entity = ecs_entity_init(world, &(ecs_entity_desc_t){ + .entity = s_id, + .name = name, + .sep = "::", + .root_sep = "::", + .symbol = symbol + }); + } - EcsSystem *system_data = (EcsSystem*)ecs_get( - world, system, EcsSystem); - assert(system_data != NULL); + ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!s_id || s_id == entity, ECS_INTERNAL_ERROR, NULL); - return ecs_run_intern( - world, stage, system, system_data, stage_current, stage_count, - delta_time, 0, 0, param); + return entity; } -ecs_entity_t ecs_run( +ecs_entity_t ecs_cpp_enum_constant_register( ecs_world_t *world, - ecs_entity_t system, - FLECS_FLOAT delta_time, - void *param) + ecs_entity_t parent, + ecs_entity_t id, + const char *name, + int value) { - return ecs_run_w_filter(world, system, delta_time, 0, 0, param); -} + ecs_suspend_readonly_state_t readonly_state; + world = flecs_suspend_readonly(world, &readonly_state); -ecs_query_t* ecs_system_get_query( - const ecs_world_t *world, - ecs_entity_t system) -{ - const EcsQuery *q = ecs_get(world, system, EcsQuery); - if (q) { - return q->query; - } else { - const EcsSystem *s = ecs_get(world, system, EcsSystem); - if (s) { - return s->query; - } else { - return NULL; + const char *parent_name = ecs_get_name(world, parent); + ecs_size_t parent_name_len = ecs_os_strlen(parent_name); + if (!ecs_os_strncmp(name, parent_name, parent_name_len)) { + name += parent_name_len; + if (name[0] == '_') { + name ++; } } + + ecs_entity_t prev = ecs_set_scope(world, parent); + id = ecs_entity_init(world, &(ecs_entity_desc_t) { + .entity = id, + .name = name + }); + ecs_assert(id != 0, ECS_INVALID_OPERATION, name); + ecs_set_scope(world, prev); + + ecs_set_id(world, id, parent, sizeof(int), &value); + + flecs_resume_readonly(world, &readonly_state); + + ecs_trace("#[green]constant#[reset] %s.%s created with value %d", + ecs_get_name(world, parent), name, value); + + return id; } -void* ecs_get_system_ctx( - const ecs_world_t *world, - ecs_entity_t system) -{ - const EcsSystem *s = ecs_get(world, system, EcsSystem); - if (s) { - return s->ctx; - } else { - return NULL; - } +static int32_t flecs_reset_count = 0; + +int32_t ecs_cpp_reset_count_get(void) { + return flecs_reset_count; } -void* ecs_get_system_binding_ctx( - const ecs_world_t *world, - ecs_entity_t system) -{ - const EcsSystem *s = ecs_get(world, system, EcsSystem); - if (s) { - return s->binding_ctx; - } else { - return NULL; - } +int32_t ecs_cpp_reset_count_inc(void) { + return ++flecs_reset_count; } -/* System destructor */ -static -ECS_DTOR(EcsSystem, ptr, { - if (!ecs_is_alive(world, entity)) { - /* This can happen when a set is deferred while a system is being - * cleaned up. The operation will be discarded, but the destructor - * still needs to be invoked for the value */ - continue; - } +#endif - /* Invoke Deactivated action for active systems */ - if (ptr->query && ecs_query_table_count(ptr->query)) { - invoke_status_action(world, entity, ptr, EcsSystemDeactivated); - } - /* Invoke Disabled action for enabled systems */ - if (!ecs_has_id(world, entity, EcsDisabled)) { - invoke_status_action(world, entity, ptr, EcsSystemDisabled); - } +#ifdef FLECS_REST - if (ptr->ctx_free) { - ptr->ctx_free(ptr->ctx); - } +typedef struct { + ecs_world_t *world; + ecs_entity_t entity; + ecs_http_server_t *srv; + int32_t rc; +} ecs_rest_ctx_t; - if (ptr->status_ctx_free) { - ptr->status_ctx_free(ptr->status_ctx); +static ECS_COPY(EcsRest, dst, src, { + ecs_rest_ctx_t *impl = src->impl; + if (impl) { + impl->rc ++; } - if (ptr->binding_ctx_free) { - ptr->binding_ctx_free(ptr->binding_ctx); - } - - if (ptr->query) { - ecs_query_fini(ptr->query); - } + ecs_os_strset(&dst->ipaddr, src->ipaddr); + dst->port = src->port; + dst->impl = impl; }) -static -void EnableMonitor( - ecs_iter_t *it) -{ - if (ecs_is_fini(it->world)) { - return; - } - - EcsSystem *sys = ecs_term(it, EcsSystem, 1); +static ECS_MOVE(EcsRest, dst, src, { + *dst = *src; + src->ipaddr = NULL; + src->impl = NULL; +}) - int32_t i; - for (i = 0; i < it->count; i ++) { - if (it->event == EcsOnAdd) { - ecs_enable_system(it->world, it->entities[i], &sys[i], true); - } else if (it->event == EcsOnRemove) { - ecs_enable_system(it->world, it->entities[i], &sys[i], false); +static ECS_DTOR(EcsRest, ptr, { + ecs_rest_ctx_t *impl = ptr->impl; + if (impl) { + impl->rc --; + if (!impl->rc) { + ecs_http_server_fini(impl->srv); + ecs_os_free(impl); } } -} + ecs_os_free(ptr->ipaddr); +}) -ecs_entity_t ecs_system_init( - ecs_world_t *world, - const ecs_system_desc_t *desc) +static char *rest_last_err; + +static +void rest_capture_log( + int32_t level, + const char *file, + int32_t line, + const char *msg) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); + (void)file; (void)line; - ecs_entity_t existing = desc->entity.entity; - ecs_entity_t result = ecs_entity_init(world, &desc->entity); - if (!result) { - return 0; + if (!rest_last_err && level < 0) { + rest_last_err = ecs_os_strdup(msg); } +} - bool added = false; - EcsSystem *system = ecs_get_mut(world, result, EcsSystem, &added); - if (added) { - ecs_check(desc->callback != NULL, ECS_INVALID_PARAMETER, NULL); +static +char* rest_get_captured_log(void) { + char *result = rest_last_err; + rest_last_err = NULL; + return result; +} - memset(system, 0, sizeof(EcsSystem)); +static +void reply_verror( + ecs_http_reply_t *reply, + const char *fmt, + va_list args) +{ + ecs_strbuf_appendstr(&reply->body, "{\"error\":\""); + ecs_strbuf_vappend(&reply->body, fmt, args); + ecs_strbuf_appendstr(&reply->body, "\"}"); +} - ecs_query_desc_t query_desc = desc->query; - query_desc.filter.name = desc->entity.name; - query_desc.system = result; +static +void reply_error( + ecs_http_reply_t *reply, + const char *fmt, + ...) +{ + va_list args; + va_start(args, fmt); + reply_verror(reply, fmt, args); + va_end(args); +} - ecs_query_t *query = ecs_query_init(world, &query_desc); - if (!query) { - ecs_delete(world, result); - return 0; +static +void rest_bool_param( + const ecs_http_request_t *req, + const char *name, + bool *value_out) +{ + const char *value = ecs_http_get_param(req, name); + if (value) { + if (!ecs_os_strcmp(value, "true")) { + value_out[0] = true; + } else { + value_out[0] = false; } + } +} - /* Re-obtain pointer, as query may have added components */ - system = ecs_get_mut(world, result, EcsSystem, &added); - ecs_assert(added == false, ECS_INTERNAL_ERROR, NULL); - - /* Prevent the system from moving while we're initializing */ - ecs_defer_begin(world); - - system->entity = result; - system->query = query; - - system->run = desc->run; - system->action = desc->callback; - system->status_action = desc->status_callback; +static +void rest_int_param( + const ecs_http_request_t *req, + const char *name, + int32_t *value_out) +{ + const char *value = ecs_http_get_param(req, name); + if (value) { + *value_out = atoi(value); + } +} - system->self = desc->self; - system->ctx = desc->ctx; - system->status_ctx = desc->status_ctx; - system->binding_ctx = desc->binding_ctx; +static +void rest_parse_json_ser_entity_params( + ecs_entity_to_json_desc_t *desc, + const ecs_http_request_t *req) +{ + rest_bool_param(req, "path", &desc->serialize_path); + rest_bool_param(req, "label", &desc->serialize_label); + rest_bool_param(req, "brief", &desc->serialize_brief); + rest_bool_param(req, "link", &desc->serialize_link); + rest_bool_param(req, "id_labels", &desc->serialize_id_labels); + rest_bool_param(req, "base", &desc->serialize_base); + rest_bool_param(req, "values", &desc->serialize_values); + rest_bool_param(req, "private", &desc->serialize_private); + rest_bool_param(req, "type_info", &desc->serialize_type_info); +} - system->ctx_free = desc->ctx_free; - system->status_ctx_free = desc->status_ctx_free; - system->binding_ctx_free = desc->binding_ctx_free; +static +void rest_parse_json_ser_iter_params( + ecs_iter_to_json_desc_t *desc, + const ecs_http_request_t *req) +{ + rest_bool_param(req, "term_ids", &desc->serialize_term_ids); + rest_bool_param(req, "ids", &desc->serialize_ids); + rest_bool_param(req, "subjects", &desc->serialize_subjects); + rest_bool_param(req, "variables", &desc->serialize_variables); + rest_bool_param(req, "is_set", &desc->serialize_is_set); + rest_bool_param(req, "values", &desc->serialize_values); + rest_bool_param(req, "entities", &desc->serialize_entities); + rest_bool_param(req, "entity_labels", &desc->serialize_entity_labels); + rest_bool_param(req, "variable_labels", &desc->serialize_variable_labels); + rest_bool_param(req, "duration", &desc->measure_eval_duration); + rest_bool_param(req, "type_info", &desc->serialize_type_info); +} - system->tick_source = desc->tick_source; +static +bool rest_reply( + const ecs_http_request_t* req, + ecs_http_reply_t *reply, + void *ctx) +{ + ecs_rest_ctx_t *impl = ctx; + ecs_world_t *world = impl->world; - system->multi_threaded = desc->multi_threaded; - system->no_staging = desc->no_staging; + if (req->path == NULL) { + ecs_dbg("rest: bad request (missing path)"); + reply_error(reply, "bad request (missing path)"); + reply->code = 400; + return false; + } - /* If tables have been matched with this system it is active, and we - * should activate the in terms, if any. This will ensure that any - * OnDemand systems get enabled. */ - if (ecs_query_table_count(query)) { - ecs_system_activate(world, result, true, system); - } else { - /* If system isn't matched with any tables, mark it as inactive. This - * causes it to be ignored by the main loop. When the system matches - * with a table it will be activated. */ - ecs_add_id(world, result, EcsInactive); - } + ecs_strbuf_appendstr(&reply->headers, "Access-Control-Allow-Origin: *\r\n"); - if (!ecs_has_id(world, result, EcsDisabled)) { - /* If system is already enabled, generate enable status. The API - * should guarantee that it exactly matches enable-disable - * notifications and activate-deactivate notifications. */ - invoke_status_action(world, result, system, EcsSystemEnabled); + if (req->method == EcsHttpGet) { + /* Entity endpoint */ + if (!ecs_os_strncmp(req->path, "entity/", 7)) { + char *path = &req->path[7]; + ecs_dbg_2("rest: request entity '%s'", path); - /* If column system has active (non-empty) tables, also generate the - * activate status. */ - if (ecs_query_table_count(system->query)) { - invoke_status_action(world, result, system, EcsSystemActivated); + ecs_entity_t e = ecs_lookup_path_w_sep( + world, 0, path, "/", NULL, false); + if (!e) { + ecs_dbg_2("rest: entity '%s' not found", path); + reply_error(reply, "entity '%s' not found", path); + reply->code = 404; + return true; } - } - if (desc->interval != 0 || desc->rate != 0 || desc->tick_source != 0) { -#ifdef FLECS_TIMER - if (desc->interval != 0) { - ecs_set_interval(world, result, desc->interval); - } + ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT; + rest_parse_json_ser_entity_params(&desc, req); - if (desc->rate) { - ecs_set_rate(world, result, desc->rate, desc->tick_source); - } else if (desc->tick_source) { - ecs_set_tick_source(world, result, desc->tick_source); + ecs_entity_to_json_buf(world, e, &reply->body, &desc); + return true; + + /* Query endpoint */ + } else if (!ecs_os_strcmp(req->path, "query")) { + const char *q = ecs_http_get_param(req, "q"); + if (!q) { + ecs_strbuf_appendstr(&reply->body, "Missing parameter 'q'"); + reply->code = 400; /* bad request */ + return true; } -#else - ecs_abort(ECS_UNSUPPORTED, "timer module not available"); -#endif - } - ecs_modified(world, result, EcsSystem); + ecs_dbg_2("rest: request query '%s'", q); + bool prev_color = ecs_log_enable_colors(false); + ecs_os_api_log_t prev_log_ = ecs_os_api.log_; + ecs_os_api.log_ = rest_capture_log; - if (desc->entity.name) { - ecs_trace("#[green]system#[reset] %s created", - ecs_get_name(world, result)); - } + ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t) { + .expr = q + }); + if (!r) { + char *err = rest_get_captured_log(); + char *escaped_err = ecs_astresc('"', err); + reply_error(reply, escaped_err); + reply->code = 400; /* bad request */ + ecs_os_free(escaped_err); + ecs_os_free(err); + } else { + ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT; + rest_parse_json_ser_iter_params(&desc, req); - ecs_defer_end(world); - } else { - const char *expr_desc = desc->query.filter.expr; - const char *expr_sys = system->query->filter.expr; + int32_t offset = 0; + int32_t limit = 100; - /* Only check expression if it's set */ - if (expr_desc) { - if (expr_sys && !strcmp(expr_sys, "0")) expr_sys = NULL; - if (expr_desc && !strcmp(expr_desc, "0")) expr_desc = NULL; + rest_int_param(req, "offset", &offset); + rest_int_param(req, "limit", &limit); - if (expr_sys && expr_desc) { - if (strcmp(expr_sys, expr_desc)) { - ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); - } - } else { - if (expr_sys != expr_desc) { - ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); - } + ecs_iter_t it = ecs_rule_iter(world, r); + ecs_iter_t pit = ecs_page_iter(&it, offset, limit); + ecs_iter_to_json_buf(world, &pit, &reply->body, &desc); + ecs_rule_fini(r); } - /* If expr_desc is not set, and this is an existing system, don't throw - * an error because we could be updating existing parameters of the - * system such as the context or system callback. However, if no - * entity handle was provided, we have to assume that the application is - * trying to redeclare the system. */ - } else if (!existing) { - if (expr_sys) { - ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); - } - } + ecs_os_api.log_ = prev_log_; + ecs_log_enable_colors(prev_color); - if (desc->run) { - system->run = desc->run; - } - if (desc->callback) { - system->action = desc->callback; - } - if (desc->ctx) { - system->ctx = desc->ctx; - } - if (desc->binding_ctx) { - system->binding_ctx = desc->binding_ctx; - } - if (desc->query.filter.instanced) { - system->query->filter.instanced = true; - } - if (desc->multi_threaded) { - system->multi_threaded = desc->multi_threaded; - } - if (desc->no_staging) { - system->no_staging = desc->no_staging; + return true; } } + if (req->method == EcsHttpOptions) { + return true; + } - return result; -error: - return 0; -} - -void FlecsSystemImport( - ecs_world_t *world) -{ - ECS_MODULE(world, FlecsSystem); - - ecs_set_name_prefix(world, "Ecs"); - - flecs_bootstrap_component(world, EcsSystem); - flecs_bootstrap_component(world, EcsTickSource); - - /* Put following tags in flecs.core so they can be looked up - * without using the flecs.systems prefix. */ - ecs_entity_t old_scope = ecs_set_scope(world, EcsFlecsCore); - flecs_bootstrap_tag(world, EcsInactive); - flecs_bootstrap_tag(world, EcsMonitor); - ecs_set_scope(world, old_scope); - - /* Bootstrap ctor and dtor for EcsSystem */ - ecs_set_component_actions_w_id(world, ecs_id(EcsSystem), - &(EcsComponentLifecycle) { - .ctor = ecs_default_ctor, - .dtor = ecs_dtor(EcsSystem) - }); - - ecs_observer_init(world, &(ecs_observer_desc_t) { - .entity.name = "EnableMonitor", - .filter.terms = { - { .id = ecs_id(EcsSystem) }, - { .id = EcsDisabled, .oper = EcsNot }, - }, - .events = {EcsMonitor}, - .callback = EnableMonitor - }); + return false; } -#endif - - -#ifdef FLECS_JSON - -void json_next( - ecs_strbuf_t *buf); - -void json_literal( - ecs_strbuf_t *buf, - const char *value); +static +void on_set_rest(ecs_iter_t *it) +{ + EcsRest *rest = it->ptrs[0]; -void json_number( - ecs_strbuf_t *buf, - double value); + int i; + for(i = 0; i < it->count; i ++) { + if (!rest[i].port) { + rest[i].port = ECS_REST_DEFAULT_PORT; + } -void json_true( - ecs_strbuf_t *buf); + ecs_rest_ctx_t *srv_ctx = ecs_os_malloc_t(ecs_rest_ctx_t); + ecs_http_server_t *srv = ecs_http_server_init(&(ecs_http_server_desc_t){ + .ipaddr = rest[i].ipaddr, + .port = rest[i].port, + .callback = rest_reply, + .ctx = srv_ctx + }); -void json_false( - ecs_strbuf_t *buf); + if (!srv) { + const char *ipaddr = rest[i].ipaddr ? rest[i].ipaddr : "0.0.0.0"; + ecs_err("failed to create REST server on %s:%u", + ipaddr, rest[i].port); + ecs_os_free(srv_ctx); + continue; + } -void json_bool( - ecs_strbuf_t *buf, - bool value); + srv_ctx->world = it->world; + srv_ctx->entity = it->entities[i]; + srv_ctx->srv = srv; + srv_ctx->rc = 1; -void json_array_push( - ecs_strbuf_t *buf); + rest[i].impl = srv_ctx; -void json_array_pop( - ecs_strbuf_t *buf); + ecs_http_server_start(srv_ctx->srv); + } +} -void json_object_push( - ecs_strbuf_t *buf); +static +void DequeueRest(ecs_iter_t *it) { + EcsRest *rest = ecs_term(it, EcsRest, 1); -void json_object_pop( - ecs_strbuf_t *buf); + if (it->delta_system_time > (FLECS_FLOAT)1.0) { + ecs_warn( + "detected large progress interval (%.2fs), REST request may timeout", + (double)it->delta_system_time); + } -void json_string( - ecs_strbuf_t *buf, - const char *value); + int32_t i; + for(i = 0; i < it->count; i ++) { + ecs_rest_ctx_t *ctx = rest[i].impl; + if (ctx) { + ecs_http_server_dequeue(ctx->srv, it->delta_time); + } + } +} -void json_member( - ecs_strbuf_t *buf, - const char *name); +void FlecsRestImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsRest); -void json_path( - ecs_strbuf_t *buf, - const ecs_world_t *world, - ecs_entity_t e); + ecs_set_name_prefix(world, "Ecs"); -void json_label( - ecs_strbuf_t *buf, - const ecs_world_t *world, - ecs_entity_t e); + flecs_bootstrap_component(world, EcsRest); -void json_id( - ecs_strbuf_t *buf, - const ecs_world_t *world, - ecs_id_t id); + ecs_set_component_actions(world, EcsRest, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsRest), + .copy = ecs_copy(EcsRest), + .dtor = ecs_dtor(EcsRest), + .on_set = on_set_rest + }); -ecs_primitive_kind_t json_op_to_primitive_kind( - ecs_meta_type_op_kind_t kind); + ECS_SYSTEM(world, DequeueRest, EcsPostFrame, EcsRest); +} #endif +#ifndef FLECS_META_PRIVATE_H +#define FLECS_META_PRIVATE_H -#ifdef FLECS_JSON -void json_next( - ecs_strbuf_t *buf) -{ - ecs_strbuf_list_next(buf); -} +#ifdef FLECS_META -void json_literal( - ecs_strbuf_t *buf, - const char *value) -{ - ecs_strbuf_appendstr(buf, value); -} +void ecs_meta_type_serialized_init( + ecs_iter_t *it); -void json_number( - ecs_strbuf_t *buf, - double value) -{ - ecs_strbuf_appendflt(buf, value, '"'); -} +void ecs_meta_dtor_serialized( + EcsMetaTypeSerialized *ptr); -void json_true( - ecs_strbuf_t *buf) -{ - json_literal(buf, "true"); -} -void json_false( - ecs_strbuf_t *buf) -{ - json_literal(buf, "false"); -} +bool flecs_unit_validate( + ecs_world_t *world, + ecs_entity_t t, + EcsUnit *data); -void json_bool( - ecs_strbuf_t *buf, - bool value) -{ - if (value) { - json_true(buf); - } else { - json_false(buf); - } -} +#endif + +#endif -void json_array_push( - ecs_strbuf_t *buf) -{ - ecs_strbuf_list_push(buf, "[", ", "); -} -void json_array_pop( - ecs_strbuf_t *buf) -{ - ecs_strbuf_list_pop(buf, "]"); -} +#ifdef FLECS_META -void json_object_push( - ecs_strbuf_t *buf) +static +const char* op_kind_str( + ecs_meta_type_op_kind_t kind) { - ecs_strbuf_list_push(buf, "{", ", "); -} + switch(kind) { -void json_object_pop( - ecs_strbuf_t *buf) -{ - ecs_strbuf_list_pop(buf, "}"); + case EcsOpEnum: return "Enum"; + case EcsOpBitmask: return "Bitmask"; + case EcsOpArray: return "Array"; + case EcsOpVector: return "Vector"; + case EcsOpPush: return "Push"; + case EcsOpPop: return "Pop"; + case EcsOpPrimitive: return "Primitive"; + case EcsOpBool: return "Bool"; + case EcsOpChar: return "Char"; + case EcsOpByte: return "Byte"; + case EcsOpU8: return "U8"; + case EcsOpU16: return "U16"; + case EcsOpU32: return "U32"; + case EcsOpU64: return "U64"; + case EcsOpI8: return "I8"; + case EcsOpI16: return "I16"; + case EcsOpI32: return "I32"; + case EcsOpI64: return "I64"; + case EcsOpF32: return "F32"; + case EcsOpF64: return "F64"; + case EcsOpUPtr: return "UPtr"; + case EcsOpIPtr: return "IPtr"; + case EcsOpString: return "String"; + case EcsOpEntity: return "Entity"; + default: return "<< invalid kind >>"; + } } -void json_string( - ecs_strbuf_t *buf, - const char *value) +/* Get current scope */ +static +ecs_meta_scope_t* get_scope( + const ecs_meta_cursor_t *cursor) { - ecs_strbuf_appendch(buf, '"'); - ecs_strbuf_appendstr(buf, value); - ecs_strbuf_appendch(buf, '"'); + ecs_check(cursor != NULL, ECS_INVALID_PARAMETER, NULL); + return (ecs_meta_scope_t*)&cursor->scope[cursor->depth]; +error: + return NULL; } -void json_member( - ecs_strbuf_t *buf, - const char *name) +/* Get previous scope */ +static +ecs_meta_scope_t* get_prev_scope( + ecs_meta_cursor_t *cursor) { - ecs_strbuf_list_appendstr(buf, "\""); - ecs_strbuf_appendstr(buf, name); - ecs_strbuf_appendstr(buf, "\":"); + ecs_check(cursor != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(cursor->depth > 0, ECS_INVALID_PARAMETER, NULL); + return &cursor->scope[cursor->depth - 1]; +error: + return NULL; } -void json_path( - ecs_strbuf_t *buf, - const ecs_world_t *world, - ecs_entity_t e) +/* Get current operation for scope */ +static +ecs_meta_type_op_t* get_op( + ecs_meta_scope_t *scope) { - ecs_strbuf_appendch(buf, '"'); - ecs_get_path_w_sep_buf(world, 0, e, ".", "", buf); - ecs_strbuf_appendch(buf, '"'); + return &scope->ops[scope->op_cur]; } -void json_label( - ecs_strbuf_t *buf, +/* Get component for type in current scope */ +static +const EcsComponent* get_component_ptr( const ecs_world_t *world, - ecs_entity_t e) + ecs_meta_scope_t *scope) { - const char *lbl = NULL; -#ifdef FLECS_DOC - lbl = ecs_doc_get_name(world, e); -#else - lbl = ecs_get_name(world, e); -#endif - - if (lbl) { - ecs_strbuf_appendch(buf, '"'); - ecs_strbuf_appendstr(buf, lbl); - ecs_strbuf_appendch(buf, '"'); - } else { - ecs_strbuf_appendstr(buf, "0"); + const EcsComponent *comp = scope->comp; + if (!comp) { + comp = scope->comp = ecs_get(world, scope->type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); } + return comp; } -void json_id( - ecs_strbuf_t *buf, +/* Get size for type in current scope */ +static +ecs_size_t get_size( const ecs_world_t *world, - ecs_id_t id) + ecs_meta_scope_t *scope) { - ecs_strbuf_appendch(buf, '"'); - ecs_id_str_buf(world, id, buf); - ecs_strbuf_appendch(buf, '"'); + return get_component_ptr(world, scope)->size; } -ecs_primitive_kind_t json_op_to_primitive_kind( - ecs_meta_type_op_kind_t kind) +/* Get alignment for type in current scope */ +static +ecs_size_t get_alignment( + const ecs_world_t *world, + ecs_meta_scope_t *scope) { - return kind - EcsOpPrimitive; + return get_component_ptr(world, scope)->alignment; } -#endif - - -#include +static +int32_t get_elem_count( + ecs_meta_scope_t *scope) +{ + if (scope->vector) { + return ecs_vector_count(*(scope->vector)); + } -#ifdef FLECS_JSON + ecs_meta_type_op_t *op = get_op(scope); + return op->count; +} +/* Get pointer to current field/element */ static -int json_ser_type( +ecs_meta_type_op_t* get_ptr( const ecs_world_t *world, - ecs_vector_t *ser, - const void *base, - ecs_strbuf_t *str); + ecs_meta_scope_t *scope) +{ + ecs_meta_type_op_t *op = get_op(scope); + ecs_size_t size = get_size(world, scope); -static -int json_ser_type_ops( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - ecs_strbuf_t *str); + if (scope->vector) { + ecs_size_t align = get_alignment(world, scope); + ecs_vector_set_min_count_t( + scope->vector, size, align, scope->elem_cur + 1); + scope->ptr = ecs_vector_first_t(*(scope->vector), size, align); + } -static -int json_ser_type_op( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str); + return ECS_OFFSET(scope->ptr, size * scope->elem_cur + op->offset); +} -/* Serialize enumeration */ static -int json_ser_enum( +int push_type( const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str) + ecs_meta_scope_t *scope, + ecs_entity_t type, + void *ptr) { - const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum); - ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL); - - int32_t value = *(int32_t*)base; - - /* Enumeration constants are stored in a map that is keyed on the - * enumeration value. */ - ecs_enum_constant_t *constant = ecs_map_get( - enum_type->constants, ecs_enum_constant_t, value); - if (!constant) { - goto error; + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + if (ser == NULL) { + char *str = ecs_id_str(world, type); + ecs_err("cannot open scope for entity '%s' which is not a type", str); + ecs_os_free(str); + return -1; } - ecs_strbuf_appendch(str, '"'); - ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant)); - ecs_strbuf_appendch(str, '"'); + scope[0] = (ecs_meta_scope_t) { + .type = type, + .ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t), + .op_count = ecs_vector_count(ser->ops), + .ptr = ptr + }; return 0; -error: - return -1; } -/* Serialize bitmask */ -static -int json_ser_bitmask( +ecs_meta_cursor_t ecs_meta_cursor( const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) + ecs_entity_t type, + void *ptr) { - const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask); - ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL); - - uint32_t value = *(uint32_t*)ptr; - ecs_map_key_t key; - ecs_bitmask_constant_t *constant; - - if (!value) { - ecs_strbuf_appendch(str, '0'); - return 0; - } - - ecs_strbuf_list_push(str, "\"", "|"); + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(type != 0, ECS_INVALID_PARAMETER, NULL); + ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); - /* Multiple flags can be set at a given time. Iterate through all the flags - * and append the ones that are set. */ - ecs_map_iter_t it = ecs_map_iter(bitmask_type->constants); - while ((constant = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { - if ((value & key) == key) { - ecs_strbuf_list_appendstr(str, - ecs_get_name(world, constant->constant)); - value -= (uint32_t)key; - } - } + ecs_meta_cursor_t result = { + .world = world, + .valid = true + }; - if (value != 0) { - /* All bits must have been matched by a constant */ - goto error; + if (push_type(world, result.scope, type, ptr) != 0) { + result.valid = false; } - ecs_strbuf_list_pop(str, "\""); - - return 0; + return result; error: - return -1; + return (ecs_meta_cursor_t){ 0 }; } -/* Serialize elements of a contiguous array */ -static -int json_ser_elements( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - int32_t elem_count, - int32_t elem_size, - ecs_strbuf_t *str) +void* ecs_meta_get_ptr( + ecs_meta_cursor_t *cursor) { - json_array_push(str); + return get_ptr(cursor->world, get_scope(cursor)); +} - const void *ptr = base; +int ecs_meta_next( + ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); - int i; - for (i = 0; i < elem_count; i ++) { - ecs_strbuf_list_next(str); - if (json_ser_type_ops(world, ops, op_count, ptr, str)) { + if (scope->is_collection) { + scope->elem_cur ++; + scope->op_cur = 0; + if (scope->elem_cur >= get_elem_count(scope)) { + ecs_err("out of collection bounds (%d)", scope->elem_cur); return -1; } - ptr = ECS_OFFSET(ptr, elem_size); + + return 0; } - json_array_pop(str); + scope->op_cur += op->op_count; + if (scope->op_cur >= scope->op_count) { + ecs_err("out of bounds"); + return -1; + } return 0; } -static -int json_ser_type_elements( - const ecs_world_t *world, - ecs_entity_t type, - const void *base, - int32_t elem_count, - ecs_strbuf_t *str) +int ecs_meta_member( + ecs_meta_cursor_t *cursor, + const char *name) { - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); - - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + if (cursor->depth == 0) { + ecs_err("cannot move to member in root scope"); + return -1; + } - ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); - int32_t op_count = ecs_vector_count(ser->ops); + ecs_meta_scope_t *prev_scope = get_prev_scope(cursor); + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *push_op = get_op(prev_scope); + const ecs_world_t *world = cursor->world; - return json_ser_elements( - world, ops, op_count, base, elem_count, comp->size, str); -} + ecs_assert(push_op->kind == EcsOpPush, ECS_INTERNAL_ERROR, NULL); + + if (!push_op->members) { + ecs_err("cannot move to member '%s' for non-struct type", name); + return -1; + } -/* Serialize array */ -static -int json_ser_array( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) -{ - const EcsArray *a = ecs_get(world, op->type, EcsArray); - ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL); + const uint64_t *cur_ptr = flecs_name_index_find_ptr(push_op->members, name, 0, 0); + if (!cur_ptr) { + char *path = ecs_get_fullpath(world, scope->type); + ecs_err("unknown member '%s' for type '%s'", name, path); + ecs_os_free(path); + return -1; + } - return json_ser_type_elements( - world, a->type, ptr, a->count, str); + scope->op_cur = flecs_uto(int32_t, cur_ptr[0]); + + return 0; } -/* Serialize vector */ -static -int json_ser_vector( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *base, - ecs_strbuf_t *str) +int ecs_meta_push( + ecs_meta_cursor_t *cursor) { - ecs_vector_t *value = *(ecs_vector_t**)base; - if (!value) { - ecs_strbuf_appendstr(str, "null"); - return 0; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + const ecs_world_t *world = cursor->world; + + if (cursor->depth == 0) { + if (!cursor->is_primitive_scope) { + if (op->kind > EcsOpScope) { + cursor->is_primitive_scope = true; + return 0; + } + } } - const EcsVector *v = ecs_get(world, op->type, EcsVector); - ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL); + void *ptr = get_ptr(world, scope); + cursor->depth ++; + ecs_check(cursor->depth < ECS_META_MAX_SCOPE_DEPTH, + ECS_INVALID_PARAMETER, NULL); - const EcsComponent *comp = ecs_get(world, v->type, EcsComponent); - ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_meta_scope_t *next_scope = get_scope(cursor); - int32_t count = ecs_vector_count(value); - void *array = ecs_vector_first_t(value, comp->size, comp->alignment); + /* If we're not already in an inline array and this operation is an inline + * array, push a frame for the array. + * Doing this first ensures that inline arrays take precedence over other + * kinds of push operations, such as for a struct element type. */ + if (!scope->is_inline_array && op->count > 1 && !scope->is_collection) { + /* Push a frame just for the element type, with inline_array = true */ + next_scope[0] = (ecs_meta_scope_t){ + .ops = op, + .op_count = op->op_count, + .ptr = scope->ptr, + .type = op->type, + .is_collection = true, + .is_inline_array = true + }; - /* Serialize contiguous buffer of vector */ - return json_ser_type_elements(world, v->type, array, count, str); -} + /* With 'is_inline_array' set to true we ensure that we can never push + * the same inline array twice */ + + return 0; + } -/* Forward serialization to the different type kinds */ -static -int json_ser_type_op( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - const void *ptr, - ecs_strbuf_t *str) -{ switch(op->kind) { case EcsOpPush: - case EcsOpPop: - /* Should not be parsed as single op */ - ecs_throw(ECS_INVALID_PARAMETER, NULL); - break; - case EcsOpF32: - ecs_strbuf_appendflt(str, - (ecs_f64_t)*(ecs_f32_t*)ECS_OFFSET(ptr, op->offset), '"'); - break; - case EcsOpF64: - ecs_strbuf_appendflt(str, - *(ecs_f64_t*)ECS_OFFSET(ptr, op->offset), '"'); - break; - case EcsOpEnum: - if (json_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; - } - break; - case EcsOpBitmask: - if (json_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) { - goto error; - } + next_scope[0] = (ecs_meta_scope_t) { + .ops = &op[1], /* op after push */ + .op_count = op->op_count - 1, /* don't include pop */ + .ptr = scope->ptr, + .type = op->type + }; break; - case EcsOpArray: - if (json_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) { + + case EcsOpArray: { + if (push_type(world, next_scope, op->type, ptr) != 0) { goto error; } + + const EcsArray *type_ptr = ecs_get(world, op->type, EcsArray); + next_scope->type = type_ptr->type; + next_scope->is_collection = true; break; + } + case EcsOpVector: - if (json_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) { + next_scope->vector = ptr; + if (push_type(world, next_scope, op->type, NULL) != 0) { goto error; } + + const EcsVector *type_ptr = ecs_get(world, op->type, EcsVector); + next_scope->type = type_ptr->type; + next_scope->is_collection = true; break; - case EcsOpEntity: { - ecs_entity_t e = *(ecs_entity_t*)ECS_OFFSET(ptr, op->offset); - if (!e) { - ecs_strbuf_appendch(str, '0'); - } else { - json_path(str, world, e); - } - break; + + default: { + char *path = ecs_get_fullpath(world, scope->type); + ecs_err("invalid push for type '%s'", path); + ecs_os_free(path); + goto error; + } } - default: - if (ecs_primitive_to_expr_buf(world, - json_op_to_primitive_kind(op->kind), - ECS_OFFSET(ptr, op->offset), str)) - { - /* Unknown operation */ - ecs_throw(ECS_INTERNAL_ERROR, NULL); - return -1; - } - break; + if (scope->is_collection) { + next_scope[0].ptr = ECS_OFFSET(next_scope[0].ptr, + scope->elem_cur * get_size(world, scope)); } return 0; @@ -28795,19122 +27865,20067 @@ int json_ser_type_op( return -1; } -/* Iterate over a slice of the type ops array */ -static -int json_ser_type_ops( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - const void *base, - ecs_strbuf_t *str) +int ecs_meta_pop( + ecs_meta_cursor_t *cursor) { - for (int i = 0; i < op_count; i ++) { - ecs_meta_type_op_t *op = &ops[i]; + if (cursor->is_primitive_scope) { + cursor->is_primitive_scope = false; + return 0; + } - if (op != ops) { - if (op->name) { - json_member(str, op->name); - } + ecs_meta_scope_t *scope = get_scope(cursor); + cursor->depth --; + if (cursor->depth < 0) { + ecs_err("unexpected end of scope"); + return -1; + } - int32_t elem_count = op->count; - if (elem_count > 1 && op != ops) { - /* Serialize inline array */ - if (json_ser_elements(world, op, op->op_count, base, - elem_count, op->size, str)) - { - return -1; - } + ecs_meta_scope_t *next_scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(next_scope); - i += op->op_count - 1; - continue; - } - } - - switch(op->kind) { - case EcsOpPush: - json_object_push(str); - break; - case EcsOpPop: - json_object_pop(str); - break; - default: - if (json_ser_type_op(world, op, base, str)) { - goto error; - } - break; + if (!scope->is_inline_array) { + if (op->kind == EcsOpPush) { + next_scope->op_cur += op->op_count - 1; + + /* push + op_count should point to the operation after pop */ + op = get_op(next_scope); + ecs_assert(op->kind == EcsOpPop, ECS_INTERNAL_ERROR, NULL); + } else if (op->kind == EcsOpArray || op->kind == EcsOpVector) { + /* Collection type, nothing else to do */ + } else { + /* should not have been able to push if the previous scope was not + * a complex or collection type */ + ecs_assert(false, ECS_INTERNAL_ERROR, NULL); } + } else { + /* Make sure that this was an inline array */ + ecs_assert(next_scope->op_count > 1, ECS_INTERNAL_ERROR, NULL); } return 0; -error: - return -1; } -/* Iterate over the type ops of a type */ -static -int json_ser_type( - const ecs_world_t *world, - ecs_vector_t *v_ops, - const void *base, - ecs_strbuf_t *str) +bool ecs_meta_is_collection( + const ecs_meta_cursor_t *cursor) { - ecs_meta_type_op_t *ops = ecs_vector_first(v_ops, ecs_meta_type_op_t); - int32_t count = ecs_vector_count(v_ops); - return json_ser_type_ops(world, ops, count, base, str); + ecs_meta_scope_t *scope = get_scope(cursor); + return scope->is_collection; } -static -int array_to_json_buf_w_type_data( - const ecs_world_t *world, - const void *ptr, - int32_t count, - ecs_strbuf_t *buf, - const EcsComponent *comp, - const EcsMetaTypeSerialized *ser) +ecs_entity_t ecs_meta_get_type( + const ecs_meta_cursor_t *cursor) { - if (count) { - ecs_size_t size = comp->size; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + return op->type; +} - json_array_push(buf); +ecs_entity_t ecs_meta_get_unit( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + return op->unit; +} - do { - ecs_strbuf_list_next(buf); - if (json_ser_type(world, ser->ops, ptr, buf)) { - return -1; - } +const char* ecs_meta_get_member( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + return op->name; +} - ptr = ECS_OFFSET(ptr, size); - } while (-- count); +/* Utility macro's to let the compiler do the conversion work for us */ +#define set_T(T, ptr, value)\ + ((T*)ptr)[0] = ((T)value) - json_array_pop(buf); - } else { - if (json_ser_type(world, ser->ops, ptr, buf)) { - return -1; - } - } +#define case_T(kind, T, dst, src)\ +case kind:\ + set_T(T, dst, src);\ + break - return 0; +#define cases_T_float(dst, src)\ + case_T(EcsOpF32, ecs_f32_t, dst, src);\ + case_T(EcsOpF64, ecs_f64_t, dst, src) + +#define cases_T_signed(dst, src)\ + case_T(EcsOpChar, ecs_char_t, dst, src);\ + case_T(EcsOpI8, ecs_i8_t, dst, src);\ + case_T(EcsOpI16, ecs_i16_t, dst, src);\ + case_T(EcsOpI32, ecs_i32_t, dst, src);\ + case_T(EcsOpI64, ecs_i64_t, dst, src);\ + case_T(EcsOpIPtr, ecs_iptr_t, dst, src) + +#define cases_T_unsigned(dst, src)\ + case_T(EcsOpByte, ecs_byte_t, dst, src);\ + case_T(EcsOpU8, ecs_u8_t, dst, src);\ + case_T(EcsOpU16, ecs_u16_t, dst, src);\ + case_T(EcsOpU32, ecs_u32_t, dst, src);\ + case_T(EcsOpU64, ecs_u64_t, dst, src);\ + case_T(EcsOpUPtr, ecs_uptr_t, dst, src);\ + +#define cases_T_bool(dst, src)\ +case EcsOpBool:\ + set_T(ecs_bool_t, dst, value != 0);\ + break + +static +void conversion_error( + ecs_meta_cursor_t *cursor, + ecs_meta_type_op_t *op, + const char *from) +{ + char *path = ecs_get_fullpath(cursor->world, op->type); + ecs_err("unsupported conversion from %s to '%s'", from, path); + ecs_os_free(path); } -int ecs_array_to_json_buf( - const ecs_world_t *world, - ecs_entity_t type, - const void *ptr, - int32_t count, - ecs_strbuf_t *buf) +int ecs_meta_set_bool( + ecs_meta_cursor_t *cursor, + bool value) { - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - if (!comp) { - char *path = ecs_get_fullpath(world, type); - ecs_err("cannot serialize to JSON, '%s' is not a component", path); - ecs_os_free(path); - return -1; - } + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - if (!ser) { - char *path = ecs_get_fullpath(world, type); - ecs_err("cannot serialize to JSON, '%s' has no reflection data", path); - ecs_os_free(path); + switch(op->kind) { + cases_T_bool(ptr, value); + cases_T_unsigned(ptr, value); + default: + conversion_error(cursor, op, "bool"); return -1; } - return array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser); + return 0; } -char* ecs_array_to_json( - const ecs_world_t *world, - ecs_entity_t type, - const void* ptr, - int32_t count) +int ecs_meta_set_char( + ecs_meta_cursor_t *cursor, + char value) { - ecs_strbuf_t str = ECS_STRBUF_INIT; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - if (ecs_array_to_json_buf(world, type, ptr, count, &str) != 0) { - ecs_strbuf_reset(&str); - return NULL; + switch(op->kind) { + cases_T_bool(ptr, value); + cases_T_signed(ptr, value); + default: + conversion_error(cursor, op, "char"); + return -1; } - return ecs_strbuf_get(&str); + return 0; } -int ecs_ptr_to_json_buf( - const ecs_world_t *world, - ecs_entity_t type, - const void *ptr, - ecs_strbuf_t *buf) +int ecs_meta_set_int( + ecs_meta_cursor_t *cursor, + int64_t value) { - return ecs_array_to_json_buf(world, type, ptr, 0, buf); -} + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); -char* ecs_ptr_to_json( - const ecs_world_t *world, - ecs_entity_t type, - const void* ptr) -{ - return ecs_array_to_json(world, type, ptr, 0); + switch(op->kind) { + cases_T_bool(ptr, value); + cases_T_signed(ptr, value); + cases_T_float(ptr, value); + default: { + conversion_error(cursor, op, "int"); + return -1; + } + } + + return 0; } -static -bool skip_id( - const ecs_world_t *world, - ecs_id_t id, - const ecs_entity_to_json_desc_t *desc, - ecs_entity_t ent, - ecs_entity_t inst, - ecs_entity_t *pred_out, - ecs_entity_t *obj_out, - ecs_entity_t *role_out, - bool *hidden_out) +int ecs_meta_set_uint( + ecs_meta_cursor_t *cursor, + uint64_t value) { - bool is_base = ent != inst; - ecs_entity_t pred = 0, obj = 0, role = 0; - bool hidden = false; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - if (ECS_HAS_ROLE(id, PAIR)) { - pred = ecs_pair_first(world, id); - obj = ecs_pair_second(world, id); - } else { - pred = id & ECS_COMPONENT_MASK; - if (id & ECS_ROLE_MASK) { - role = id & ECS_ROLE_MASK; - } + switch(op->kind) { + cases_T_bool(ptr, value); + cases_T_unsigned(ptr, value); + cases_T_float(ptr, value); + case EcsOpEntity: + set_T(ecs_entity_t, ptr, value); + break; + default: + conversion_error(cursor, op, "uint"); + return -1; } - if (!desc || !desc->serialize_meta_ids) { - if (pred == EcsIsA || pred == EcsChildOf || - pred == ecs_id(EcsIdentifier)) - { - return true; - } -#ifdef FLECS_DOC - if (pred == ecs_id(EcsDocDescription)) { - return true; - } -#endif - } + return 0; +} - if (is_base) { - if (ecs_has_id(world, pred, EcsDontInherit)) { - return true; - } - } - if (!desc || !desc->serialize_private) { - if (ecs_has_id(world, pred, EcsPrivate)) { - return true; - } - } - if (is_base) { - if (ecs_get_object_for_id(world, inst, EcsIsA, id) != ent) { - hidden = true; - } - } - if (hidden && (!desc || !desc->serialize_hidden)) { - return true; - } +int ecs_meta_set_float( + ecs_meta_cursor_t *cursor, + double value) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - *pred_out = pred; - *obj_out = obj; - *role_out = role; - if (hidden_out) *hidden_out = hidden; + switch(op->kind) { + cases_T_bool(ptr, value); + cases_T_signed(ptr, value); + cases_T_unsigned(ptr, value); + cases_T_float(ptr, value); + default: + conversion_error(cursor, op, "float"); + return -1; + } - return false; + return 0; } static -int append_type_labels( - const ecs_world_t *world, - ecs_strbuf_t *buf, - const ecs_id_t *ids, - int32_t count, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +int add_bitmask_constant( + ecs_meta_cursor_t *cursor, + ecs_meta_type_op_t *op, + void *out, + const char *value) { - (void)world; (void)buf; (void)ids; (void)count; (void)ent; (void)inst; - (void)desc; - -#ifdef FLECS_DOC - if (!desc || !desc->serialize_id_labels) { + ecs_assert(op->type != 0, ECS_INTERNAL_ERROR, NULL); + + if (!ecs_os_strcmp(value, "0")) { return 0; } - json_member(buf, "id_labels"); - json_array_push(buf); - - int32_t i; - for (i = 0; i < count; i ++) { - ecs_entity_t pred = 0, obj = 0, role = 0; - if (skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) { - continue; - } - - if (desc && desc->serialize_id_labels) { - json_next(buf); - - json_array_push(buf); - json_next(buf); - json_label(buf, world, pred); - if (obj) { - json_next(buf); - json_label(buf, world, obj); - } + ecs_entity_t c = ecs_lookup_child(cursor->world, op->type, value); + if (!c) { + char *path = ecs_get_fullpath(cursor->world, op->type); + ecs_err("unresolved bitmask constant '%s' for type '%s'", value, path); + ecs_os_free(path); + return -1; + } - json_array_pop(buf); - } + const ecs_u32_t *v = ecs_get_pair_object( + cursor->world, c, EcsConstant, ecs_u32_t); + if (v == NULL) { + char *path = ecs_get_fullpath(cursor->world, op->type); + ecs_err("'%s' is not an bitmask constant for type '%s'", value, path); + ecs_os_free(path); + return -1; } - json_array_pop(buf); -#endif + *(ecs_u32_t*)out |= v[0]; + return 0; } static -int append_type_values( - const ecs_world_t *world, - ecs_strbuf_t *buf, - const ecs_id_t *ids, - int32_t count, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +int parse_bitmask( + ecs_meta_cursor_t *cursor, + ecs_meta_type_op_t *op, + void *out, + const char *value) { - if (!desc || !desc->serialize_values) { - return 0; - } + char token[ECS_MAX_TOKEN_SIZE]; - json_member(buf, "values"); - json_array_push(buf); + const char *prev = value, *ptr = value; - int32_t i; - for (i = 0; i < count; i ++) { - bool hidden; - ecs_entity_t pred = 0, obj = 0, role = 0; - ecs_id_t id = ids[i]; - if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, - &hidden)) - { - continue; + *(ecs_u32_t*)out = 0; + + while ((ptr = strchr(ptr, '|'))) { + ecs_os_memcpy(token, prev, ptr - prev); + token[ptr - prev] = '\0'; + if (add_bitmask_constant(cursor, op, out, token) != 0) { + return -1; } - if (!hidden) { - bool serialized = false; - ecs_entity_t typeid = ecs_get_typeid(world, id); - if (typeid) { - const EcsMetaTypeSerialized *ser = ecs_get( - world, typeid, EcsMetaTypeSerialized); - if (ser) { - const void *ptr = ecs_get_id(world, ent, id); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + ptr ++; + prev = ptr; + } - json_next(buf); - if (json_ser_type(world, ser->ops, ptr, buf) != 0) { - /* Entity contains invalid value */ - return -1; - } - serialized = true; - } - } - if (!serialized) { - json_next(buf); - json_number(buf, 0); - } - } else { - if (!desc || desc->serialize_hidden) { - json_next(buf); - json_number(buf, 0); - } - } + if (add_bitmask_constant(cursor, op, out, prev) != 0) { + return -1; } - json_array_pop(buf); - return 0; } -static -int append_type_info( - const ecs_world_t *world, - ecs_strbuf_t *buf, - const ecs_id_t *ids, - int32_t count, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +int ecs_meta_set_string( + ecs_meta_cursor_t *cursor, + const char *value) { - if (!desc || !desc->serialize_type_info) { - return 0; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + + switch(op->kind) { + case EcsOpBool: + if (!ecs_os_strcmp(value, "true")) { + set_T(ecs_bool_t, ptr, true); + } else if (!ecs_os_strcmp(value, "false")) { + set_T(ecs_bool_t, ptr, false); + } else { + ecs_err("invalid value for boolean '%s'", value); + return -1; + } + break; + case EcsOpI8: + case EcsOpU8: + case EcsOpChar: + case EcsOpByte: + set_T(ecs_i8_t, ptr, atol(value)); + break; + case EcsOpI16: + case EcsOpU16: + set_T(ecs_i16_t, ptr, atol(value)); + break; + case EcsOpI32: + case EcsOpU32: + set_T(ecs_i32_t, ptr, atol(value)); + break; + case EcsOpI64: + case EcsOpU64: + set_T(ecs_i64_t, ptr, atol(value)); + break; + case EcsOpIPtr: + case EcsOpUPtr: + set_T(ecs_iptr_t, ptr, atol(value)); + break; + case EcsOpF32: + set_T(ecs_f32_t, ptr, atof(value)); + break; + case EcsOpF64: + set_T(ecs_f64_t, ptr, atof(value)); + break; + case EcsOpString: { + ecs_os_free(*(char**)ptr); + char *result = ecs_os_strdup(value); + set_T(ecs_string_t, ptr, result); + break; } + case EcsOpEnum: { + ecs_assert(op->type != 0, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t c = ecs_lookup_child(cursor->world, op->type, value); + if (!c) { + char *path = ecs_get_fullpath(cursor->world, op->type); + ecs_err("unresolved enum constant '%s' for type '%s'", value, path); + ecs_os_free(path); + return -1; + } - json_member(buf, "type_info"); - json_array_push(buf); + const ecs_i32_t *v = ecs_get_pair_object( + cursor->world, c, EcsConstant, ecs_i32_t); + if (v == NULL) { + char *path = ecs_get_fullpath(cursor->world, op->type); + ecs_err("'%s' is not an enum constant for type '%s'", value, path); + ecs_os_free(path); + return -1; + } - int32_t i; - for (i = 0; i < count; i ++) { - bool hidden; - ecs_entity_t pred = 0, obj = 0, role = 0; - ecs_id_t id = ids[i]; - if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, - &hidden)) - { - continue; + set_T(ecs_i32_t, ptr, v[0]); + break; + } + case EcsOpBitmask: + if (parse_bitmask(cursor, op, ptr, value) != 0) { + return -1; } + break; + case EcsOpEntity: { + ecs_entity_t e = 0; - if (!hidden) { - ecs_entity_t typeid = ecs_get_typeid(world, id); - if (typeid) { - json_next(buf); - if (ecs_type_info_to_json_buf(world, typeid, buf) != 0) { - return -1; - } + if (ecs_os_strcmp(value, "0")) { + if (cursor->lookup_action) { + e = cursor->lookup_action( + cursor->world, value, + cursor->lookup_ctx); } else { - json_next(buf); - json_number(buf, 0); + e = ecs_lookup_path(cursor->world, 0, value); } - } else { - if (!desc || desc->serialize_hidden) { - json_next(buf); - json_number(buf, 0); + + if (!e) { + ecs_err("unresolved entity identifier '%s'", value); + return -1; } } + + set_T(ecs_entity_t, ptr, e); + break; + } + case EcsOpPop: + ecs_err("excess element '%s' in scope", value); + return -1; + default: + ecs_err("unsupported conversion from string '%s' to '%s'", + value, op_kind_str(op->kind)); + return -1; } - json_array_pop(buf); - return 0; } -static -int append_type_hidden( - const ecs_world_t *world, - ecs_strbuf_t *buf, - const ecs_id_t *ids, - int32_t count, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +int ecs_meta_set_string_literal( + ecs_meta_cursor_t *cursor, + const char *value) { - if (!desc || !desc->serialize_hidden) { - return 0; - } + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - if (ent == inst) { - return 0; /* if this is not a base, components are never hidden */ + ecs_size_t len = ecs_os_strlen(value); + if (value[0] != '\"' || value[len - 1] != '\"') { + ecs_err("invalid string literal '%s'", value); + return -1; } - json_member(buf, "hidden"); - json_array_push(buf); + switch(op->kind) { + case EcsOpChar: + set_T(ecs_char_t, ptr, value[1]); + break; + + default: + case EcsOpEntity: + case EcsOpString: + len -= 2; - int32_t i; - for (i = 0; i < count; i ++) { - bool hidden; - ecs_entity_t pred = 0, obj = 0, role = 0; - ecs_id_t id = ids[i]; - if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, - &hidden)) - { - continue; + char *result = ecs_os_malloc(len + 1); + ecs_os_memcpy(result, value + 1, len); + result[len] = '\0'; + + if (ecs_meta_set_string(cursor, result)) { + ecs_os_free(result); + return -1; } - json_next(buf); - json_bool(buf, hidden); + ecs_os_free(result); + + break; } - json_array_pop(buf); - return 0; } - -static -int append_type( - const ecs_world_t *world, - ecs_strbuf_t *buf, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +int ecs_meta_set_entity( + ecs_meta_cursor_t *cursor, + ecs_entity_t value) { - ecs_type_t type = ecs_get_type(world, ent); - const ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t i, count = ecs_vector_count(type); - - json_member(buf, "ids"); - json_array_push(buf); + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); - for (i = 0; i < count; i ++) { - ecs_entity_t pred = 0, obj = 0, role = 0; - if (skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) { - continue; - } + switch(op->kind) { + case EcsOpEntity: + set_T(ecs_entity_t, ptr, value); + break; + default: + conversion_error(cursor, op, "entity"); + return -1; + } + return 0; +} - json_next(buf); - json_array_push(buf); - json_next(buf); - json_path(buf, world, pred); - if (obj || role) { - json_next(buf); - if (obj) { - json_path(buf, world, obj); - } else { - json_number(buf, 0); - } - if (role) { - json_next(buf); - json_string(buf, ecs_role_str(role)); - } - } - json_array_pop(buf); +int ecs_meta_set_null( + ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch (op->kind) { + case EcsOpString: + ecs_os_free(*(char**)ptr); + set_T(ecs_string_t, ptr, NULL); + break; + default: + conversion_error(cursor, op, "null"); + return -1; } - json_array_pop(buf); + return 0; +} - if (append_type_labels(world, buf, ids, count, ent, inst, desc)) { - return -1; +bool ecs_meta_get_bool( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpBool: return *(ecs_bool_t*)ptr; + case EcsOpI8: return *(ecs_i8_t*)ptr != 0; + case EcsOpU8: return *(ecs_u8_t*)ptr != 0; + case EcsOpChar: return *(ecs_char_t*)ptr != 0; + case EcsOpByte: return *(ecs_u8_t*)ptr != 0; + case EcsOpI16: return *(ecs_i16_t*)ptr != 0; + case EcsOpU16: return *(ecs_u16_t*)ptr != 0; + case EcsOpI32: return *(ecs_i32_t*)ptr != 0; + case EcsOpU32: return *(ecs_u32_t*)ptr != 0; + case EcsOpI64: return *(ecs_i64_t*)ptr != 0; + case EcsOpU64: return *(ecs_u64_t*)ptr != 0; + case EcsOpIPtr: return *(ecs_iptr_t*)ptr != 0; + case EcsOpUPtr: return *(ecs_uptr_t*)ptr != 0; + case EcsOpF32: return *(ecs_f32_t*)ptr != 0; + case EcsOpF64: return *(ecs_f64_t*)ptr != 0; + case EcsOpString: return *(const char**)ptr != NULL; + case EcsOpEnum: return *(ecs_i32_t*)ptr != 0; + case EcsOpBitmask: return *(ecs_u32_t*)ptr != 0; + case EcsOpEntity: return *(ecs_entity_t*)ptr != 0; + default: ecs_throw(ECS_INVALID_PARAMETER, + "invalid element for bool"); } - - if (append_type_values(world, buf, ids, count, ent, inst, desc)) { - return -1; +error: + return 0; +} + +char ecs_meta_get_char( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpChar: return *(ecs_char_t*)ptr != 0; + default: ecs_throw(ECS_INVALID_PARAMETER, + "invalid element for char"); } +error: + return 0; +} - if (append_type_info(world, buf, ids, count, ent, inst, desc)) { - return -1; +int64_t ecs_meta_get_int( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpBool: return *(ecs_bool_t*)ptr; + case EcsOpI8: return *(ecs_i8_t*)ptr; + case EcsOpU8: return *(ecs_u8_t*)ptr; + case EcsOpChar: return *(ecs_char_t*)ptr; + case EcsOpByte: return *(ecs_u8_t*)ptr; + case EcsOpI16: return *(ecs_i16_t*)ptr; + case EcsOpU16: return *(ecs_u16_t*)ptr; + case EcsOpI32: return *(ecs_i32_t*)ptr; + case EcsOpU32: return *(ecs_u32_t*)ptr; + case EcsOpI64: return *(ecs_i64_t*)ptr; + case EcsOpU64: return flecs_uto(int64_t, *(ecs_u64_t*)ptr); + case EcsOpIPtr: return *(ecs_iptr_t*)ptr; + case EcsOpUPtr: return flecs_uto(int64_t, *(ecs_uptr_t*)ptr); + case EcsOpF32: return (int64_t)*(ecs_f32_t*)ptr; + case EcsOpF64: return (int64_t)*(ecs_f64_t*)ptr; + case EcsOpString: return atoi(*(const char**)ptr); + case EcsOpEnum: return *(ecs_i32_t*)ptr; + case EcsOpBitmask: return *(ecs_u32_t*)ptr; + case EcsOpEntity: + ecs_throw(ECS_INVALID_PARAMETER, + "invalid conversion from entity to int"); + break; + default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for int"); } +error: + return 0; +} - if (append_type_hidden(world, buf, ids, count, ent, inst, desc)) { - return -1; +uint64_t ecs_meta_get_uint( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpBool: return *(ecs_bool_t*)ptr; + case EcsOpI8: return flecs_ito(uint64_t, *(ecs_i8_t*)ptr); + case EcsOpU8: return *(ecs_u8_t*)ptr; + case EcsOpChar: return flecs_ito(uint64_t, *(ecs_char_t*)ptr); + case EcsOpByte: return flecs_ito(uint64_t, *(ecs_u8_t*)ptr); + case EcsOpI16: return flecs_ito(uint64_t, *(ecs_i16_t*)ptr); + case EcsOpU16: return *(ecs_u16_t*)ptr; + case EcsOpI32: return flecs_ito(uint64_t, *(ecs_i32_t*)ptr); + case EcsOpU32: return *(ecs_u32_t*)ptr; + case EcsOpI64: return flecs_ito(uint64_t, *(ecs_i64_t*)ptr); + case EcsOpU64: return *(ecs_u64_t*)ptr; + case EcsOpIPtr: return flecs_ito(uint64_t, *(ecs_i64_t*)ptr); + case EcsOpUPtr: return *(ecs_uptr_t*)ptr; + case EcsOpF32: return flecs_ito(uint64_t, *(ecs_f32_t*)ptr); + case EcsOpF64: return flecs_ito(uint64_t, *(ecs_f64_t*)ptr); + case EcsOpString: return flecs_ito(uint64_t, atoi(*(const char**)ptr)); + case EcsOpEnum: return flecs_ito(uint64_t, *(ecs_i32_t*)ptr); + case EcsOpBitmask: return *(ecs_u32_t*)ptr; + case EcsOpEntity: return *(ecs_entity_t*)ptr; + default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for uint"); + } +error: + return 0; +} + +double ecs_meta_get_float( + const ecs_meta_cursor_t *cursor) +{ + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpBool: return *(ecs_bool_t*)ptr; + case EcsOpI8: return *(ecs_i8_t*)ptr; + case EcsOpU8: return *(ecs_u8_t*)ptr; + case EcsOpChar: return *(ecs_char_t*)ptr; + case EcsOpByte: return *(ecs_u8_t*)ptr; + case EcsOpI16: return *(ecs_i16_t*)ptr; + case EcsOpU16: return *(ecs_u16_t*)ptr; + case EcsOpI32: return *(ecs_i32_t*)ptr; + case EcsOpU32: return *(ecs_u32_t*)ptr; + case EcsOpI64: return (double)*(ecs_i64_t*)ptr; + case EcsOpU64: return (double)*(ecs_u64_t*)ptr; + case EcsOpIPtr: return (double)*(ecs_iptr_t*)ptr; + case EcsOpUPtr: return (double)*(ecs_uptr_t*)ptr; + case EcsOpF32: return (double)*(ecs_f32_t*)ptr; + case EcsOpF64: return *(ecs_f64_t*)ptr; + case EcsOpString: return atof(*(const char**)ptr); + case EcsOpEnum: return *(ecs_i32_t*)ptr; + case EcsOpBitmask: return *(ecs_u32_t*)ptr; + case EcsOpEntity: + ecs_throw(ECS_INVALID_PARAMETER, + "invalid conversion from entity to float"); + break; + default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for float"); } - +error: return 0; } -static -int append_base( - const ecs_world_t *world, - ecs_strbuf_t *buf, - ecs_entity_t ent, - ecs_entity_t inst, - const ecs_entity_to_json_desc_t *desc) +const char* ecs_meta_get_string( + const ecs_meta_cursor_t *cursor) { - ecs_type_t type = ecs_get_type(world, ent); - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t i, count = ecs_vector_count(type); - - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; - if (ECS_HAS_RELATION(id, EcsIsA)) { - if (append_base(world, buf, ecs_pair_second(world, id), inst, desc)) - { - return -1; - } - } - } - - json_object_push(buf); - json_member(buf, "path"); - json_path(buf, world, ent); - - if (append_type(world, buf, ent, inst, desc)) { - return -1; + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpString: return *(const char**)ptr; + default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for string"); } - - json_object_pop(buf); - +error: return 0; } -int ecs_entity_to_json_buf( - const ecs_world_t *world, - ecs_entity_t entity, - ecs_strbuf_t *buf, - const ecs_entity_to_json_desc_t *desc) +ecs_entity_t ecs_meta_get_entity( + const ecs_meta_cursor_t *cursor) { - if (!entity || !ecs_is_valid(world, entity)) { - return -1; - } - - json_object_push(buf); - - if (!desc || desc->serialize_path) { - char *path = ecs_get_fullpath(world, entity); - json_member(buf, "path"); - json_string(buf, path); - ecs_os_free(path); - } - -#ifdef FLECS_DOC - if (desc && desc->serialize_label) { - json_member(buf, "label"); - const char *doc_name = ecs_doc_get_name(world, entity); - if (doc_name) { - json_string(buf, doc_name); - } else { - char num_buf[20]; - ecs_os_sprintf(num_buf, "%u", (uint32_t)entity); - json_string(buf, num_buf); - } - } - - if (desc && desc->serialize_brief) { - const char *doc_brief = ecs_doc_get_brief(world, entity); - if (doc_brief) { - json_member(buf, "brief"); - json_string(buf, doc_brief); - } + ecs_meta_scope_t *scope = get_scope(cursor); + ecs_meta_type_op_t *op = get_op(scope); + void *ptr = get_ptr(cursor->world, scope); + switch(op->kind) { + case EcsOpEntity: return *(ecs_entity_t*)ptr; + default: ecs_throw(ECS_INVALID_PARAMETER, "invalid element for entity"); } +error: + return 0; +} - if (desc && desc->serialize_link) { - const char *doc_link = ecs_doc_get_link(world, entity); - if (doc_link) { - json_member(buf, "link"); - json_string(buf, doc_link); - } - } #endif - ecs_type_t type = ecs_get_type(world, entity); - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t i, count = ecs_vector_count(type); - if (!desc || desc->serialize_base) { - if (ecs_has_pair(world, entity, EcsIsA, EcsWildcard)) { - json_member(buf, "is_a"); - json_array_push(buf); +#ifdef FLECS_META - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; - if (ECS_HAS_RELATION(id, EcsIsA)) { - if (append_base( - world, buf, ecs_pair_second(world, id), entity, desc)) - { - return -1; - } - } - } +static +ecs_vector_t* serialize_type( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops); - json_array_pop(buf); - } - } +static +ecs_meta_type_op_kind_t primitive_to_op_kind(ecs_primitive_kind_t kind) { + return EcsOpPrimitive + kind; +} - if (append_type(world, buf, entity, entity, desc)) { - goto error; - } +static +ecs_size_t type_size(ecs_world_t *world, ecs_entity_t type) { + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + return comp->size; +} - json_object_pop(buf); +static +ecs_meta_type_op_t* ops_add(ecs_vector_t **ops, ecs_meta_type_op_kind_t kind) { + ecs_meta_type_op_t *op = ecs_vector_add(ops, ecs_meta_type_op_t); + op->kind = kind; + op->offset = 0; + op->count = 1; + op->op_count = 1; + op->size = 0; + op->name = NULL; + op->members = NULL; + op->type = 0; + op->unit = 0; + return op; +} - return 0; -error: - return -1; +static +ecs_meta_type_op_t* ops_get(ecs_vector_t *ops, int32_t index) { + ecs_meta_type_op_t* op = ecs_vector_get(ops, ecs_meta_type_op_t, index); + ecs_assert(op != NULL, ECS_INTERNAL_ERROR, NULL); + return op; } -char* ecs_entity_to_json( - const ecs_world_t *world, - ecs_entity_t entity, - const ecs_entity_to_json_desc_t *desc) +static +ecs_vector_t* serialize_primitive( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - ecs_strbuf_t buf = ECS_STRBUF_INIT; + const EcsPrimitive *ptr = ecs_get(world, type, EcsPrimitive); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - if (ecs_entity_to_json_buf(world, entity, &buf, desc) != 0) { - ecs_strbuf_reset(&buf); - return NULL; - } + ecs_meta_type_op_t *op = ops_add(&ops, primitive_to_op_kind(ptr->kind)); + op->offset = offset, + op->type = type; + op->size = type_size(world, type); - return ecs_strbuf_get(&buf); + return ops; } static -bool skip_variable( - const char *name) +ecs_vector_t* serialize_enum( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - if (!name || name[0] == '_' || name[0] == '.') { - return true; - } else { - return false; - } + (void)world; + + ecs_meta_type_op_t *op = ops_add(&ops, EcsOpEnum); + op->offset = offset, + op->type = type; + op->size = ECS_SIZEOF(ecs_i32_t); + + return ops; } static -void serialize_id( - const ecs_world_t *world, - ecs_id_t id, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_bitmask( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - json_id(buf, world, id); + (void)world; + + ecs_meta_type_op_t *op = ops_add(&ops, EcsOpBitmask); + op->offset = offset, + op->type = type; + op->size = ECS_SIZEOF(ecs_u32_t); + + return ops; } static -void serialize_iter_ids( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_array( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - int32_t term_count = it->term_count; - if (!term_count) { - return; - } - - json_member(buf, "ids"); - json_array_push(buf); + (void)world; - for (int i = 0; i < term_count; i ++) { - json_next(buf); - serialize_id(world, it->terms[i].id, buf); - } + ecs_meta_type_op_t *op = ops_add(&ops, EcsOpArray); + op->offset = offset; + op->type = type; + op->size = type_size(world, type); - json_array_pop(buf); + return ops; } static -void serialize_type_info( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_array_component( + ecs_world_t *world, + ecs_entity_t type) { - int32_t term_count = it->term_count; - if (!term_count) { - return; + const EcsArray *ptr = ecs_get(world, type, EcsArray); + if (!ptr) { + return NULL; /* Should never happen, will trigger internal error */ } - json_member(buf, "type_info"); - json_object_push(buf); + ecs_vector_t *ops = serialize_type(world, ptr->type, 0, NULL); + ecs_assert(ops != NULL, ECS_INTERNAL_ERROR, NULL); - for (int i = 0; i < term_count; i ++) { - json_next(buf); - ecs_entity_t typeid = ecs_get_typeid(world, it->terms[i].id); - if (typeid) { - serialize_id(world, typeid, buf); - ecs_strbuf_appendstr(buf, ":"); - ecs_type_info_to_json_buf(world, typeid, buf); - } else { - serialize_id(world, it->terms[i].id, buf); - ecs_strbuf_appendstr(buf, ":"); - ecs_strbuf_appendstr(buf, "0"); - } - } + ecs_meta_type_op_t *first = ecs_vector_first(ops, ecs_meta_type_op_t); + first->count = ptr->count; - json_object_pop(buf); + return ops; } static -void serialize_iter_variables(ecs_iter_t *it, ecs_strbuf_t *buf) { - char **variable_names = it->variable_names; - int32_t var_count = it->variable_count; - int32_t actual_count = 0; - - for (int i = 0; i < var_count; i ++) { - const char *var_name = variable_names[i]; - if (skip_variable(var_name)) continue; - - if (!actual_count) { - json_member(buf, "vars"); - json_array_push(buf); - actual_count ++; - } +ecs_vector_t* serialize_vector( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) +{ + (void)world; - ecs_strbuf_list_next(buf); - json_string(buf, var_name); - } + ecs_meta_type_op_t *op = ops_add(&ops, EcsOpVector); + op->offset = offset; + op->type = type; + op->size = type_size(world, type); - if (actual_count) { - json_array_pop(buf); - } + return ops; } static -void serialize_iter_result_ids( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_struct( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - json_member(buf, "ids"); - json_array_push(buf); + const EcsStruct *ptr = ecs_get(world, type, EcsStruct); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - for (int i = 0; i < it->term_count; i ++) { - json_next(buf); - serialize_id(world, ecs_term_id(it, i + 1), buf); + int32_t cur, first = ecs_vector_count(ops); + ecs_meta_type_op_t *op = ops_add(&ops, EcsOpPush); + op->offset = offset; + op->type = type; + op->size = type_size(world, type); + + ecs_member_t *members = ecs_vector_first(ptr->members, ecs_member_t); + int32_t i, count = ecs_vector_count(ptr->members); + + ecs_hashmap_t *member_index = NULL; + if (count) { + op->members = member_index = flecs_name_index_new(); } - json_array_pop(buf); -} + for (i = 0; i < count; i ++) { + ecs_member_t *member = &members[i]; -static -void serialize_iter_result_subjects( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) -{ - json_member(buf, "subjects"); - json_array_push(buf); + cur = ecs_vector_count(ops); + ops = serialize_type(world, member->type, offset + member->offset, ops); - for (int i = 0; i < it->term_count; i ++) { - json_next(buf); - ecs_entity_t subj = it->subjects[i]; - if (subj) { - json_path(buf, world, subj); - } else { - json_literal(buf, "0"); + op = ops_get(ops, cur); + if (!op->type) { + op->type = member->type; } - } - json_array_pop(buf); -} + if (op->count <= 1) { + op->count = member->count; + } -static -void serialize_iter_result_is_set( - const ecs_iter_t *it, - ecs_strbuf_t *buf) -{ - json_member(buf, "is_set"); - json_array_push(buf); + const char *member_name = member->name; + op->name = member_name; + op->unit = member->unit; + op->op_count = ecs_vector_count(ops) - cur; - for (int i = 0; i < it->term_count; i ++) { - ecs_strbuf_list_next(buf); - if (ecs_term_is_set(it, i + 1)) { - json_true(buf); - } else { - json_false(buf); - } + flecs_name_index_ensure( + member_index, flecs_ito(uint64_t, cur - first - 1), + member_name, 0, 0); } - json_array_pop(buf); + ops_add(&ops, EcsOpPop); + ops_get(ops, first)->op_count = ecs_vector_count(ops) - first; + + return ops; } static -void serialize_iter_result_variables( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_type( + ecs_world_t *world, + ecs_entity_t type, + ecs_size_t offset, + ecs_vector_t *ops) { - char **variable_names = it->variable_names; - ecs_entity_t *variables = it->variables; - int32_t var_count = it->variable_count; - int32_t actual_count = 0; - - for (int i = 0; i < var_count; i ++) { - const char *var_name = variable_names[i]; - if (skip_variable(var_name)) continue; - - if (!actual_count) { - json_member(buf, "vars"); - json_array_push(buf); - actual_count ++; - } - - ecs_strbuf_list_next(buf); - json_path(buf, world, variables[i]); + const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType); + if (!ptr) { + char *path = ecs_get_fullpath(world, type); + ecs_err("missing EcsMetaType for type %s'", path); + ecs_os_free(path); + return NULL; } - if (actual_count) { - json_array_pop(buf); - } -} + switch(ptr->kind) { + case EcsPrimitiveType: + ops = serialize_primitive(world, type, offset, ops); + break; -static -void serialize_iter_result_variable_labels( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) -{ - char **variable_names = it->variable_names; - ecs_entity_t *variables = it->variables; - int32_t var_count = it->variable_count; - int32_t actual_count = 0; + case EcsEnumType: + ops = serialize_enum(world, type, offset, ops); + break; - for (int i = 0; i < var_count; i ++) { - const char *var_name = variable_names[i]; - if (skip_variable(var_name)) continue; + case EcsBitmaskType: + ops = serialize_bitmask(world, type, offset, ops); + break; - if (!actual_count) { - json_member(buf, "var_labels"); - json_array_push(buf); - actual_count ++; - } + case EcsStructType: + ops = serialize_struct(world, type, offset, ops); + break; - ecs_strbuf_list_next(buf); - json_label(buf, world, variables[i]); - } + case EcsArrayType: + ops = serialize_array(world, type, offset, ops); + break; - if (actual_count) { - json_array_pop(buf); + case EcsVectorType: + ops = serialize_vector(world, type, offset, ops); + break; } + + return ops; } static -void serialize_iter_result_entities( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +ecs_vector_t* serialize_component( + ecs_world_t *world, + ecs_entity_t type) { - int32_t count = it->count; - if (!it->count) { - return; + const EcsMetaType *ptr = ecs_get(world, type, EcsMetaType); + if (!ptr) { + char *path = ecs_get_fullpath(world, type); + ecs_err("missing EcsMetaType for type %s'", path); + ecs_os_free(path); + return NULL; } - json_member(buf, "entities"); - json_array_push(buf); - - ecs_entity_t *entities = it->entities; + ecs_vector_t *ops = NULL; - for (int i = 0; i < count; i ++) { - json_next(buf); - json_path(buf, world, entities[i]); + switch(ptr->kind) { + case EcsArrayType: + ops = serialize_array_component(world, type); + break; + default: + ops = serialize_type(world, type, 0, NULL); + break; } - json_array_pop(buf); + return ops; } -static -void serialize_iter_result_entity_labels( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) +void ecs_meta_type_serialized_init( + ecs_iter_t *it) { - int32_t count = it->count; - if (!it->count) { - return; - } + ecs_world_t *world = it->world; - json_member(buf, "entity_labels"); - json_array_push(buf); + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_vector_t *ops = serialize_component(world, e); + ecs_assert(ops != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t *entities = it->entities; + EcsMetaTypeSerialized *ptr = ecs_get_mut( + world, e, EcsMetaTypeSerialized, NULL); + if (ptr->ops) { + ecs_meta_dtor_serialized(ptr); + } - for (int i = 0; i < count; i ++) { - json_next(buf); - json_label(buf, world, entities[i]); + ptr->ops = ops; } - - json_array_pop(buf); } -static -void serialize_iter_result_values( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf) -{ - int32_t count = it->count; - if (!it->count) { - return; - } - - json_member(buf, "values"); - json_array_push(buf); +#endif - int32_t i, term_count = it->term_count; - for (i = 0; i < term_count; i ++) { - ecs_strbuf_list_next(buf); - const void *ptr = NULL; - if (it->ptrs) { - ptr = it->ptrs[i]; - } - if (!ptr) { - /* No data in column. Append 0 if this is not an optional term */ - if (ecs_term_is_set(it, i + 1)) { - json_literal(buf, "0"); - continue; - } - } +#ifdef FLECS_META - if (ecs_term_is_writeonly(it, i + 1)) { - json_literal(buf, "0"); - continue; - } +/* EcsMetaTypeSerialized lifecycle */ - /* Get component id (can be different in case of pairs) */ - ecs_entity_t type = ecs_get_typeid(world, it->ids[i]); - if (!type) { - /* Odd, we have a ptr but no Component? Not the place of the - * serializer to complain about that. */ - json_literal(buf, "0"); - continue; +void ecs_meta_dtor_serialized( + EcsMetaTypeSerialized *ptr) +{ + int32_t i, count = ecs_vector_count(ptr->ops); + ecs_meta_type_op_t *ops = ecs_vector_first(ptr->ops, ecs_meta_type_op_t); + + for (i = 0; i < count; i ++) { + ecs_meta_type_op_t *op = &ops[i]; + if (op->members) { + flecs_hashmap_fini(op->members); + ecs_os_free(op->members); } + } - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - if (!comp) { - /* Also odd, typeid but not a component? */ - json_literal(buf, "0"); - continue; - } + ecs_vector_free(ptr->ops); +} - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - if (!ser) { - /* Not odd, component just has no reflection data */ - json_literal(buf, "0"); - continue; - } +static ECS_COPY(EcsMetaTypeSerialized, dst, src, { + ecs_meta_dtor_serialized(dst); - /* If term is not set, append empty array. This indicates that the term - * could have had data but doesn't */ - if (!ecs_term_is_set(it, i + 1)) { - ecs_assert(ptr == NULL, ECS_INTERNAL_ERROR, NULL); - json_array_push(buf); - json_array_pop(buf); - continue; - } + dst->ops = ecs_vector_copy(src->ops, ecs_meta_type_op_t); - if (ecs_term_is_owned(it, i + 1)) { - array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser); - } else { - array_to_json_buf_w_type_data(world, ptr, 0, buf, comp, ser); + int32_t o, count = ecs_vector_count(src->ops); + ecs_meta_type_op_t *ops = ecs_vector_first(src->ops, ecs_meta_type_op_t); + + for (o = 0; o < count; o ++) { + ecs_meta_type_op_t *op = &ops[o]; + if (op->members) { + op->members = ecs_os_memdup_t(op->members, ecs_hashmap_t); + flecs_hashmap_copy(op->members, op->members); } } +}) - json_array_pop(buf); -} +static ECS_MOVE(EcsMetaTypeSerialized, dst, src, { + ecs_meta_dtor_serialized(dst); + dst->ops = src->ops; + src->ops = NULL; +}) -static -void serialize_iter_result( - const ecs_world_t *world, - const ecs_iter_t *it, - ecs_strbuf_t *buf, - const ecs_iter_to_json_desc_t *desc) -{ - json_next(buf); - json_object_push(buf); +static ECS_DTOR(EcsMetaTypeSerialized, ptr, { + ecs_meta_dtor_serialized(ptr); +}) - /* Each result can be matched with different component ids. Add them to - * the result so clients know with which component an entity was matched */ - if (!desc || desc->serialize_ids) { - serialize_iter_result_ids(world, it, buf); - } - /* Include information on which entity the term is matched with */ - if (!desc || desc->serialize_ids) { - serialize_iter_result_subjects(world, it, buf); - } +/* EcsStruct lifecycle */ - /* Write variable values for current result */ - if (!desc || desc->serialize_variables) { - serialize_iter_result_variables(world, it, buf); +static void dtor_struct( + EcsStruct *ptr) +{ + ecs_member_t *members = ecs_vector_first(ptr->members, ecs_member_t); + int32_t i, count = ecs_vector_count(ptr->members); + for (i = 0; i < count; i ++) { + ecs_os_free((char*)members[i].name); } + ecs_vector_free(ptr->members); +} - /* Write labels for variables */ - if (desc && desc->serialize_variable_labels) { - serialize_iter_result_variable_labels(world, it, buf); - } +static ECS_COPY(EcsStruct, dst, src, { + dtor_struct(dst); - /* Include information on which terms are set, to support optional terms */ - if (!desc || desc->serialize_is_set) { - serialize_iter_result_is_set(it, buf); - } + dst->members = ecs_vector_copy(src->members, ecs_member_t); - /* Write entity ids for current result (for queries with This terms) */ - if (!desc || desc->serialize_entities) { - serialize_iter_result_entities(world, it, buf); - } + ecs_member_t *members = ecs_vector_first(dst->members, ecs_member_t); + int32_t m, count = ecs_vector_count(dst->members); - /* Write labels for entities */ - if (desc && desc->serialize_entity_labels) { - serialize_iter_result_entity_labels(world, it, buf); + for (m = 0; m < count; m ++) { + members[m].name = ecs_os_strdup(members[m].name); } +}) - /* Serialize component values */ - if (!desc || desc->serialize_values) { - serialize_iter_result_values(world, it, buf); - } +static ECS_MOVE(EcsStruct, dst, src, { + dtor_struct(dst); + dst->members = src->members; + src->members = NULL; +}) - json_object_pop(buf); -} +static ECS_DTOR(EcsStruct, ptr, { dtor_struct(ptr); }) -int ecs_iter_to_json_buf( - const ecs_world_t *world, - ecs_iter_t *it, - ecs_strbuf_t *buf, - const ecs_iter_to_json_desc_t *desc) + +/* EcsEnum lifecycle */ + +static void dtor_enum( + EcsEnum *ptr) { - ecs_time_t duration = {0}; - if (desc && desc->measure_eval_duration) { - ecs_time_measure(&duration); + ecs_map_iter_t it = ecs_map_iter(ptr->constants); + ecs_enum_constant_t *c; + while ((c = ecs_map_next(&it, ecs_enum_constant_t, NULL))) { + ecs_os_free((char*)c->name); } + ecs_map_free(ptr->constants); +} - json_object_push(buf); +static ECS_COPY(EcsEnum, dst, src, { + dtor_enum(dst); - /* Serialize component ids of the terms (usually provided by query) */ - if (!desc || desc->serialize_term_ids) { - serialize_iter_ids(world, it, buf); - } + dst->constants = ecs_map_copy(src->constants); + ecs_assert(ecs_map_count(dst->constants) == ecs_map_count(src->constants), + ECS_INTERNAL_ERROR, NULL); - /* Serialize type info if enabled */ - if (desc && desc->serialize_type_info) { - serialize_type_info(world, it, buf); + ecs_map_iter_t it = ecs_map_iter(dst->constants); + ecs_enum_constant_t *c; + while ((c = ecs_map_next(&it, ecs_enum_constant_t, NULL))) { + c->name = ecs_os_strdup(c->name); } +}) - /* Serialize variable names, if iterator has any */ - serialize_iter_variables(it, buf); +static ECS_MOVE(EcsEnum, dst, src, { + dtor_enum(dst); + dst->constants = src->constants; + src->constants = NULL; +}) - /* Serialize results */ - json_member(buf, "results"); - json_array_push(buf); +static ECS_DTOR(EcsEnum, ptr, { dtor_enum(ptr); }) - /* Use instancing for improved performance */ - it->is_instanced = true; - ecs_iter_next_action_t next = it->next; - while (next(it)) { - serialize_iter_result(world, it, buf, desc); +/* EcsBitmask lifecycle */ + +static void dtor_bitmask( + EcsBitmask *ptr) +{ + ecs_map_iter_t it = ecs_map_iter(ptr->constants); + ecs_bitmask_constant_t *c; + while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, NULL))) { + ecs_os_free((char*)c->name); } + ecs_map_free(ptr->constants); +} - json_array_pop(buf); +static ECS_COPY(EcsBitmask, dst, src, { + dtor_bitmask(dst); - if (desc && desc->measure_eval_duration) { - double dt = ecs_time_measure(&duration); - json_member(buf, "eval_duration"); - json_number(buf, dt); + dst->constants = ecs_map_copy(src->constants); + ecs_assert(ecs_map_count(dst->constants) == ecs_map_count(src->constants), + ECS_INTERNAL_ERROR, NULL); + + ecs_map_iter_t it = ecs_map_iter(dst->constants); + ecs_bitmask_constant_t *c; + while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, NULL))) { + c->name = ecs_os_strdup(c->name); } +}) - json_object_pop(buf); +static ECS_MOVE(EcsBitmask, dst, src, { + dtor_bitmask(dst); + dst->constants = src->constants; + src->constants = NULL; +}) - return 0; -} +static ECS_DTOR(EcsBitmask, ptr, { dtor_bitmask(ptr); }) -char* ecs_iter_to_json( - const ecs_world_t *world, - ecs_iter_t *it, - const ecs_iter_to_json_desc_t *desc) -{ - ecs_strbuf_t buf = ECS_STRBUF_INIT; - if (ecs_iter_to_json_buf(world, it, &buf, desc)) { - ecs_strbuf_reset(&buf); - return NULL; - } +/* EcsUnit lifecycle */ - return ecs_strbuf_get(&buf); +static void dtor_unit( + EcsUnit *ptr) +{ + ecs_os_free(ptr->symbol); } -#endif +static ECS_COPY(EcsUnit, dst, src, { + dtor_unit(dst); + dst->symbol = ecs_os_strdup(src->symbol); + dst->base = src->base; + dst->over = src->over; + dst->prefix = src->prefix; + dst->translation = src->translation; +}) +static ECS_MOVE(EcsUnit, dst, src, { + dtor_unit(dst); + dst->symbol = src->symbol; + dst->base = src->base; + dst->over = src->over; + dst->prefix = src->prefix; + dst->translation = src->translation; -#ifdef FLECS_JSON + src->symbol = NULL; + src->base = 0; + src->over = 0; + src->prefix = 0; + src->translation = (ecs_unit_translation_t){0}; +}) -static -int json_typeinfo_ser_type( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *buf); +static ECS_DTOR(EcsUnit, ptr, { dtor_unit(ptr); }) -static -int json_typeinfo_ser_primitive( - ecs_primitive_kind_t kind, - ecs_strbuf_t *str) -{ - switch(kind) { - case EcsBool: - json_string(str, "bool"); - break; - case EcsChar: - case EcsString: - json_string(str, "text"); - break; - case EcsByte: - json_string(str, "byte"); - break; - case EcsU8: - case EcsU16: - case EcsU32: - case EcsU64: - case EcsI8: - case EcsI16: - case EcsI32: - case EcsI64: - case EcsIPtr: - case EcsUPtr: - json_string(str, "int"); - break; - case EcsF32: - case EcsF64: - json_string(str, "float"); - break; - case EcsEntity: - json_string(str, "entity"); - break; - default: - return -1; - } - return 0; -} +/* EcsUnitPrefix lifecycle */ -static -void json_typeinfo_ser_constants( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *str) +static void dtor_unit_prefix( + EcsUnitPrefix *ptr) { - ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) { - .id = ecs_pair(EcsChildOf, type) - }); - - while (ecs_term_next(&it)) { - int32_t i, count = it.count; - for (i = 0; i < count; i ++) { - json_next(str); - json_string(str, ecs_get_name(world, it.entities[i])); - } - } + ecs_os_free(ptr->symbol); } -static -void json_typeinfo_ser_enum( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *str) -{ - ecs_strbuf_list_appendstr(str, "\"enum\""); - json_typeinfo_ser_constants(world, type, str); -} +static ECS_COPY(EcsUnitPrefix, dst, src, { + dtor_unit_prefix(dst); + dst->symbol = ecs_os_strdup(src->symbol); + dst->translation = src->translation; +}) -static -void json_typeinfo_ser_bitmask( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *str) -{ - ecs_strbuf_list_appendstr(str, "\"bitmask\""); - json_typeinfo_ser_constants(world, type, str); -} +static ECS_MOVE(EcsUnitPrefix, dst, src, { + dtor_unit_prefix(dst); + dst->symbol = src->symbol; + dst->translation = src->translation; -static -int json_typeinfo_ser_array( - const ecs_world_t *world, - ecs_entity_t elem_type, - int32_t count, - ecs_strbuf_t *str) -{ - ecs_strbuf_list_appendstr(str, "\"array\""); + src->symbol = NULL; + src->translation = (ecs_unit_translation_t){0}; +}) - json_next(str); - if (json_typeinfo_ser_type(world, elem_type, str)) { - goto error; - } +static ECS_DTOR(EcsUnitPrefix, ptr, { dtor_unit_prefix(ptr); }) - ecs_strbuf_list_append(str, "%u", count); - return 0; -error: - return -1; -} + +/* Type initialization */ static -int json_typeinfo_ser_array_type( - const ecs_world_t *world, +int init_type( + ecs_world_t *world, ecs_entity_t type, - ecs_strbuf_t *str) + ecs_type_kind_t kind, + ecs_size_t size, + ecs_size_t alignment) { - const EcsArray *arr = ecs_get(world, type, EcsArray); - ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL); - if (json_typeinfo_ser_array(world, arr->type, arr->count, str)) { - goto error; + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL); + + bool is_added = false; + EcsMetaType *meta_type = ecs_get_mut(world, type, EcsMetaType, &is_added); + if (is_added) { + meta_type->existing = ecs_has(world, type, EcsComponent); + + /* Ensure that component has a default constructor, to prevent crashing + * serializers on uninitialized values. */ + ecs_type_info_t *ti = flecs_ensure_type_info(world, type); + if (!ti->lifecycle.ctor) { + ti->lifecycle.ctor = ecs_default_ctor; + } + } else { + if (meta_type->kind != kind) { + ecs_err("type '%s' reregistered with different kind", + ecs_get_name(world, type)); + return -1; + } + } + + if (!meta_type->existing) { + EcsComponent *comp = ecs_get_mut(world, type, EcsComponent, NULL); + comp->size = size; + comp->alignment = alignment; + ecs_modified(world, type, EcsComponent); + } else { + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + if (comp->size < size) { + ecs_err("computed size for '%s' is larger than actual type", + ecs_get_name(world, type)); + return -1; + } + if (comp->alignment < alignment) { + ecs_err("computed alignment for '%s' is larger than actual type", + ecs_get_name(world, type)); + return -1; + } + if (comp->size == size && comp->alignment != alignment) { + ecs_err("computed size for '%s' matches with actual type but " + "alignment is different", ecs_get_name(world, type)); + return -1; + } + + meta_type->partial = comp->size != size; } + meta_type->kind = kind; + meta_type->size = size; + meta_type->alignment = alignment; + ecs_modified(world, type, EcsMetaType); + return 0; -error: - return -1; } +#define init_type_t(world, type, kind, T) \ + init_type(world, type, kind, ECS_SIZEOF(T), ECS_ALIGNOF(T)) + static -int json_typeinfo_ser_vector( - const ecs_world_t *world, +void set_struct_member( + ecs_member_t *member, + ecs_entity_t entity, + const char *name, ecs_entity_t type, - ecs_strbuf_t *str) + int32_t count, + ecs_entity_t unit) { - const EcsVector *arr = ecs_get(world, type, EcsVector); - ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_strbuf_list_appendstr(str, "\"vector\""); + member->member = entity; + member->type = type; + member->count = count; + member->unit = unit; - json_next(str); - if (json_typeinfo_ser_type(world, arr->type, str)) { - goto error; + if (!count) { + member->count = 1; } - return 0; -error: - return -1; + ecs_os_strset((char**)&member->name, name); } -/* Serialize unit information */ static -int json_typeinfo_ser_unit( - const ecs_world_t *world, - ecs_strbuf_t *str, - ecs_entity_t unit) +int add_member_to_struct( + ecs_world_t *world, + ecs_entity_t type, + ecs_entity_t member, + EcsMember *m) { - json_member(str, "unit"); - json_path(str, world, unit); + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(type != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(member != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL); - const EcsUnit *uptr = ecs_get(world, unit, EcsUnit); - if (uptr) { - if (uptr->symbol) { - json_member(str, "symbol"); - json_string(str, uptr->symbol); - } - ecs_entity_t quantity = ecs_get_object(world, unit, EcsQuantity, 0); - if (quantity) { - json_member(str, "quantity"); - json_path(str, world, quantity); - } + const char *name = ecs_get_name(world, member); + if (!name) { + char *path = ecs_get_fullpath(world, type); + ecs_err("member for struct '%s' does not have a name", path); + ecs_os_free(path); + return -1; } - return 0; -} + if (!m->type) { + char *path = ecs_get_fullpath(world, member); + ecs_err("member '%s' does not have a type", path); + ecs_os_free(path); + return -1; + } -/* Forward serialization to the different type kinds */ -static -int json_typeinfo_ser_type_op( - const ecs_world_t *world, - ecs_meta_type_op_t *op, - ecs_strbuf_t *str) -{ - json_array_push(str); + if (ecs_get_typeid(world, m->type) == 0) { + char *path = ecs_get_fullpath(world, member); + char *ent_path = ecs_get_fullpath(world, m->type); + ecs_err("member '%s.type' is '%s' which is not a type", path, ent_path); + ecs_os_free(path); + ecs_os_free(ent_path); + return -1; + } - switch(op->kind) { - case EcsOpPush: - case EcsOpPop: - /* Should not be parsed as single op */ - ecs_throw(ECS_INVALID_PARAMETER, NULL); - break; - case EcsOpEnum: - json_typeinfo_ser_enum(world, op->type, str); - break; - case EcsOpBitmask: - json_typeinfo_ser_bitmask(world, op->type, str); - break; - case EcsOpArray: - json_typeinfo_ser_array_type(world, op->type, str); - break; - case EcsOpVector: - json_typeinfo_ser_vector(world, op->type, str); - break; - default: - if (json_typeinfo_ser_primitive( - json_op_to_primitive_kind(op->kind), str)) - { - /* Unknown operation */ - ecs_throw(ECS_INTERNAL_ERROR, NULL); + ecs_entity_t unit = m->unit; + + if (unit) { + if (!ecs_has(world, unit, EcsUnit)) { + ecs_err("entity '%s' for member '%s' is not a unit", + ecs_get_name(world, unit), name); return -1; } - break; + + if (ecs_has(world, m->type, EcsUnit) && m->type != unit) { + ecs_err("unit mismatch for type '%s' and unit '%s' for member '%s'", + ecs_get_name(world, m->type), ecs_get_name(world, unit), name); + return -1; + } + } else { + if (ecs_has(world, m->type, EcsUnit)) { + unit = m->type; + m->unit = unit; + } } - ecs_entity_t unit = op->unit; - if (unit) { - json_next(str); - json_next(str); + EcsStruct *s = ecs_get_mut(world, type, EcsStruct, NULL); + ecs_assert(s != NULL, ECS_INTERNAL_ERROR, NULL); - json_object_push(str); - json_typeinfo_ser_unit(world, str, unit); - json_object_pop(str); + /* First check if member is already added to struct */ + ecs_member_t *members = ecs_vector_first(s->members, ecs_member_t); + int32_t i, count = ecs_vector_count(s->members); + for (i = 0; i < count; i ++) { + if (members[i].member == member) { + set_struct_member( + &members[i], member, name, m->type, m->count, unit); + break; + } } - json_array_pop(str); + /* If member wasn't added yet, add a new element to vector */ + if (i == count) { + ecs_member_t *elem = ecs_vector_add(&s->members, ecs_member_t); + elem->name = NULL; + set_struct_member(elem, member, name, m->type, m->count, unit); - return 0; -error: - return -1; -} + /* Reobtain members array in case it was reallocated */ + members = ecs_vector_first(s->members, ecs_member_t); + count ++; + } -/* Iterate over a slice of the type ops array */ -static -int json_typeinfo_ser_type_ops( - const ecs_world_t *world, - ecs_meta_type_op_t *ops, - int32_t op_count, - ecs_strbuf_t *str) -{ - for (int i = 0; i < op_count; i ++) { - ecs_meta_type_op_t *op = &ops[i]; + /* Compute member offsets and size & alignment of struct */ + ecs_size_t size = 0; + ecs_size_t alignment = 0; - if (op != ops) { - if (op->name) { - json_member(str, op->name); - } + for (i = 0; i < count; i ++) { + ecs_member_t *elem = &members[i]; - int32_t elem_count = op->count; - if (elem_count > 1 && op != ops) { - json_array_push(str); - json_typeinfo_ser_array(world, op->type, op->count, str); - json_array_pop(str); - i += op->op_count - 1; - continue; - } + ecs_assert(elem->name != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(elem->type != 0, ECS_INTERNAL_ERROR, NULL); + + /* Get component of member type to get its size & alignment */ + const EcsComponent *mbr_comp = ecs_get(world, elem->type, EcsComponent); + if (!mbr_comp) { + char *path = ecs_get_fullpath(world, member); + ecs_err("member '%s' is not a type", path); + ecs_os_free(path); + return -1; } - - switch(op->kind) { - case EcsOpPush: - json_object_push(str); - break; - case EcsOpPop: - json_object_pop(str); - break; - default: - if (json_typeinfo_ser_type_op(world, op, str)) { - goto error; - } - break; + + ecs_size_t member_size = mbr_comp->size; + ecs_size_t member_alignment = mbr_comp->alignment; + + if (!member_size || !member_alignment) { + char *path = ecs_get_fullpath(world, member); + ecs_err("member '%s' has 0 size/alignment"); + ecs_os_free(path); + return -1; + } + + member_size *= elem->count; + size = ECS_ALIGN(size, member_alignment); + elem->size = member_size; + elem->offset = size; + + size += member_size; + + if (member_alignment > alignment) { + alignment = member_alignment; } } - return 0; -error: - return -1; -} + if (size == 0) { + ecs_err("struct '%s' has 0 size", ecs_get_name(world, type)); + return -1; + } -static -int json_typeinfo_ser_type( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *buf) -{ - const EcsComponent *comp = ecs_get(world, type, EcsComponent); - if (!comp) { - ecs_strbuf_appendstr(buf, "0"); - return 0; + if (alignment == 0) { + ecs_err("struct '%s' has 0 alignment", ecs_get_name(world, type)); + return -1; } - const EcsMetaTypeSerialized *ser = ecs_get( - world, type, EcsMetaTypeSerialized); - if (!ser) { - ecs_strbuf_appendstr(buf, "0"); - return 0; + /* Align struct size to struct alignment */ + size = ECS_ALIGN(size, alignment); + + ecs_modified(world, type, EcsStruct); + + /* Do this last as it triggers the update of EcsMetaTypeSerialized */ + if (init_type(world, type, EcsStructType, size, alignment)) { + return -1; } - ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); - int32_t count = ecs_vector_count(ser->ops); + /* If current struct is also a member, assign to itself */ + if (ecs_has(world, type, EcsMember)) { + EcsMember *type_mbr = ecs_get_mut(world, type, EcsMember, NULL); + ecs_assert(type_mbr != NULL, ECS_INTERNAL_ERROR, NULL); - return json_typeinfo_ser_type_ops(world, ops, count, buf); -} + type_mbr->type = type; + type_mbr->count = 1; -int ecs_type_info_to_json_buf( - const ecs_world_t *world, - ecs_entity_t type, - ecs_strbuf_t *buf) -{ - return json_typeinfo_ser_type(world, type, buf); + ecs_modified(world, type, EcsMember); + } + + return 0; } -char* ecs_type_info_to_json( - const ecs_world_t *world, - ecs_entity_t type) +static +int add_constant_to_enum( + ecs_world_t *world, + ecs_entity_t type, + ecs_entity_t e, + ecs_id_t constant_id) { - ecs_strbuf_t str = ECS_STRBUF_INIT; + EcsEnum *ptr = ecs_get_mut(world, type, EcsEnum, NULL); + + /* Remove constant from map if it was already added */ + ecs_map_iter_t it = ecs_map_iter(ptr->constants); + ecs_enum_constant_t *c; + ecs_map_key_t key; + while ((c = ecs_map_next(&it, ecs_enum_constant_t, &key))) { + if (c->constant == e) { + ecs_os_free((char*)c->name); + ecs_map_remove(ptr->constants, key); + } + } - if (ecs_type_info_to_json_buf(world, type, &str) != 0) { - ecs_strbuf_reset(&str); - return NULL; + /* Check if constant sets explicit value */ + int32_t value = 0; + bool value_set = false; + if (ecs_id_is_pair(constant_id)) { + if (ecs_pair_second(world, constant_id) != ecs_id(ecs_i32_t)) { + char *path = ecs_get_fullpath(world, e); + ecs_err("expected i32 type for enum constant '%s'", path); + ecs_os_free(path); + return -1; + } + + const int32_t *value_ptr = ecs_get_pair_object( + world, e, EcsConstant, ecs_i32_t); + ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + value = *value_ptr; + value_set = true; } - return ecs_strbuf_get(&str); -} + /* Make sure constant value doesn't conflict if set / find the next value */ + it = ecs_map_iter(ptr->constants); + while ((c = ecs_map_next(&it, ecs_enum_constant_t, &key))) { + if (value_set) { + if (c->value == value) { + char *path = ecs_get_fullpath(world, e); + ecs_err("conflicting constant value for '%s' (other is '%s')", + path, c->name); + ecs_os_free(path); + return -1; + } + } else { + if (c->value >= value) { + value = c->value + 1; + } + } + } -#endif + if (!ptr->constants) { + ptr->constants = ecs_map_new(ecs_enum_constant_t, 1); + } + c = ecs_map_ensure(ptr->constants, ecs_enum_constant_t, value); + c->name = ecs_os_strdup(ecs_get_name(world, e)); + c->value = value; + c->constant = e; + ecs_i32_t *cptr = ecs_get_mut_pair_object( + world, e, EcsConstant, ecs_i32_t, NULL); + ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); + cptr[0] = value; -#ifdef FLECS_JSON + return 0; +} -const char* ecs_parse_json( - const ecs_world_t *world, - const char *ptr, - ecs_entity_t type, - void *data_out, - const ecs_parse_json_desc_t *desc) +static +int add_constant_to_bitmask( + ecs_world_t *world, + ecs_entity_t type, + ecs_entity_t e, + ecs_id_t constant_id) { - char token[ECS_MAX_TOKEN_SIZE]; - int depth = 0; - - const char *name = NULL; - const char *expr = NULL; + EcsBitmask *ptr = ecs_get_mut(world, type, EcsBitmask, NULL); + + /* Remove constant from map if it was already added */ + ecs_map_iter_t it = ecs_map_iter(ptr->constants); + ecs_bitmask_constant_t *c; + ecs_map_key_t key; + while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { + if (c->constant == e) { + ecs_os_free((char*)c->name); + ecs_map_remove(ptr->constants, key); + } + } - ptr = ecs_parse_fluff(ptr, NULL); + /* Check if constant sets explicit value */ + uint32_t value = 1; + if (ecs_id_is_pair(constant_id)) { + if (ecs_pair_second(world, constant_id) != ecs_id(ecs_u32_t)) { + char *path = ecs_get_fullpath(world, e); + ecs_err("expected u32 type for bitmask constant '%s'", path); + ecs_os_free(path); + return -1; + } - ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, data_out); - if (cur.valid == false) { - return NULL; + const uint32_t *value_ptr = ecs_get_pair_object( + world, e, EcsConstant, ecs_u32_t); + ecs_assert(value_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + value = *value_ptr; + } else { + value = 1u << (ecs_u32_t)ecs_map_count(ptr->constants); } - if (desc) { - name = desc->name; - expr = desc->expr; + /* Make sure constant value doesn't conflict */ + it = ecs_map_iter(ptr->constants); + while ((c = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { + if (c->value == value) { + char *path = ecs_get_fullpath(world, e); + ecs_err("conflicting constant value for '%s' (other is '%s')", + path, c->name); + ecs_os_free(path); + return -1; + } } - while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) { - - ptr = ecs_parse_fluff(ptr, NULL); + if (!ptr->constants) { + ptr->constants = ecs_map_new(ecs_bitmask_constant_t, 1); + } - if (!ecs_os_strcmp(token, "{")) { - depth ++; - if (ecs_meta_push(&cur) != 0) { - goto error; - } + c = ecs_map_ensure(ptr->constants, ecs_bitmask_constant_t, value); + c->name = ecs_os_strdup(ecs_get_name(world, e)); + c->value = value; + c->constant = e; - if (ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected '['"); - return NULL; - } - } + ecs_u32_t *cptr = ecs_get_mut_pair_object( + world, e, EcsConstant, ecs_u32_t, NULL); + ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); + cptr[0] = value; - else if (!ecs_os_strcmp(token, "}")) { - depth --; + return 0; +} - if (ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected ']'"); - return NULL; - } +static +void set_primitive(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsPrimitive *type = ecs_term(it, EcsPrimitive, 1); - if (ecs_meta_pop(&cur) != 0) { - goto error; - } + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + switch(type->kind) { + case EcsBool: + init_type_t(world, e, EcsPrimitiveType, bool); + break; + case EcsChar: + init_type_t(world, e, EcsPrimitiveType, char); + break; + case EcsByte: + init_type_t(world, e, EcsPrimitiveType, bool); + break; + case EcsU8: + init_type_t(world, e, EcsPrimitiveType, uint8_t); + break; + case EcsU16: + init_type_t(world, e, EcsPrimitiveType, uint16_t); + break; + case EcsU32: + init_type_t(world, e, EcsPrimitiveType, uint32_t); + break; + case EcsU64: + init_type_t(world, e, EcsPrimitiveType, uint64_t); + break; + case EcsI8: + init_type_t(world, e, EcsPrimitiveType, int8_t); + break; + case EcsI16: + init_type_t(world, e, EcsPrimitiveType, int16_t); + break; + case EcsI32: + init_type_t(world, e, EcsPrimitiveType, int32_t); + break; + case EcsI64: + init_type_t(world, e, EcsPrimitiveType, int64_t); + break; + case EcsF32: + init_type_t(world, e, EcsPrimitiveType, float); + break; + case EcsF64: + init_type_t(world, e, EcsPrimitiveType, double); + break; + case EcsUPtr: + init_type_t(world, e, EcsPrimitiveType, uintptr_t); + break; + case EcsIPtr: + init_type_t(world, e, EcsPrimitiveType, intptr_t); + break; + case EcsString: + init_type_t(world, e, EcsPrimitiveType, char*); + break; + case EcsEntity: + init_type_t(world, e, EcsPrimitiveType, ecs_entity_t); + break; } + } +} - else if (!ecs_os_strcmp(token, "[")) { - depth ++; - if (ecs_meta_push(&cur) != 0) { - goto error; - } +static +void set_member(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsMember *member = ecs_term(it, EcsMember, 1); - if (!ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected '{'"); - return NULL; - } + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); + if (!parent) { + ecs_err("missing parent for member '%s'", ecs_get_name(world, e)); + continue; } - else if (!ecs_os_strcmp(token, "]")) { - depth --; + add_member_to_struct(world, parent, e, &member[i]); + } +} - if (!ecs_meta_is_collection(&cur)) { - ecs_parser_error(name, expr, ptr - expr, "expected '}'"); - return NULL; - } +static +void add_enum(ecs_iter_t *it) { + ecs_world_t *world = it->world; - if (ecs_meta_pop(&cur) != 0) { - goto error; - } - } + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; - else if (!ecs_os_strcmp(token, ",")) { - if (ecs_meta_next(&cur) != 0) { - goto error; - } + if (init_type_t(world, e, EcsEnumType, ecs_i32_t)) { + continue; } - else if (!ecs_os_strcmp(token, "null")) { - if (ecs_meta_set_null(&cur) != 0) { - goto error; - } - } + ecs_add_id(world, e, EcsExclusive); + ecs_add_id(world, e, EcsTag); + } +} - else if (token[0] == '\"') { - if (ptr[0] == ':') { - /* Member assignment */ - ptr ++; +static +void add_bitmask(ecs_iter_t *it) { + ecs_world_t *world = it->world; - /* Strip trailing " */ - ecs_size_t len = ecs_os_strlen(token); - if (token[len - 1] != '"') { - ecs_parser_error(name, expr, ptr - expr, "expected \""); - return NULL; - } else { - token[len - 1] = '\0'; - } + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; - if (ecs_meta_member(&cur, token + 1) != 0) { - goto error; - } - } else { - if (ecs_meta_set_string_literal(&cur, token) != 0) { - goto error; - } - } + if (init_type_t(world, e, EcsBitmaskType, ecs_u32_t)) { + continue; } + } +} - else { - if (ecs_meta_set_string(&cur, token) != 0) { - goto error; - } +static +void add_constant(ecs_iter_t *it) { + ecs_world_t *world = it->world; + + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); + if (!parent) { + ecs_err("missing parent for constant '%s'", ecs_get_name(world, e)); + continue; } - if (!depth) { - break; + if (ecs_has(world, parent, EcsEnum)) { + add_constant_to_enum(world, parent, e, it->event_id); + } else if (ecs_has(world, parent, EcsBitmask)) { + add_constant_to_bitmask(world, parent, e, it->event_id); } } - - return ptr; -error: - return NULL; } -#endif +static +void set_array(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsArray *array = ecs_term(it, EcsArray, 1); + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_entity_t elem_type = array[i].type; + int32_t elem_count = array[i].count; -#ifdef FLECS_REST + if (!elem_type) { + ecs_err("array '%s' has no element type", ecs_get_name(world, e)); + continue; + } -typedef struct { - ecs_world_t *world; - ecs_entity_t entity; - ecs_http_server_t *srv; - int32_t rc; -} ecs_rest_ctx_t; + if (!elem_count) { + ecs_err("array '%s' has size 0", ecs_get_name(world, e)); + continue; + } -static ECS_COPY(EcsRest, dst, src, { - ecs_rest_ctx_t *impl = src->impl; - if (impl) { - impl->rc ++; + const EcsComponent *elem_ptr = ecs_get(world, elem_type, EcsComponent); + if (init_type(world, e, EcsArrayType, + elem_ptr->size * elem_count, elem_ptr->alignment)) + { + continue; + } } +} - ecs_os_strset(&dst->ipaddr, src->ipaddr); - dst->port = src->port; - dst->impl = impl; -}) +static +void set_vector(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsVector *array = ecs_term(it, EcsVector, 1); -static ECS_MOVE(EcsRest, dst, src, { - *dst = *src; - src->ipaddr = NULL; - src->impl = NULL; -}) + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_entity_t elem_type = array[i].type; -static ECS_DTOR(EcsRest, ptr, { - ecs_rest_ctx_t *impl = ptr->impl; - if (impl) { - impl->rc --; - if (!impl->rc) { - ecs_http_server_fini(impl->srv); - ecs_os_free(impl); + if (!elem_type) { + ecs_err("vector '%s' has no element type", ecs_get_name(world, e)); + continue; } - } - ecs_os_free(ptr->ipaddr); -}) - -static char *rest_last_err; - -static -void rest_capture_log( - int32_t level, - const char *file, - int32_t line, - const char *msg) -{ - (void)file; (void)line; - if (!rest_last_err && level < 0) { - rest_last_err = ecs_os_strdup(msg); + if (init_type_t(world, e, EcsVectorType, ecs_vector_t*)) { + continue; + } } } -static -char* rest_get_captured_log(void) { - char *result = rest_last_err; - rest_last_err = NULL; - return result; -} - -static -void reply_verror( - ecs_http_reply_t *reply, - const char *fmt, - va_list args) +bool flecs_unit_validate( + ecs_world_t *world, + ecs_entity_t t, + EcsUnit *data) { - ecs_strbuf_appendstr(&reply->body, "{\"error\":\""); - ecs_strbuf_vappend(&reply->body, fmt, args); - ecs_strbuf_appendstr(&reply->body, "\"}"); -} + char *derived_symbol = NULL; + const char *symbol = data->symbol; -static -void reply_error( - ecs_http_reply_t *reply, - const char *fmt, - ...) -{ - va_list args; - va_start(args, fmt); - reply_verror(reply, fmt, args); - va_end(args); -} + ecs_entity_t base = data->base; + ecs_entity_t over = data->over; + ecs_entity_t prefix = data->prefix; + ecs_unit_translation_t translation = data->translation; -static -void rest_bool_param( - const ecs_http_request_t *req, - const char *name, - bool *value_out) -{ - const char *value = ecs_http_get_param(req, name); - if (value) { - if (!ecs_os_strcmp(value, "true")) { - value_out[0] = true; - } else { - value_out[0] = false; + if (base) { + if (!ecs_has(world, base, EcsUnit)) { + ecs_err("entity '%s' for unit '%s' used as base is not a unit", + ecs_get_name(world, base), ecs_get_name(world, t)); + goto error; } } -} -static -void rest_int_param( - const ecs_http_request_t *req, - const char *name, - int32_t *value_out) -{ - const char *value = ecs_http_get_param(req, name); - if (value) { - *value_out = atoi(value); + if (over) { + if (!base) { + ecs_err("invalid unit '%s': cannot specify over without base", + ecs_get_name(world, t)); + goto error; + } + if (!ecs_has(world, over, EcsUnit)) { + ecs_err("entity '%s' for unit '%s' used as over is not a unit", + ecs_get_name(world, over), ecs_get_name(world, t)); + goto error; + } } -} - -static -void rest_parse_json_ser_entity_params( - ecs_entity_to_json_desc_t *desc, - const ecs_http_request_t *req) -{ - rest_bool_param(req, "path", &desc->serialize_path); - rest_bool_param(req, "label", &desc->serialize_label); - rest_bool_param(req, "brief", &desc->serialize_brief); - rest_bool_param(req, "link", &desc->serialize_link); - rest_bool_param(req, "id_labels", &desc->serialize_id_labels); - rest_bool_param(req, "base", &desc->serialize_base); - rest_bool_param(req, "values", &desc->serialize_values); - rest_bool_param(req, "private", &desc->serialize_private); - rest_bool_param(req, "type_info", &desc->serialize_type_info); -} - -static -void rest_parse_json_ser_iter_params( - ecs_iter_to_json_desc_t *desc, - const ecs_http_request_t *req) -{ - rest_bool_param(req, "term_ids", &desc->serialize_term_ids); - rest_bool_param(req, "ids", &desc->serialize_ids); - rest_bool_param(req, "subjects", &desc->serialize_subjects); - rest_bool_param(req, "variables", &desc->serialize_variables); - rest_bool_param(req, "is_set", &desc->serialize_is_set); - rest_bool_param(req, "values", &desc->serialize_values); - rest_bool_param(req, "entities", &desc->serialize_entities); - rest_bool_param(req, "entity_labels", &desc->serialize_entity_labels); - rest_bool_param(req, "variable_labels", &desc->serialize_variable_labels); - rest_bool_param(req, "duration", &desc->measure_eval_duration); - rest_bool_param(req, "type_info", &desc->serialize_type_info); -} -static -bool rest_reply( - const ecs_http_request_t* req, - ecs_http_reply_t *reply, - void *ctx) -{ - ecs_rest_ctx_t *impl = ctx; - ecs_world_t *world = impl->world; + if (prefix) { + if (!base) { + ecs_err("invalid unit '%s': cannot specify prefix without base", + ecs_get_name(world, t)); + goto error; + } + const EcsUnitPrefix *prefix_ptr = ecs_get(world, prefix, EcsUnitPrefix); + if (!prefix_ptr) { + ecs_err("entity '%s' for unit '%s' used as prefix is not a prefix", + ecs_get_name(world, over), ecs_get_name(world, t)); + goto error; + } - if (req->path == NULL) { - ecs_dbg("rest: bad request (missing path)"); - reply_error(reply, "bad request (missing path)"); - reply->code = 400; - return false; + if (translation.factor || translation.power) { + if (prefix_ptr->translation.factor != translation.factor || + prefix_ptr->translation.power != translation.power) + { + ecs_err( + "factor for unit '%s' is inconsistent with prefix '%s'", + ecs_get_name(world, t), ecs_get_name(world, prefix)); + goto error; + } + } else { + translation = prefix_ptr->translation; + } } - ecs_strbuf_appendstr(&reply->headers, "Access-Control-Allow-Origin: *\r\n"); + if (base) { + bool must_match = false; /* Must base symbol match symbol? */ + ecs_strbuf_t sbuf = ECS_STRBUF_INIT; + if (prefix) { + const EcsUnitPrefix *ptr = ecs_get(world, prefix, EcsUnitPrefix); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + if (ptr->symbol) { + ecs_strbuf_appendstr(&sbuf, ptr->symbol); + must_match = true; + } + } - if (req->method == EcsHttpGet) { - /* Entity endpoint */ - if (!ecs_os_strncmp(req->path, "entity/", 7)) { - char *path = &req->path[7]; - ecs_dbg_2("rest: request entity '%s'", path); + const EcsUnit *uptr = ecs_get(world, base, EcsUnit); + ecs_assert(uptr != NULL, ECS_INTERNAL_ERROR, NULL); + if (uptr->symbol) { + ecs_strbuf_appendstr(&sbuf, uptr->symbol); + } - ecs_entity_t e = ecs_lookup_path_w_sep( - world, 0, path, "/", NULL, false); - if (!e) { - ecs_dbg_2("rest: entity '%s' not found", path); - reply_error(reply, "entity '%s' not found", path); - reply->code = 404; - return true; + if (over) { + uptr = ecs_get(world, over, EcsUnit); + ecs_assert(uptr != NULL, ECS_INTERNAL_ERROR, NULL); + if (uptr->symbol) { + ecs_strbuf_appendstr(&sbuf, "/"); + ecs_strbuf_appendstr(&sbuf, uptr->symbol); + must_match = true; } + } - ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT; - rest_parse_json_ser_entity_params(&desc, req); + derived_symbol = ecs_strbuf_get(&sbuf); + if (derived_symbol && !ecs_os_strlen(derived_symbol)) { + ecs_os_free(derived_symbol); + derived_symbol = NULL; + } - ecs_entity_to_json_buf(world, e, &reply->body, &desc); - return true; - - /* Query endpoint */ - } else if (!ecs_os_strcmp(req->path, "query")) { - const char *q = ecs_http_get_param(req, "q"); - if (!q) { - ecs_strbuf_appendstr(&reply->body, "Missing parameter 'q'"); - reply->code = 400; /* bad request */ - return true; + if (derived_symbol && symbol && ecs_os_strcmp(symbol, derived_symbol)) { + if (must_match) { + ecs_err("symbol '%s' for unit '%s' does not match base" + " symbol '%s'", symbol, + ecs_get_name(world, t), derived_symbol); + goto error; } + } + if (!symbol && derived_symbol && (prefix || over)) { + ecs_os_free(data->symbol); + data->symbol = derived_symbol; + } else { + ecs_os_free(derived_symbol); + } + } - ecs_dbg_2("rest: request query '%s'", q); - bool prev_color = ecs_log_enable_colors(false); - ecs_os_api_log_t prev_log_ = ecs_os_api.log_; - ecs_os_api.log_ = rest_capture_log; + data->base = base; + data->over = over; + data->prefix = prefix; + data->translation = translation; - ecs_rule_t *r = ecs_rule_init(world, &(ecs_filter_desc_t) { - .expr = q - }); - if (!r) { - char *err = rest_get_captured_log(); - char *escaped_err = ecs_astresc('"', err); - reply_error(reply, escaped_err); - reply->code = 400; /* bad request */ - ecs_os_free(escaped_err); - ecs_os_free(err); - } else { - ecs_iter_to_json_desc_t desc = ECS_ITER_TO_JSON_INIT; - rest_parse_json_ser_iter_params(&desc, req); + return true; +error: + ecs_os_free(derived_symbol); + return false; +} - int32_t offset = 0; - int32_t limit = 100; +static +void set_unit(ecs_iter_t *it) { + EcsUnit *u = ecs_term(it, EcsUnit, 1); - rest_int_param(req, "offset", &offset); - rest_int_param(req, "limit", &limit); + ecs_world_t *world = it->world; - ecs_iter_t it = ecs_rule_iter(world, r); - ecs_iter_t pit = ecs_page_iter(&it, offset, limit); - ecs_iter_to_json_buf(world, &pit, &reply->body, &desc); - ecs_rule_fini(r); - } + int i, count = it->count; + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + flecs_unit_validate(world, e, &u[i]); + } +} - ecs_os_api.log_ = prev_log_; - ecs_log_enable_colors(prev_color); +static +void unit_quantity_monitor(ecs_iter_t *it) { + ecs_world_t *world = it->world; - return true; + int i, count = it->count; + if (it->event == EcsOnAdd) { + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_add_pair(world, e, EcsQuantity, e); + } + } else { + for (i = 0; i < count; i ++) { + ecs_entity_t e = it->entities[i]; + ecs_remove_pair(world, e, EcsQuantity, e); } } - if (req->method == EcsHttpOptions) { - return true; - } - - return false; } static -void on_set_rest(ecs_iter_t *it) -{ - EcsRest *rest = it->ptrs[0]; +void ecs_meta_type_init_default_ctor(ecs_iter_t *it) { + ecs_world_t *world = it->world; + EcsMetaType *type = ecs_term(it, EcsMetaType, 1); int i; - for(i = 0; i < it->count; i ++) { - if (!rest[i].port) { - rest[i].port = ECS_REST_DEFAULT_PORT; - } - - ecs_rest_ctx_t *srv_ctx = ecs_os_malloc_t(ecs_rest_ctx_t); - ecs_http_server_t *srv = ecs_http_server_init(&(ecs_http_server_desc_t){ - .ipaddr = rest[i].ipaddr, - .port = rest[i].port, - .callback = rest_reply, - .ctx = srv_ctx - }); - - if (!srv) { - const char *ipaddr = rest[i].ipaddr ? rest[i].ipaddr : "0.0.0.0"; - ecs_err("failed to create REST server on %s:%u", - ipaddr, rest[i].port); - ecs_os_free(srv_ctx); - continue; + for (i = 0; i < it->count; i ++) { + /* If a component is defined from reflection data, configure it with the + * default constructor. This ensures that a new component value does not + * contain uninitialized memory, which could cause serializers to crash + * when for example inspecting string fields. */ + if (!type->existing) { + ecs_set_component_actions_w_id(world, it->entities[i], + &(EcsComponentLifecycle){ + .ctor = ecs_default_ctor + }); } - - srv_ctx->world = it->world; - srv_ctx->entity = it->entities[i]; - srv_ctx->srv = srv; - srv_ctx->rc = 1; - - rest[i].impl = srv_ctx; - - ecs_http_server_start(srv_ctx->srv); } } static -void DequeueRest(ecs_iter_t *it) { - EcsRest *rest = ecs_term(it, EcsRest, 1); - - if (it->delta_system_time > (FLECS_FLOAT)1.0) { - ecs_warn( - "detected large progress interval (%.2fs), REST request may timeout", - (double)it->delta_system_time); +void member_on_set(ecs_iter_t *it) { + EcsMember *mbr = it->ptrs[0]; + if (!mbr->count) { + mbr->count = 1; } - - int32_t i; - for(i = 0; i < it->count; i ++) { - ecs_rest_ctx_t *ctx = rest[i].impl; - if (ctx) { - ecs_http_server_dequeue(ctx->srv, it->delta_time); - } - } } -void FlecsRestImport( +void FlecsMetaImport( ecs_world_t *world) { - ECS_MODULE(world, FlecsRest); + ECS_MODULE(world, FlecsMeta); ecs_set_name_prefix(world, "Ecs"); - flecs_bootstrap_component(world, EcsRest); - - ecs_set_component_actions(world, EcsRest, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsRest), - .copy = ecs_copy(EcsRest), - .dtor = ecs_dtor(EcsRest), - .on_set = on_set_rest - }); - - ECS_SYSTEM(world, DequeueRest, EcsPostFrame, EcsRest); -} - -#endif - - - -#ifdef FLECS_COREDOC - -#define URL_ROOT "https://flecs.docsforge.com/master/relations-manual/" - -void FlecsCoreDocImport( - ecs_world_t *world) -{ - ECS_MODULE(world, FlecsCoreDoc); - - ECS_IMPORT(world, FlecsMeta); - ECS_IMPORT(world, FlecsDoc); + flecs_bootstrap_component(world, EcsMetaType); + flecs_bootstrap_component(world, EcsMetaTypeSerialized); + flecs_bootstrap_component(world, EcsPrimitive); + flecs_bootstrap_component(world, EcsEnum); + flecs_bootstrap_component(world, EcsBitmask); + flecs_bootstrap_component(world, EcsMember); + flecs_bootstrap_component(world, EcsStruct); + flecs_bootstrap_component(world, EcsArray); + flecs_bootstrap_component(world, EcsVector); + flecs_bootstrap_component(world, EcsUnit); + flecs_bootstrap_component(world, EcsUnitPrefix); - ecs_set_name_prefix(world, "Ecs"); + flecs_bootstrap_tag(world, EcsConstant); + flecs_bootstrap_tag(world, EcsQuantity); - /* Initialize reflection data for core components */ + ecs_set_component_actions(world, EcsMetaType, { .ctor = ecs_default_ctor }); - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsComponent), - .members = { - {.name = (char*)"size", .type = ecs_id(ecs_i32_t)}, - {.name = (char*)"alignment", .type = ecs_id(ecs_i32_t)} - } + ecs_set_component_actions(world, EcsMetaTypeSerialized, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsMetaTypeSerialized), + .copy = ecs_copy(EcsMetaTypeSerialized), + .dtor = ecs_dtor(EcsMetaTypeSerialized) }); - ecs_struct_init(world, &(ecs_struct_desc_t) { - .entity.entity = ecs_id(EcsDocDescription), - .members = { - {.name = "value", .type = ecs_id(ecs_string_t)} - } + ecs_set_component_actions(world, EcsStruct, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsStruct), + .copy = ecs_copy(EcsStruct), + .dtor = ecs_dtor(EcsStruct) }); - /* Initialize documentation data for core components */ - ecs_doc_set_brief(world, EcsFlecs, "Flecs root module"); - ecs_doc_set_link(world, EcsFlecs, "https://github.com/SanderMertens/flecs"); - - ecs_doc_set_brief(world, EcsFlecsCore, "Flecs module with builtin components"); - ecs_doc_set_brief(world, EcsFlecsHidden, "Flecs module with internal/anonymous entities"); - - ecs_doc_set_brief(world, EcsWorld, "Entity associated with world"); - - ecs_doc_set_brief(world, ecs_id(EcsComponent), "Component that is added to all components"); - ecs_doc_set_brief(world, EcsModule, "Tag that is added to modules"); - ecs_doc_set_brief(world, EcsPrefab, "Tag that is added to prefabs"); - ecs_doc_set_brief(world, EcsDisabled, "Tag that is added to disabled entities"); - - ecs_doc_set_brief(world, ecs_id(EcsIdentifier), "Component used for entity names"); - ecs_doc_set_brief(world, EcsName, "Tag used with EcsIdentifier to signal entity name"); - ecs_doc_set_brief(world, EcsSymbol, "Tag used with EcsIdentifier to signal entity symbol"); - - ecs_doc_set_brief(world, ecs_id(EcsComponentLifecycle), "Callbacks for component constructors, destructors, copy and move operations"); + ecs_set_component_actions(world, EcsMember, { + .ctor = ecs_default_ctor, + .on_set = member_on_set + }); - ecs_doc_set_brief(world, EcsTransitive, "Transitive relation property"); - ecs_doc_set_brief(world, EcsReflexive, "Reflexive relation property"); - ecs_doc_set_brief(world, EcsFinal, "Final relation property"); - ecs_doc_set_brief(world, EcsDontInherit, "DontInherit relation property"); - ecs_doc_set_brief(world, EcsTag, "Tag relation property"); - ecs_doc_set_brief(world, EcsAcyclic, "Acyclic relation property"); - ecs_doc_set_brief(world, EcsExclusive, "Exclusive relation property"); - ecs_doc_set_brief(world, EcsSymmetric, "Symmetric relation property"); - ecs_doc_set_brief(world, EcsWith, "With relation property"); - ecs_doc_set_brief(world, EcsOnDelete, "OnDelete relation cleanup property"); - ecs_doc_set_brief(world, EcsOnDeleteObject, "OnDeleteObject relation cleanup property"); - ecs_doc_set_brief(world, EcsDefaultChildComponent, "Sets default component hint for children of entity"); - ecs_doc_set_brief(world, EcsRemove, "Remove relation cleanup property"); - ecs_doc_set_brief(world, EcsDelete, "Delete relation cleanup property"); - ecs_doc_set_brief(world, EcsThrow, "Throw relation cleanup property"); - ecs_doc_set_brief(world, EcsIsA, "Builtin IsA relation"); - ecs_doc_set_brief(world, EcsChildOf, "Builtin ChildOf relation"); - ecs_doc_set_brief(world, EcsOnAdd, "Builtin OnAdd event"); - ecs_doc_set_brief(world, EcsOnRemove, "Builtin OnRemove event"); - ecs_doc_set_brief(world, EcsOnSet, "Builtin OnSet event"); - ecs_doc_set_brief(world, EcsUnSet, "Builtin UnSet event"); + ecs_set_component_actions(world, EcsEnum, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsEnum), + .copy = ecs_copy(EcsEnum), + .dtor = ecs_dtor(EcsEnum) + }); - ecs_doc_set_link(world, EcsTransitive, URL_ROOT "#transitive-property"); - ecs_doc_set_link(world, EcsReflexive, URL_ROOT "#reflexive-property"); - ecs_doc_set_link(world, EcsFinal, URL_ROOT "#final-property"); - ecs_doc_set_link(world, EcsDontInherit, URL_ROOT "#dontinherit-property"); - ecs_doc_set_link(world, EcsTag, URL_ROOT "#tag-property"); - ecs_doc_set_link(world, EcsAcyclic, URL_ROOT "#acyclic-property"); - ecs_doc_set_link(world, EcsExclusive, URL_ROOT "#exclusive-property"); - ecs_doc_set_link(world, EcsSymmetric, URL_ROOT "#symmetric-property"); - ecs_doc_set_link(world, EcsWith, URL_ROOT "#with-property"); - ecs_doc_set_link(world, EcsOnDelete, URL_ROOT "#cleanup-properties"); - ecs_doc_set_link(world, EcsOnDeleteObject, URL_ROOT "#cleanup-properties"); - ecs_doc_set_link(world, EcsRemove, URL_ROOT "#cleanup-properties"); - ecs_doc_set_link(world, EcsDelete, URL_ROOT "#cleanup-properties"); - ecs_doc_set_link(world, EcsThrow, URL_ROOT "#cleanup-properties"); - ecs_doc_set_link(world, EcsIsA, URL_ROOT "#the-isa-relation"); - ecs_doc_set_link(world, EcsChildOf, URL_ROOT "#the-childof-relation"); - - /* Initialize documentation for meta components */ - ecs_entity_t meta = ecs_lookup_fullpath(world, "flecs.meta"); - ecs_doc_set_brief(world, meta, "Flecs module with reflection components"); + ecs_set_component_actions(world, EcsBitmask, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsBitmask), + .copy = ecs_copy(EcsBitmask), + .dtor = ecs_dtor(EcsBitmask) + }); - ecs_doc_set_brief(world, ecs_id(EcsMetaType), "Component added to types"); - ecs_doc_set_brief(world, ecs_id(EcsMetaTypeSerialized), "Component that stores reflection data in an optimized format"); - ecs_doc_set_brief(world, ecs_id(EcsPrimitive), "Component added to primitive types"); - ecs_doc_set_brief(world, ecs_id(EcsEnum), "Component added to enumeration types"); - ecs_doc_set_brief(world, ecs_id(EcsBitmask), "Component added to bitmask types"); - ecs_doc_set_brief(world, ecs_id(EcsMember), "Component added to struct members"); - ecs_doc_set_brief(world, ecs_id(EcsStruct), "Component added to struct types"); - ecs_doc_set_brief(world, ecs_id(EcsArray), "Component added to array types"); - ecs_doc_set_brief(world, ecs_id(EcsVector), "Component added to vector types"); + ecs_set_component_actions(world, EcsUnit, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsUnit), + .copy = ecs_copy(EcsUnit), + .dtor = ecs_dtor(EcsUnit) + }); - ecs_doc_set_brief(world, ecs_id(ecs_bool_t), "bool component"); - ecs_doc_set_brief(world, ecs_id(ecs_char_t), "char component"); - ecs_doc_set_brief(world, ecs_id(ecs_byte_t), "byte component"); - ecs_doc_set_brief(world, ecs_id(ecs_u8_t), "8 bit unsigned int component"); - ecs_doc_set_brief(world, ecs_id(ecs_u16_t), "16 bit unsigned int component"); - ecs_doc_set_brief(world, ecs_id(ecs_u32_t), "32 bit unsigned int component"); - ecs_doc_set_brief(world, ecs_id(ecs_u64_t), "64 bit unsigned int component"); - ecs_doc_set_brief(world, ecs_id(ecs_uptr_t), "word sized unsigned int component"); - ecs_doc_set_brief(world, ecs_id(ecs_i8_t), "8 bit signed int component"); - ecs_doc_set_brief(world, ecs_id(ecs_i16_t), "16 bit signed int component"); - ecs_doc_set_brief(world, ecs_id(ecs_i32_t), "32 bit signed int component"); - ecs_doc_set_brief(world, ecs_id(ecs_i64_t), "64 bit signed int component"); - ecs_doc_set_brief(world, ecs_id(ecs_iptr_t), "word sized signed int component"); - ecs_doc_set_brief(world, ecs_id(ecs_f32_t), "32 bit floating point component"); - ecs_doc_set_brief(world, ecs_id(ecs_f64_t), "64 bit floating point component"); - ecs_doc_set_brief(world, ecs_id(ecs_string_t), "string component"); - ecs_doc_set_brief(world, ecs_id(ecs_entity_t), "entity component"); + ecs_set_component_actions(world, EcsUnitPrefix, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsUnitPrefix), + .copy = ecs_copy(EcsUnitPrefix), + .dtor = ecs_dtor(EcsUnitPrefix) + }); - /* Initialize documentation for doc components */ - ecs_entity_t doc = ecs_lookup_fullpath(world, "flecs.doc"); - ecs_doc_set_brief(world, doc, "Flecs module with documentation components"); + /* Register triggers to finalize type information from component data */ + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsPrimitive), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = set_primitive + }); - ecs_doc_set_brief(world, ecs_id(EcsDocDescription), "Component used to add documentation"); - ecs_doc_set_brief(world, EcsDocBrief, "Used as (Description, Brief) to add a brief description"); - ecs_doc_set_brief(world, EcsDocDetail, "Used as (Description, Detail) to add a detailed description"); - ecs_doc_set_brief(world, EcsDocLink, "Used as (Description, Link) to add a link"); -} + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsMember), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = set_member + }); -#endif + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsEnum), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnAdd}, + .callback = add_enum + }); -/* This is a heavily modified version of the EmbeddableWebServer (see copyright - * below). This version has been stripped from everything not strictly necessary - * for receiving/replying to simple HTTP requests, and has been modified to use - * the Flecs OS API. */ + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsBitmask), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnAdd}, + .callback = add_bitmask + }); -/* EmbeddableWebServer Copyright (c) 2016, 2019, 2020 Forrest Heller, and - * CONTRIBUTORS (see below) - All rights reserved. - * - * CONTRIBUTORS: - * Martin Pulec - bug fixes, warning fixes, IPv6 support - * Daniel Barry - bug fix (ifa_addr != NULL) - * - * Released under the BSD 2-clause license: - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. THIS SOFTWARE IS - * PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS - * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN - * NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = EcsConstant, + .term.subj.set.mask = EcsSelf, + .events = {EcsOnAdd}, + .callback = add_constant + }); + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_pair(EcsConstant, EcsWildcard), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = add_constant + }); -#ifdef FLECS_HTTP + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsArray), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = set_array + }); -#if defined(ECS_TARGET_WINDOWS) -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif -#pragma comment(lib, "Ws2_32.lib") -#include -#include -#include -typedef SOCKET ecs_http_socket_t; -#else -#include -#include -#include -#include -#include -#include -typedef int ecs_http_socket_t; -#endif + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsVector), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = set_vector + }); -/* Max length of request method */ -#define ECS_HTTP_METHOD_LEN_MAX (8) + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsUnit), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = set_unit + }); -/* Timeout (s) before connection purge */ -#define ECS_HTTP_CONNECTION_PURGE_TIMEOUT (1.0) + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsMetaType), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = ecs_meta_type_serialized_init + }); -/* Number of dequeues before purging */ -#define ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT (5) + ecs_trigger_init(world, &(ecs_trigger_desc_t) { + .term.id = ecs_id(EcsMetaType), + .term.subj.set.mask = EcsSelf, + .events = {EcsOnSet}, + .callback = ecs_meta_type_init_default_ctor + }); -/* Minimum interval between dequeueing requests (ms) */ -#define ECS_HTTP_MIN_DEQUEUE_INTERVAL (100) + ecs_observer_init(world, &(ecs_observer_desc_t) { + .filter.terms = { + { .id = ecs_id(EcsUnit) }, + { .id = EcsQuantity } + }, + .events = { EcsMonitor }, + .callback = unit_quantity_monitor + }); -/* Minimum interval between printing statistics (ms) */ -#define ECS_HTTP_MIN_STATS_INTERVAL (10 * 1000) + /* Initialize primitive types */ + #define ECS_PRIMITIVE(world, type, primitive_kind)\ + ecs_entity_init(world, &(ecs_entity_desc_t) {\ + .entity = ecs_id(ecs_##type##_t),\ + .name = #type,\ + .symbol = #type });\ + ecs_set(world, ecs_id(ecs_##type##_t), EcsPrimitive, {\ + .kind = primitive_kind\ + }); -/* Max length of headers in reply */ -#define ECS_HTTP_REPLY_HEADER_SIZE (1024) + ECS_PRIMITIVE(world, bool, EcsBool); + ECS_PRIMITIVE(world, char, EcsChar); + ECS_PRIMITIVE(world, byte, EcsByte); + ECS_PRIMITIVE(world, u8, EcsU8); + ECS_PRIMITIVE(world, u16, EcsU16); + ECS_PRIMITIVE(world, u32, EcsU32); + ECS_PRIMITIVE(world, u64, EcsU64); + ECS_PRIMITIVE(world, uptr, EcsUPtr); + ECS_PRIMITIVE(world, i8, EcsI8); + ECS_PRIMITIVE(world, i16, EcsI16); + ECS_PRIMITIVE(world, i32, EcsI32); + ECS_PRIMITIVE(world, i64, EcsI64); + ECS_PRIMITIVE(world, iptr, EcsIPtr); + ECS_PRIMITIVE(world, f32, EcsF32); + ECS_PRIMITIVE(world, f64, EcsF64); + ECS_PRIMITIVE(world, string, EcsString); + ECS_PRIMITIVE(world, entity, EcsEntity); -/* Receive buffer size */ -#define ECS_HTTP_SEND_RECV_BUFFER_SIZE (16 * 1024) + #undef ECS_PRIMITIVE -/* Max length of request (path + query + headers + body) */ -#define ECS_HTTP_REQUEST_LEN_MAX (10 * 1024 * 1024) + /* Set default child components */ + ecs_add_pair(world, ecs_id(EcsStruct), + EcsDefaultChildComponent, ecs_id(EcsMember)); -/* HTTP server struct */ -struct ecs_http_server_t { - bool should_run; - bool running; + ecs_add_pair(world, ecs_id(EcsMember), + EcsDefaultChildComponent, ecs_id(EcsMember)); - ecs_http_socket_t sock; - ecs_os_mutex_t lock; - ecs_os_thread_t thread; + ecs_add_pair(world, ecs_id(EcsEnum), + EcsDefaultChildComponent, EcsConstant); - ecs_http_reply_action_t callback; - void *ctx; + ecs_add_pair(world, ecs_id(EcsBitmask), + EcsDefaultChildComponent, EcsConstant); - ecs_sparse_t *connections; /* sparse */ - ecs_sparse_t *requests; /* sparse */ + /* Relationship properties */ + ecs_add_id(world, EcsQuantity, EcsExclusive); + ecs_add_id(world, EcsQuantity, EcsTag); - bool initialized; + /* Initialize reflection data for meta components */ + ecs_entity_t type_kind = ecs_enum_init(world, &(ecs_enum_desc_t) { + .entity.name = "TypeKind", + .constants = { + {.name = "PrimitiveType"}, + {.name = "BitmaskType"}, + {.name = "EnumType"}, + {.name = "StructType"}, + {.name = "ArrayType"}, + {.name = "VectorType"} + } + }); - uint16_t port; - const char *ipaddr; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsMetaType), + .members = { + {.name = (char*)"kind", .type = type_kind} + } + }); - FLECS_FLOAT dequeue_timeout; /* used to not lock request queue too often */ - FLECS_FLOAT stats_timeout; /* used for periodic reporting of statistics */ + ecs_entity_t primitive_kind = ecs_enum_init(world, &(ecs_enum_desc_t) { + .entity.name = "PrimitiveKind", + .constants = { + {.name = "Bool", 1}, + {.name = "Char"}, + {.name = "Byte"}, + {.name = "U8"}, + {.name = "U16"}, + {.name = "U32"}, + {.name = "U64"}, + {.name = "I8"}, + {.name = "I16"}, + {.name = "I32"}, + {.name = "I64"}, + {.name = "F32"}, + {.name = "F64"}, + {.name = "UPtr"}, + {.name = "IPtr"}, + {.name = "String"}, + {.name = "Entity"} + } + }); - FLECS_FLOAT request_time; /* time spent on requests in last stats interval */ - FLECS_FLOAT request_time_total; /* total time spent on requests */ - int32_t requests_processed; /* requests processed in last stats interval */ - int32_t requests_processed_total; /* total requests processed */ - int32_t dequeue_count; /* number of dequeues in last stats interval */ -}; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsPrimitive), + .members = { + {.name = (char*)"kind", .type = primitive_kind} + } + }); -/** Fragment state, used by HTTP request parser */ -typedef enum { - HttpFragStateBegin, - HttpFragStateMethod, - HttpFragStatePath, - HttpFragStateVersion, - HttpFragStateHeaderStart, - HttpFragStateHeaderName, - HttpFragStateHeaderValueStart, - HttpFragStateHeaderValue, - HttpFragStateCR, - HttpFragStateCRLF, - HttpFragStateCRLFCR, - HttpFragStateBody, - HttpFragStateDone -} HttpFragState; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsMember), + .members = { + {.name = (char*)"type", .type = ecs_id(ecs_entity_t)}, + {.name = (char*)"count", .type = ecs_id(ecs_i32_t)}, + {.name = (char*)"unit", .type = ecs_id(ecs_entity_t)} + } + }); -/** A fragment is a partially received HTTP request */ -typedef struct { - HttpFragState state; - ecs_strbuf_t buf; - ecs_http_method_t method; - int32_t body_offset; - int32_t query_offset; - int32_t header_offsets[ECS_HTTP_HEADER_COUNT_MAX]; - int32_t header_value_offsets[ECS_HTTP_HEADER_COUNT_MAX]; - int32_t header_count; - int32_t param_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX]; - int32_t param_value_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX]; - int32_t param_count; - char header_buf[32]; - char *header_buf_ptr; - int32_t content_length; - bool parse_content_length; - bool invalid; -} ecs_http_fragment_t; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsArray), + .members = { + {.name = (char*)"type", .type = ecs_id(ecs_entity_t)}, + {.name = (char*)"count", .type = ecs_id(ecs_i32_t)}, + } + }); -/** Extend public connection type with fragment data */ -typedef struct { - ecs_http_connection_t pub; - ecs_http_fragment_t frag; - ecs_http_socket_t sock; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsVector), + .members = { + {.name = (char*)"type", .type = ecs_id(ecs_entity_t)} + } + }); - /* Connection is purged after both timeout expires and connection has - * exceeded retry count. This ensures that a connection does not immediately - * timeout when a frame takes longer than usual */ - FLECS_FLOAT dequeue_timeout; - int32_t dequeue_retries; -} ecs_http_connection_impl_t; + ecs_entity_t ut = ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.name = "unit_translation", + .members = { + {.name = (char*)"factor", .type = ecs_id(ecs_i32_t)}, + {.name = (char*)"power", .type = ecs_id(ecs_i32_t)} + } + }); -typedef struct { - ecs_http_request_t pub; - uint64_t conn_id; /* for sanity check */ - void *res; -} ecs_http_request_impl_t; + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsUnit), + .members = { + {.name = (char*)"symbol", .type = ecs_id(ecs_string_t)}, + {.name = (char*)"prefix", .type = ecs_id(ecs_entity_t)}, + {.name = (char*)"base", .type = ecs_id(ecs_entity_t)}, + {.name = (char*)"over", .type = ecs_id(ecs_entity_t)}, + {.name = (char*)"translation", .type = ut} + } + }); -static -ecs_size_t http_send( - ecs_http_socket_t sock, - const void *buf, - ecs_size_t size, - int flags) -{ -#ifndef ECS_TARGET_MSVC - ssize_t send_bytes = send(sock, buf, flecs_itosize(size), flags); - return flecs_itoi32(send_bytes); -#else - int send_bytes = send(sock, buf, size, flags); - return flecs_itoi32(send_bytes); -#endif + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsUnitPrefix), + .members = { + {.name = (char*)"symbol", .type = ecs_id(ecs_string_t)}, + {.name = (char*)"translation", .type = ut} + } + }); } -static -ecs_size_t http_recv( - ecs_http_socket_t sock, - void *buf, - ecs_size_t size, - int flags) -{ - ecs_size_t ret; -#ifndef ECS_TARGET_MSVC - ssize_t recv_bytes = recv(sock, buf, flecs_itosize(size), flags); - ret = flecs_itoi32(recv_bytes); -#else - int recv_bytes = recv(sock, buf, size, flags); - ret = flecs_itoi32(recv_bytes); #endif - if (ret == -1) { - ecs_dbg("recv failed: %s (sock = %d)", ecs_os_strerror(errno), sock); - } else if (ret == 0) { - ecs_dbg("recv: received 0 bytes (sock = %d)", sock); - } - return ret; -} -static -int http_getnameinfo( - const struct sockaddr* addr, - ecs_size_t addr_len, - char *host, - ecs_size_t host_len, - char *port, - ecs_size_t port_len, - int flags) -{ - ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(host_len > 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(port_len > 0, ECS_INTERNAL_ERROR, NULL); - return getnameinfo(addr, (uint32_t)addr_len, host, (uint32_t)host_len, - port, (uint32_t)port_len, flags); -} +#ifdef FLECS_META -static -int http_bind( - ecs_http_socket_t sock, - const struct sockaddr* addr, - ecs_size_t addr_len) +ecs_entity_t ecs_primitive_init( + ecs_world_t *world, + const ecs_primitive_desc_t *desc) { - ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL); - return bind(sock, addr, (uint32_t)addr_len); -} + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } -static -void http_close( - ecs_http_socket_t sock) -{ -#if defined(ECS_TARGET_WINDOWS) - closesocket(sock); -#else - shutdown(sock, SHUT_RDWR); - close(sock); -#endif + ecs_set(world, t, EcsPrimitive, { desc->kind }); + + return t; } -static -ecs_http_socket_t http_accept( - ecs_http_socket_t sock, - struct sockaddr* addr, - ecs_size_t *addr_len) +ecs_entity_t ecs_enum_init( + ecs_world_t *world, + const ecs_enum_desc_t *desc) { - socklen_t len = (socklen_t)addr_len[0]; - ecs_http_socket_t result = accept(sock, addr, &len); - addr_len[0] = (ecs_size_t)len; - return result; -} + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } -static -void reply_free(ecs_http_reply_t* response) { - ecs_assert(response != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_os_free(response->body.content); -} + ecs_add(world, t, EcsEnum); -static -void request_free(ecs_http_request_impl_t *req) { - ecs_assert(req != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(req->pub.conn != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(req->pub.conn->server != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(req->pub.conn->server->requests != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(req->pub.conn->id == req->conn_id, ECS_INTERNAL_ERROR, NULL); - ecs_os_free(req->res); - flecs_sparse_remove(req->pub.conn->server->requests, req->pub.id); -} + ecs_entity_t old_scope = ecs_set_scope(world, t); -static -void connection_free(ecs_http_connection_impl_t *conn) { - ecs_assert(conn != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(conn->pub.id != 0, ECS_INTERNAL_ERROR, NULL); - uint64_t conn_id = conn->pub.id; + int i; + for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { + const ecs_enum_constant_t *m_desc = &desc->constants[i]; + if (!m_desc->name) { + break; + } - if (conn->sock) { - http_close(conn->sock); + ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = m_desc->name + }); + + if (!m_desc->value) { + ecs_add_id(world, c, EcsConstant); + } else { + ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, + {m_desc->value}); + } } - flecs_sparse_remove(conn->pub.server->connections, conn_id); -} + ecs_set_scope(world, old_scope); -// https://stackoverflow.com/questions/10156409/convert-hex-string-char-to-int -static -char hex_2_int(char a, char b){ - a = (a <= '9') ? (char)(a - '0') : (char)((a & 0x7) + 9); - b = (b <= '9') ? (char)(b - '0') : (char)((b & 0x7) + 9); - return (char)((a << 4) + b); + if (i == 0) { + ecs_err("enum '%s' has no constants", ecs_get_name(world, t)); + ecs_delete(world, t); + return 0; + } + + return t; } -static -void decode_url_str( - char *str) +ecs_entity_t ecs_bitmask_init( + ecs_world_t *world, + const ecs_bitmask_desc_t *desc) { - char ch, *ptr, *dst = str; - for (ptr = str; (ch = *ptr); ptr++) { - if (ch == '%') { - dst[0] = hex_2_int(ptr[1], ptr[2]); - dst ++; - ptr += 2; + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } + + ecs_add(world, t, EcsBitmask); + + ecs_entity_t old_scope = ecs_set_scope(world, t); + + int i; + for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { + const ecs_bitmask_constant_t *m_desc = &desc->constants[i]; + if (!m_desc->name) { + break; + } + + ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = m_desc->name + }); + + if (!m_desc->value) { + ecs_add_id(world, c, EcsConstant); } else { - dst[0] = ptr[0]; - dst ++; + ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, + {m_desc->value}); } } - dst[0] = '\0'; -} -static -void parse_method( - ecs_http_fragment_t *frag) -{ - char *method = ecs_strbuf_get_small(&frag->buf); - if (!ecs_os_strcmp(method, "GET")) frag->method = EcsHttpGet; - else if (!ecs_os_strcmp(method, "POST")) frag->method = EcsHttpPost; - else if (!ecs_os_strcmp(method, "PUT")) frag->method = EcsHttpPut; - else if (!ecs_os_strcmp(method, "DELETE")) frag->method = EcsHttpDelete; - else if (!ecs_os_strcmp(method, "OPTIONS")) frag->method = EcsHttpOptions; - else { - frag->method = EcsHttpMethodUnsupported; - frag->invalid = true; - } - ecs_strbuf_reset(&frag->buf); -} + ecs_set_scope(world, old_scope); -static -bool header_writable( - ecs_http_fragment_t *frag) -{ - return frag->header_count < ECS_HTTP_HEADER_COUNT_MAX; -} + if (i == 0) { + ecs_err("bitmask '%s' has no constants", ecs_get_name(world, t)); + ecs_delete(world, t); + return 0; + } -static -void header_buf_reset( - ecs_http_fragment_t *frag) -{ - frag->header_buf[0] = '\0'; - frag->header_buf_ptr = frag->header_buf; + return t; } -static -void header_buf_append( - ecs_http_fragment_t *frag, - char ch) +ecs_entity_t ecs_array_init( + ecs_world_t *world, + const ecs_array_desc_t *desc) { - if ((frag->header_buf_ptr - frag->header_buf) < - ECS_SIZEOF(frag->header_buf)) - { - frag->header_buf_ptr[0] = ch; - frag->header_buf_ptr ++; - } else { - frag->header_buf_ptr[0] = '\0'; + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; } -} - -static -void enqueue_request( - ecs_http_connection_impl_t *conn) -{ - ecs_http_server_t *srv = conn->pub.server; - ecs_http_fragment_t *frag = &conn->frag; - - if (frag->invalid) { /* invalid request received, don't enqueue */ - ecs_strbuf_reset(&frag->buf); - } else { - char *res = ecs_strbuf_get(&frag->buf); - if (res) { - ecs_os_mutex_lock(srv->lock); - ecs_http_request_impl_t *req = flecs_sparse_add( - srv->requests, ecs_http_request_impl_t); - req->pub.id = flecs_sparse_last_id(srv->requests); - req->conn_id = conn->pub.id; - ecs_os_mutex_unlock(srv->lock); - req->pub.conn = (ecs_http_connection_t*)conn; - req->pub.method = frag->method; - req->pub.path = res + 1; - if (frag->body_offset) { - req->pub.body = &res[frag->body_offset]; - } - int32_t i, count = frag->header_count; - for (i = 0; i < count; i ++) { - req->pub.headers[i].key = &res[frag->header_offsets[i]]; - req->pub.headers[i].value = &res[frag->header_value_offsets[i]]; - } - count = frag->param_count; - for (i = 0; i < count; i ++) { - req->pub.params[i].key = &res[frag->param_offsets[i]]; - req->pub.params[i].value = &res[frag->param_value_offsets[i]]; - decode_url_str((char*)req->pub.params[i].value); - } + ecs_set(world, t, EcsArray, { + .type = desc->type, + .count = desc->count + }); - req->pub.header_count = frag->header_count; - req->pub.param_count = frag->param_count; - req->res = res; - } - } + return t; } -static -bool parse_request( - ecs_http_connection_impl_t *conn, - uint64_t conn_id, - const char* req_frag, - ecs_size_t req_frag_len) +ecs_entity_t ecs_vector_init( + ecs_world_t *world, + const ecs_vector_desc_t *desc) { - ecs_http_fragment_t *frag = &conn->frag; + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } - int32_t i; - for (i = 0; i < req_frag_len; i++) { - char c = req_frag[i]; - switch (frag->state) { - case HttpFragStateBegin: - ecs_os_memset_t(frag, 0, ecs_http_fragment_t); - frag->buf.max = ECS_HTTP_METHOD_LEN_MAX; - frag->state = HttpFragStateMethod; - frag->header_buf_ptr = frag->header_buf; - /* fallthrough */ - case HttpFragStateMethod: - if (c == ' ') { - parse_method(frag); - frag->state = HttpFragStatePath; - frag->buf.max = ECS_HTTP_REQUEST_LEN_MAX; - } else { - ecs_strbuf_appendch(&frag->buf, c); - } - break; - case HttpFragStatePath: - if (c == ' ') { - frag->state = HttpFragStateVersion; - ecs_strbuf_appendch(&frag->buf, '\0'); - } else { - if (c == '?' || c == '=' || c == '&') { - ecs_strbuf_appendch(&frag->buf, '\0'); - int32_t offset = ecs_strbuf_written(&frag->buf); - if (c == '?' || c == '&') { - frag->param_offsets[frag->param_count] = offset; - } else { - frag->param_value_offsets[frag->param_count] = offset; - frag->param_count ++; - } - } else { - ecs_strbuf_appendch(&frag->buf, c); - } - } - break; - case HttpFragStateVersion: - if (c == '\r') { - frag->state = HttpFragStateCR; - } /* version is not stored */ - break; - case HttpFragStateHeaderStart: - if (header_writable(frag)) { - frag->header_offsets[frag->header_count] = - ecs_strbuf_written(&frag->buf); - } - header_buf_reset(frag); - frag->state = HttpFragStateHeaderName; - /* fallthrough */ - case HttpFragStateHeaderName: - if (c == ':') { - frag->state = HttpFragStateHeaderValueStart; - header_buf_append(frag, '\0'); - frag->parse_content_length = !ecs_os_strcmp( - frag->header_buf, "Content-Length"); + ecs_set(world, t, EcsVector, { + .type = desc->type + }); - if (header_writable(frag)) { - ecs_strbuf_appendch(&frag->buf, '\0'); - frag->header_value_offsets[frag->header_count] = - ecs_strbuf_written(&frag->buf); - } - } else if (c == '\r') { - frag->state = HttpFragStateCR; - } else { - header_buf_append(frag, c); - if (header_writable(frag)) { - ecs_strbuf_appendch(&frag->buf, c); - } - } - break; - case HttpFragStateHeaderValueStart: - header_buf_reset(frag); - frag->state = HttpFragStateHeaderValue; - if (c == ' ') { /* skip first space */ - break; - } - /* fallthrough */ - case HttpFragStateHeaderValue: - if (c == '\r') { - if (frag->parse_content_length) { - header_buf_append(frag, '\0'); - int32_t len = atoi(frag->header_buf); - if (len < 0) { - frag->invalid = true; - } else { - frag->content_length = len; - } - frag->parse_content_length = false; - } - if (header_writable(frag)) { - int32_t cur = ecs_strbuf_written(&frag->buf); - if (frag->header_offsets[frag->header_count] < cur && - frag->header_value_offsets[frag->header_count] < cur) - { - ecs_strbuf_appendch(&frag->buf, '\0'); - frag->header_count ++; - } - } - frag->state = HttpFragStateCR; - } else { - if (frag->parse_content_length) { - header_buf_append(frag, c); - } - if (header_writable(frag)) { - ecs_strbuf_appendch(&frag->buf, c); - } - } - break; - case HttpFragStateCR: - if (c == '\n') { - frag->state = HttpFragStateCRLF; - } else { - frag->state = HttpFragStateHeaderStart; - } - break; - case HttpFragStateCRLF: - if (c == '\r') { - frag->state = HttpFragStateCRLFCR; - } else { - frag->state = HttpFragStateHeaderStart; - i--; - } - break; - case HttpFragStateCRLFCR: - if (c == '\n') { - if (frag->content_length != 0) { - frag->body_offset = ecs_strbuf_written(&frag->buf); - frag->state = HttpFragStateBody; - } else { - frag->state = HttpFragStateDone; - } - } else { - frag->state = HttpFragStateHeaderStart; - } - break; - case HttpFragStateBody: { - ecs_strbuf_appendch(&frag->buf, c); - if ((ecs_strbuf_written(&frag->buf) - frag->body_offset) == - frag->content_length) - { - frag->state = HttpFragStateDone; - } - } - break; - case HttpFragStateDone: + return t; +} + +ecs_entity_t ecs_struct_init( + ecs_world_t *world, + const ecs_struct_desc_t *desc) +{ + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } + + ecs_entity_t old_scope = ecs_set_scope(world, t); + + int i; + for (i = 0; i < ECS_MEMBER_DESC_CACHE_SIZE; i ++) { + const ecs_member_t *m_desc = &desc->members[i]; + if (!m_desc->type) { break; } + + if (!m_desc->name) { + ecs_err("member %d of struct '%s' does not have a name", i, + ecs_get_name(world, t)); + ecs_delete(world, t); + return 0; + } + + ecs_entity_t m = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = m_desc->name + }); + + ecs_set(world, m, EcsMember, { + .type = m_desc->type, + .count = m_desc->count, + .unit = m_desc->unit + }); } - if (frag->state == HttpFragStateDone) { - frag->state = HttpFragStateBegin; - if (conn->pub.id == conn_id) { - enqueue_request(conn); + ecs_set_scope(world, old_scope); + + if (i == 0) { + ecs_err("struct '%s' has no members", ecs_get_name(world, t)); + ecs_delete(world, t); + return 0; + } + + if (!ecs_has(world, t, EcsStruct)) { + /* Invalid members */ + ecs_delete(world, t); + return 0; + } + + return t; +} + +ecs_entity_t ecs_unit_init( + ecs_world_t *world, + const ecs_unit_desc_t *desc) +{ + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + goto error; + } + + ecs_entity_t quantity = desc->quantity; + if (quantity) { + if (!ecs_has_id(world, quantity, EcsQuantity)) { + ecs_err("entity '%s' for unit '%s' is not a quantity", + ecs_get_name(world, quantity), ecs_get_name(world, t)); + goto error; } - return true; + + ecs_add_pair(world, t, EcsQuantity, desc->quantity); } else { - return false; + ecs_remove_pair(world, t, EcsQuantity, EcsWildcard); + } + + EcsUnit *value = ecs_get_mut(world, t, EcsUnit, 0); + value->base = desc->base; + value->over = desc->over; + value->translation = desc->translation; + value->prefix = desc->prefix; + ecs_os_strset(&value->symbol, desc->symbol); + + if (!flecs_unit_validate(world, t, value)) { + goto error; + } + + ecs_modified(world, t, EcsUnit); + + return t; +error: + if (t) { + ecs_delete(world, t); } + return 0; } -static -void append_send_headers( - ecs_strbuf_t *hdrs, - int code, - const char* status, - const char* content_type, - ecs_strbuf_t *extra_headers, - ecs_size_t content_len) +ecs_entity_t ecs_unit_prefix_init( + ecs_world_t *world, + const ecs_unit_prefix_desc_t *desc) { - ecs_strbuf_appendstr(hdrs, "HTTP/1.1 "); - ecs_strbuf_append(hdrs, "%d ", code); - ecs_strbuf_appendstr(hdrs, status); - ecs_strbuf_appendstr(hdrs, "\r\n"); + ecs_entity_t t = ecs_entity_init(world, &desc->entity); + if (!t) { + return 0; + } - ecs_strbuf_appendstr(hdrs, "Content-Type: "); - ecs_strbuf_appendstr(hdrs, content_type); - ecs_strbuf_appendstr(hdrs, "\r\n"); + ecs_set(world, t, EcsUnitPrefix, { + .symbol = (char*)desc->symbol, + .translation = desc->translation + }); - ecs_strbuf_appendstr(hdrs, "Content-Length: "); - ecs_strbuf_append(hdrs, "%d", content_len); - ecs_strbuf_appendstr(hdrs, "\r\n"); + return t; +} - ecs_strbuf_appendstr(hdrs, "Server: flecs\r\n"); +ecs_entity_t ecs_quantity_init( + ecs_world_t *world, + const ecs_entity_desc_t *desc) +{ + ecs_entity_t t = ecs_entity_init(world, desc); + if (!t) { + return 0; + } - ecs_strbuf_mergebuff(hdrs, extra_headers); + ecs_add_id(world, t, EcsQuantity); - ecs_strbuf_appendstr(hdrs, "\r\n"); + return t; } -static -void send_reply( - ecs_http_connection_impl_t* conn, - ecs_http_reply_t* reply) -{ - char hdrs[ECS_HTTP_REPLY_HEADER_SIZE]; - ecs_strbuf_t hdr_buf = ECS_STRBUF_INIT; - hdr_buf.buf = hdrs; - hdr_buf.max = ECS_HTTP_REPLY_HEADER_SIZE; - hdr_buf.buf = hdrs; +#endif - char *content = ecs_strbuf_get(&reply->body); - int32_t content_length = reply->body.length - 1; - /* First, send the response HTTP headers */ - append_send_headers(&hdr_buf, reply->code, reply->status, - reply->content_type, &reply->headers, content_length); +#ifdef FLECS_MODULE - ecs_size_t hdrs_len = ecs_strbuf_written(&hdr_buf); - hdrs[hdrs_len] = '\0'; - ecs_size_t written = http_send(conn->sock, hdrs, hdrs_len, 0); +#include - if (written != hdrs_len) { - ecs_err("failed to write HTTP response headers to '%s:%s': %s", - conn->pub.host, conn->pub.port, ecs_os_strerror(errno)); - return; - } +char* ecs_module_path_from_c( + const char *c_name) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + const char *ptr; + char ch; - /* Second, send response body */ - if (content_length > 0) { - written = http_send(conn->sock, content, content_length, 0); - if (written != content_length) { - ecs_err("failed to write HTTP response body to '%s:%s': %s", - conn->pub.host, conn->pub.port, ecs_os_strerror(errno)); + for (ptr = c_name; (ch = *ptr); ptr++) { + if (isupper(ch)) { + ch = flecs_ito(char, tolower(ch)); + if (ptr != c_name) { + ecs_strbuf_appendstrn(&str, ".", 1); + } } + + ecs_strbuf_appendstrn(&str, &ch, 1); } + + return ecs_strbuf_get(&str); } -static -void recv_request( - ecs_http_server_t *srv, - ecs_http_connection_impl_t *conn, - uint64_t conn_id, - ecs_http_socket_t sock) +ecs_entity_t ecs_import( + ecs_world_t *world, + ecs_module_action_t init_action, + const char *module_name) { - ecs_size_t bytes_read; - char recv_buf[ECS_HTTP_SEND_RECV_BUFFER_SIZE]; + ecs_check(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); - while ((bytes_read = http_recv( - sock, recv_buf, ECS_SIZEOF(recv_buf), 0)) > 0) - { - ecs_os_mutex_lock(srv->lock); - bool is_alive = conn->pub.id == conn_id; - if (is_alive) { - conn->dequeue_timeout = 0; - conn->dequeue_retries = 0; - } - ecs_os_mutex_unlock(srv->lock); + ecs_entity_t old_scope = ecs_set_scope(world, 0); + const char *old_name_prefix = world->name_prefix; - if (is_alive) { - if (parse_request(conn, conn_id, recv_buf, bytes_read)) { - return; - } - } else { - return; - } + char *path = ecs_module_path_from_c(module_name); + ecs_entity_t e = ecs_lookup_fullpath(world, path); + ecs_os_free(path); + + if (!e) { + ecs_trace("#[magenta]import#[reset] %s", module_name); + ecs_log_push(); + + /* Load module */ + init_action(world); + + /* Lookup module entity (must be registered by module) */ + e = ecs_lookup_fullpath(world, module_name); + ecs_check(e != 0, ECS_MODULE_UNDEFINED, module_name); + + ecs_log_pop(); } + + /* Restore to previous state */ + ecs_set_scope(world, old_scope); + world->name_prefix = old_name_prefix; + + return e; +error: + return 0; } -static -void init_connection( - ecs_http_server_t *srv, - ecs_http_socket_t sock_conn, - struct sockaddr_storage *remote_addr, - ecs_size_t remote_addr_len) +ecs_entity_t ecs_import_from_library( + ecs_world_t *world, + const char *library_name, + const char *module_name) { - /* Create new connection */ - ecs_os_mutex_lock(srv->lock); - ecs_http_connection_impl_t *conn = flecs_sparse_add( - srv->connections, ecs_http_connection_impl_t); - uint64_t conn_id = conn->pub.id = flecs_sparse_last_id(srv->connections); - conn->pub.server = srv; - conn->sock = sock_conn; - ecs_os_mutex_unlock(srv->lock); + ecs_check(library_name != NULL, ECS_INVALID_PARAMETER, NULL); - char *remote_host = conn->pub.host; - char *remote_port = conn->pub.port; + char *import_func = (char*)module_name; /* safe */ + char *module = (char*)module_name; - /* Fetch name & port info */ - if (http_getnameinfo((struct sockaddr*) remote_addr, remote_addr_len, - remote_host, ECS_SIZEOF(conn->pub.host), - remote_port, ECS_SIZEOF(conn->pub.port), - NI_NUMERICHOST | NI_NUMERICSERV)) - { - ecs_os_strcpy(remote_host, "unknown"); - ecs_os_strcpy(remote_port, "unknown"); + if (!ecs_os_has_modules() || !ecs_os_has_dl()) { + ecs_err( + "library loading not supported, set module_to_dl, dlopen, dlclose " + "and dlproc os API callbacks first"); + return 0; } - ecs_dbg_2("http: connection established from '%s:%s'", - remote_host, remote_port); + /* If no module name is specified, try default naming convention for loading + * the main module from the library */ + if (!import_func) { + import_func = ecs_os_malloc(ecs_os_strlen(library_name) + ECS_SIZEOF("Import")); + ecs_assert(import_func != NULL, ECS_OUT_OF_MEMORY, NULL); + + const char *ptr; + char ch, *bptr = import_func; + bool capitalize = true; + for (ptr = library_name; (ch = *ptr); ptr ++) { + if (ch == '.') { + capitalize = true; + } else { + if (capitalize) { + *bptr = flecs_ito(char, toupper(ch)); + bptr ++; + capitalize = false; + } else { + *bptr = flecs_ito(char, tolower(ch)); + bptr ++; + } + } + } - recv_request(srv, conn, conn_id, sock_conn); + *bptr = '\0'; - ecs_dbg_2("http: request received from '%s:%s'", - remote_host, remote_port); + module = ecs_os_strdup(import_func); + ecs_assert(module != NULL, ECS_OUT_OF_MEMORY, NULL); + + ecs_os_strcat(bptr, "Import"); + } + + char *library_filename = ecs_os_module_to_dl(library_name); + if (!library_filename) { + ecs_err("failed to find library file for '%s'", library_name); + if (module != module_name) { + ecs_os_free(module); + } + return 0; + } else { + ecs_trace("found file '%s' for library '%s'", + library_filename, library_name); + } + + ecs_os_dl_t dl = ecs_os_dlopen(library_filename); + if (!dl) { + ecs_err("failed to load library '%s' ('%s')", + library_name, library_filename); + + ecs_os_free(library_filename); + + if (module != module_name) { + ecs_os_free(module); + } + + return 0; + } else { + ecs_trace("library '%s' ('%s') loaded", + library_name, library_filename); + } + + ecs_module_action_t action = (ecs_module_action_t) + ecs_os_dlproc(dl, import_func); + if (!action) { + ecs_err("failed to load import function %s from library %s", + import_func, library_name); + ecs_os_free(library_filename); + ecs_os_dlclose(dl); + return 0; + } else { + ecs_trace("found import function '%s' in library '%s' for module '%s'", + import_func, library_name, module); + } + + /* Do not free id, as it will be stored as the component identifier */ + ecs_entity_t result = ecs_import(world, action, module); + + if (import_func != module_name) { + ecs_os_free(import_func); + } + + if (module != module_name) { + ecs_os_free(module); + } + + ecs_os_free(library_filename); + + return result; +error: + return 0; } -static -void accept_connections( - ecs_http_server_t* srv, - const struct sockaddr* addr, - ecs_size_t addr_len) +ecs_entity_t ecs_module_init( + ecs_world_t *world, + const ecs_component_desc_t *desc) { -#ifdef ECS_TARGET_WINDOWS - /* If on Windows, test if winsock needs to be initialized */ - SOCKET testsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); - if (SOCKET_ERROR == testsocket && WSANOTINITIALISED == WSAGetLastError()) { - WSADATA data = { 0 }; - int result = WSAStartup(MAKEWORD(2, 2), &data); - if (result) { - ecs_warn("WSAStartup failed with GetLastError = %d\n", - GetLastError()); - return; - } + ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_poly_assert(world, ecs_world_t); + + const char *name = desc->entity.name; + + char *module_path = ecs_module_path_from_c(name); + ecs_entity_t e = ecs_new_from_fullpath(world, module_path); + ecs_set_symbol(world, e, module_path); + ecs_os_free(module_path); + + ecs_component_desc_t private_desc = *desc; + private_desc.entity.entity = e; + private_desc.entity.name = NULL; + + if (desc->size) { + ecs_entity_t result = ecs_component_init(world, &private_desc); + ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL); + (void)result; } else { - http_close(testsocket); + ecs_entity_t result = ecs_entity_init(world, &private_desc.entity); + ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(result == e, ECS_INTERNAL_ERROR, NULL); + (void)result; } + + return e; +error: + return 0; +} + #endif - /* Resolve name + port (used for logging) */ - char addr_host[256]; - char addr_port[20]; - if (http_getnameinfo( - addr, addr_len, addr_host, ECS_SIZEOF(addr_host), addr_port, - ECS_SIZEOF(addr_port), NI_NUMERICHOST | NI_NUMERICSERV)) - { - ecs_os_strcpy(addr_host, "unknown"); - ecs_os_strcpy(addr_port, "unknown"); - } +#ifdef FLECS_META_C - ecs_os_mutex_lock(srv->lock); - if (srv->should_run) { - ecs_dbg_2("http: initializing connection socket"); - - srv->sock = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP); - if (srv->sock < 0) { - ecs_err("unable to create new connection socket: %s", - ecs_os_strerror(errno)); - ecs_os_mutex_unlock(srv->lock); - goto done; - } +#include - int reuse = 1; - int result = setsockopt(srv->sock, SOL_SOCKET, SO_REUSEADDR, - (char*)&reuse, ECS_SIZEOF(reuse)); - if (result) { - ecs_warn("failed to setsockopt: %s", ecs_os_strerror(errno)); - } +#define ECS_META_IDENTIFIER_LENGTH (256) - if (addr->sa_family == AF_INET6) { - int ipv6only = 0; - if (setsockopt(srv->sock, IPPROTO_IPV6, IPV6_V6ONLY, - (char*)&ipv6only, ECS_SIZEOF(ipv6only))) +#define ecs_meta_error(ctx, ptr, ...)\ + ecs_parser_error((ctx)->name, (ctx)->desc, ptr - (ctx)->desc, __VA_ARGS__); + +typedef char ecs_meta_token_t[ECS_META_IDENTIFIER_LENGTH]; + +typedef struct meta_parse_ctx_t { + const char *name; + const char *desc; +} meta_parse_ctx_t; + +typedef struct meta_type_t { + ecs_meta_token_t type; + ecs_meta_token_t params; + bool is_const; + bool is_ptr; +} meta_type_t; + +typedef struct meta_member_t { + meta_type_t type; + ecs_meta_token_t name; + int64_t count; + bool is_partial; +} meta_member_t; + +typedef struct meta_constant_t { + ecs_meta_token_t name; + int64_t value; + bool is_value_set; +} meta_constant_t; + +typedef struct meta_params_t { + meta_type_t key_type; + meta_type_t type; + int64_t count; + bool is_key_value; + bool is_fixed_size; +} meta_params_t; + +static +const char* skip_scope(const char *ptr, meta_parse_ctx_t *ctx) { + /* Keep track of which characters were used to open the scope */ + char stack[256]; + int32_t sp = 0; + char ch; + + while ((ch = *ptr)) { + if (ch == '(' || ch == '<') { + stack[sp] = ch; + + sp ++; + if (sp >= 256) { + ecs_meta_error(ctx, ptr, "maximum level of nesting reached"); + goto error; + } + } else if (ch == ')' || ch == '>') { + sp --; + if ((sp < 0) || (ch == '>' && stack[sp] != '<') || + (ch == ')' && stack[sp] != '(')) { - ecs_warn("failed to setsockopt: %s", ecs_os_strerror(errno)); + ecs_meta_error(ctx, ptr, "mismatching %c in identifier", ch); + goto error; } } - - result = http_bind(srv->sock, addr, addr_len); - if (result) { - ecs_err("http: failed to bind to '%s:%s': %s", - addr_host, addr_port, ecs_os_strerror(errno)); - ecs_os_mutex_unlock(srv->lock); - goto done; - } - result = listen(srv->sock, SOMAXCONN); - if (result) { - ecs_warn("http: could not listen for SOMAXCONN (%d) connections: %s", - SOMAXCONN, ecs_os_strerror(errno)); + ptr ++; + + if (!sp) { + break; } + } - ecs_trace("http: listening for incoming connections on '%s:%s'", - addr_host, addr_port); + return ptr; +error: + return NULL; +} + +static +const char* parse_c_digit( + const char *ptr, + int64_t *value_out) +{ + char token[24]; + ptr = ecs_parse_eol_and_whitespace(ptr); + ptr = ecs_parse_digit(ptr, token); + if (!ptr) { + goto error; } - ecs_os_mutex_unlock(srv->lock); - ecs_http_socket_t sock_conn; - struct sockaddr_storage remote_addr; - ecs_size_t remote_addr_len; + *value_out = strtol(token, NULL, 0); - while (srv->should_run) { - remote_addr_len = ECS_SIZEOF(remote_addr); - sock_conn = http_accept(srv->sock, (struct sockaddr*) &remote_addr, - &remote_addr_len); + return ecs_parse_eol_and_whitespace(ptr); +error: + return NULL; +} - if (sock_conn == -1) { - if (srv->should_run) { - ecs_dbg("http: connection attempt failed: %s", - ecs_os_strerror(errno)); - } - continue; - } +static +const char* parse_c_identifier( + const char *ptr, + char *buff, + char *params, + meta_parse_ctx_t *ctx) +{ + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(buff != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL); - init_connection(srv, sock_conn, &remote_addr, remote_addr_len); + char *bptr = buff, ch; + + if (params) { + params[0] = '\0'; } -done: - if (srv->sock && errno != EBADF) { - http_close(srv->sock); - srv->sock = 0; + /* Ignore whitespaces */ + ptr = ecs_parse_eol_and_whitespace(ptr); + + if (!isalpha(*ptr)) { + ecs_meta_error(ctx, ptr, + "invalid identifier (starts with '%c')", *ptr); + goto error; } - ecs_trace("http: no longer accepting connections on '%s:%s'", - addr_host, addr_port); -} + while ((ch = *ptr) && !isspace(ch) && ch != ';' && ch != ',' && ch != ')' && ch != '>' && ch != '}') { + /* Type definitions can contain macro's or templates */ + if (ch == '(' || ch == '<') { + if (!params) { + ecs_meta_error(ctx, ptr, "unexpected %c", *ptr); + goto error; + } -static -void* http_server_thread(void* arg) { - ecs_http_server_t *srv = arg; - struct sockaddr_in addr; - ecs_os_zeromem(&addr); - addr.sin_family = AF_INET; - addr.sin_port = htons(srv->port); + const char *end = skip_scope(ptr, ctx); + ecs_os_strncpy(params, ptr, (ecs_size_t)(end - ptr)); + params[end - ptr] = '\0'; - if (!srv->ipaddr) { - addr.sin_addr.s_addr = htonl(INADDR_ANY); - } else { - inet_pton(AF_INET, srv->ipaddr, &(addr.sin_addr)); + ptr = end; + } else { + *bptr = ch; + bptr ++; + ptr ++; + } } - accept_connections(srv, (struct sockaddr*)&addr, ECS_SIZEOF(addr)); + *bptr = '\0'; + + if (!ch) { + ecs_meta_error(ctx, ptr, "unexpected end of token"); + goto error; + } + + return ptr; +error: return NULL; } static -void handle_request( - ecs_http_server_t *srv, - ecs_http_request_impl_t *req) +const char * meta_open_scope( + const char *ptr, + meta_parse_ctx_t *ctx) { - ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT; - ecs_http_connection_impl_t *conn = - (ecs_http_connection_impl_t*)req->pub.conn; + /* Skip initial whitespaces */ + ptr = ecs_parse_eol_and_whitespace(ptr); - if (srv->callback((ecs_http_request_t*)req, &reply, srv->ctx) == 0) { - reply.code = 404; - reply.status = "Resource not found"; + /* Is this the start of the type definition? */ + if (ctx->desc == ptr) { + if (*ptr != '{') { + ecs_meta_error(ctx, ptr, "missing '{' in struct definition"); + goto error; + } + + ptr ++; + ptr = ecs_parse_eol_and_whitespace(ptr); } - send_reply(conn, &reply); - ecs_dbg_2("http: reply sent to '%s:%s'", conn->pub.host, conn->pub.port); + /* Is this the end of the type definition? */ + if (!*ptr) { + ecs_meta_error(ctx, ptr, "missing '}' at end of struct definition"); + goto error; + } - reply_free(&reply); - request_free(req); - connection_free(conn); + /* Is this the end of the type definition? */ + if (*ptr == '}') { + ptr = ecs_parse_eol_and_whitespace(ptr + 1); + if (*ptr) { + ecs_meta_error(ctx, ptr, + "stray characters after struct definition"); + goto error; + } + return NULL; + } + + return ptr; +error: + return NULL; } static -int32_t dequeue_requests( - ecs_http_server_t *srv, - float delta_time) -{ - ecs_os_mutex_lock(srv->lock); - - int32_t i, request_count = flecs_sparse_count(srv->requests); - for (i = request_count - 1; i >= 1; i --) { - ecs_http_request_impl_t *req = flecs_sparse_get_dense( - srv->requests, ecs_http_request_impl_t, i); - handle_request(srv, req); +const char* meta_parse_constant( + const char *ptr, + meta_constant_t *token, + meta_parse_ctx_t *ctx) +{ + ptr = meta_open_scope(ptr, ctx); + if (!ptr) { + return NULL; } - int32_t connections_count = flecs_sparse_count(srv->connections); - for (i = connections_count - 1; i >= 1; i --) { - ecs_http_connection_impl_t *conn = flecs_sparse_get_dense( - srv->connections, ecs_http_connection_impl_t, i); + token->is_value_set = false; - conn->dequeue_timeout += delta_time; - conn->dequeue_retries ++; - - if ((conn->dequeue_timeout > - (FLECS_FLOAT)ECS_HTTP_CONNECTION_PURGE_TIMEOUT) && - (conn->dequeue_retries > ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT)) - { - ecs_dbg("http: purging connection '%s:%s' (sock = %d)", - conn->pub.host, conn->pub.port, conn->sock); - connection_free(conn); - } + /* Parse token, constant identifier */ + ptr = parse_c_identifier(ptr, token->name, NULL, ctx); + if (!ptr) { + return NULL; } - ecs_os_mutex_unlock(srv->lock); + ptr = ecs_parse_eol_and_whitespace(ptr); + if (!ptr) { + return NULL; + } - return request_count; -} + /* Explicit value assignment */ + if (*ptr == '=') { + int64_t value = 0; + ptr = parse_c_digit(ptr + 1, &value); + token->value = value; + token->is_value_set = true; + } -const char* ecs_http_get_header( - const ecs_http_request_t* req, - const char* name) -{ - for (ecs_size_t i = 0; i < req->header_count; i++) { - if (!ecs_os_strcmp(req->headers[i].key, name)) { - return req->headers[i].value; - } + /* Expect a ',' or '}' */ + if (*ptr != ',' && *ptr != '}') { + ecs_meta_error(ctx, ptr, "missing , after enum constant"); + goto error; } - return NULL; -} -const char* ecs_http_get_param( - const ecs_http_request_t* req, - const char* name) -{ - for (ecs_size_t i = 0; i < req->param_count; i++) { - if (!ecs_os_strcmp(req->params[i].key, name)) { - return req->params[i].value; - } + if (*ptr == ',') { + return ptr + 1; + } else { + return ptr; } +error: return NULL; } -ecs_http_server_t* ecs_http_server_init( - const ecs_http_server_desc_t *desc) +static +const char* meta_parse_type( + const char *ptr, + meta_type_t *token, + meta_parse_ctx_t *ctx) { - ecs_check(ecs_os_has_threading(), ECS_UNSUPPORTED, - "missing OS API implementation"); + token->is_ptr = false; + token->is_const = false; - ecs_http_server_t* srv = ecs_os_calloc_t(ecs_http_server_t); - srv->lock = ecs_os_mutex_new(); + ptr = ecs_parse_eol_and_whitespace(ptr); - srv->should_run = false; - srv->initialized = true; + /* Parse token, expect type identifier or ECS_PROPERTY */ + ptr = parse_c_identifier(ptr, token->type, token->params, ctx); + if (!ptr) { + goto error; + } - srv->callback = desc->callback; - srv->ctx = desc->ctx; - srv->port = desc->port; - srv->ipaddr = desc->ipaddr; + if (!strcmp(token->type, "ECS_PRIVATE")) { + /* Members from this point are not stored in metadata */ + ptr += ecs_os_strlen(ptr); + goto done; + } - srv->connections = flecs_sparse_new(ecs_http_connection_impl_t); - srv->requests = flecs_sparse_new(ecs_http_request_impl_t); + /* If token is const, set const flag and continue parsing type */ + if (!strcmp(token->type, "const")) { + token->is_const = true; - /* Start at id 1 */ - flecs_sparse_new_id(srv->connections); - flecs_sparse_new_id(srv->requests); + /* Parse type after const */ + ptr = parse_c_identifier(ptr + 1, token->type, token->params, ctx); + } -#ifndef ECS_TARGET_WINDOWS - /* Ignore pipe signal. SIGPIPE can occur when a message is sent to a client - * but te client already disconnected. */ - signal(SIGPIPE, SIG_IGN); -#endif + /* Check if type is a pointer */ + ptr = ecs_parse_eol_and_whitespace(ptr); + if (*ptr == '*') { + token->is_ptr = true; + ptr ++; + } - return srv; +done: + return ptr; error: return NULL; } -void ecs_http_server_fini( - ecs_http_server_t* srv) +static +const char* meta_parse_member( + const char *ptr, + meta_member_t *token, + meta_parse_ctx_t *ctx) { - if (srv->should_run) { - ecs_http_server_stop(srv); + ptr = meta_open_scope(ptr, ctx); + if (!ptr) { + return NULL; } - ecs_os_mutex_free(srv->lock); - flecs_sparse_free(srv->connections); - flecs_sparse_free(srv->requests); - ecs_os_free(srv); -} -int ecs_http_server_start( - ecs_http_server_t *srv) -{ - ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL); - ecs_check(!srv->should_run, ECS_INVALID_PARAMETER, NULL); - ecs_check(!srv->thread, ECS_INVALID_PARAMETER, NULL); + token->count = 1; + token->is_partial = false; - srv->should_run = true; + /* Parse member type */ + ptr = meta_parse_type(ptr, &token->type, ctx); + if (!ptr) { + token->is_partial = true; + goto error; + } - ecs_dbg("http: starting server thread"); + /* Next token is the identifier */ + ptr = parse_c_identifier(ptr, token->name, NULL, ctx); + if (!ptr) { + goto error; + } - srv->thread = ecs_os_thread_new(http_server_thread, srv); - if (!srv->thread) { + /* Skip whitespace between member and [ or ; */ + ptr = ecs_parse_eol_and_whitespace(ptr); + + /* Check if this is an array */ + char *array_start = strchr(token->name, '['); + if (!array_start) { + /* If the [ was separated by a space, it will not be parsed as part of + * the name */ + if (*ptr == '[') { + array_start = (char*)ptr; /* safe, will not be modified */ + } + } + + if (array_start) { + /* Check if the [ matches with a ] */ + char *array_end = strchr(array_start, ']'); + if (!array_end) { + ecs_meta_error(ctx, ptr, "missing ']'"); + goto error; + + } else if (array_end - array_start == 0) { + ecs_meta_error(ctx, ptr, "dynamic size arrays are not supported"); + goto error; + } + + token->count = atoi(array_start + 1); + + if (array_start == ptr) { + /* If [ was found after name, continue parsing after ] */ + ptr = array_end + 1; + } else { + /* If [ was fonud in name, replace it with 0 terminator */ + array_start[0] = '\0'; + } + } + + /* Expect a ; */ + if (*ptr != ';') { + ecs_meta_error(ctx, ptr, "missing ; after member declaration"); goto error; } - return 0; + return ptr + 1; error: - return -1; + return NULL; } -void ecs_http_server_stop( - ecs_http_server_t* srv) +static +int meta_parse_desc( + const char *ptr, + meta_params_t *token, + meta_parse_ctx_t *ctx) { - ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(srv->initialized, ECS_INVALID_OPERATION, NULL); - ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL); + token->is_key_value = false; + token->is_fixed_size = false; - /* Stop server thread */ - ecs_dbg("http: shutting down server thread"); + ptr = ecs_parse_eol_and_whitespace(ptr); + if (*ptr != '(' && *ptr != '<') { + ecs_meta_error(ctx, ptr, + "expected '(' at start of collection definition"); + goto error; + } - ecs_os_mutex_lock(srv->lock); - srv->should_run = false; - if (srv->sock >= 0) { - http_close(srv->sock); + ptr ++; + + /* Parse type identifier */ + ptr = meta_parse_type(ptr, &token->type, ctx); + if (!ptr) { + goto error; } - ecs_os_mutex_unlock(srv->lock); - ecs_os_thread_join(srv->thread); + ptr = ecs_parse_eol_and_whitespace(ptr); - ecs_trace("http: server thread shut down"); + /* If next token is a ',' the first type was a key type */ + if (*ptr == ',') { + ptr = ecs_parse_eol_and_whitespace(ptr + 1); + + if (isdigit(*ptr)) { + int64_t value; + ptr = parse_c_digit(ptr, &value); + if (!ptr) { + goto error; + } - /* Cleanup all outstanding requests */ - int i, count = flecs_sparse_count(srv->requests); - for (i = count - 1; i >= 1; i --) { - request_free(flecs_sparse_get_dense( - srv->requests, ecs_http_request_impl_t, i)); - } + token->count = value; + token->is_fixed_size = true; + } else { + token->key_type = token->type; - /* Close all connections */ - count = flecs_sparse_count(srv->connections); - for (i = count - 1; i >= 1; i --) { - connection_free(flecs_sparse_get_dense( - srv->connections, ecs_http_connection_impl_t, i)); + /* Parse element type */ + ptr = meta_parse_type(ptr, &token->type, ctx); + ptr = ecs_parse_eol_and_whitespace(ptr); + + token->is_key_value = true; + } } - ecs_assert(flecs_sparse_count(srv->connections) == 1, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(flecs_sparse_count(srv->requests) == 1, - ECS_INTERNAL_ERROR, NULL); + if (*ptr != ')' && *ptr != '>') { + ecs_meta_error(ctx, ptr, + "expected ')' at end of collection definition"); + goto error; + } - srv->thread = 0; + return 0; error: - return; + return -1; } -void ecs_http_server_dequeue( - ecs_http_server_t* srv, - float delta_time) -{ - ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL); - ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL); - - srv->dequeue_timeout += delta_time; - srv->stats_timeout += delta_time; +static +ecs_entity_t meta_lookup( + ecs_world_t *world, + meta_type_t *token, + const char *ptr, + int64_t count, + meta_parse_ctx_t *ctx); - if ((1000 * srv->dequeue_timeout) > - (FLECS_FLOAT)ECS_HTTP_MIN_DEQUEUE_INTERVAL) - { - srv->dequeue_timeout = 0; +static +ecs_entity_t meta_lookup_array( + ecs_world_t *world, + ecs_entity_t e, + const char *params_decl, + meta_parse_ctx_t *ctx) +{ + meta_parse_ctx_t param_ctx = { + .name = ctx->name, + .desc = params_decl + }; - ecs_time_t t = {0}; - ecs_time_measure(&t); - int32_t request_count = dequeue_requests(srv, srv->dequeue_timeout); - srv->requests_processed += request_count; - srv->requests_processed_total += request_count; - FLECS_FLOAT time_spent = (FLECS_FLOAT)ecs_time_measure(&t); - srv->request_time += time_spent; - srv->request_time_total += time_spent; - srv->dequeue_count ++; + meta_params_t params; + if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { + goto error; + } + if (!params.is_fixed_size) { + ecs_meta_error(ctx, params_decl, "missing size for array"); + goto error; } - if ((1000 * srv->stats_timeout) > - (FLECS_FLOAT)ECS_HTTP_MIN_STATS_INTERVAL) - { - srv->stats_timeout = 0; - ecs_dbg("http: processed %d requests in %.3fs (avg %.3fs / dequeue)", - srv->requests_processed, (double)srv->request_time, - (double)(srv->request_time / (FLECS_FLOAT)srv->dequeue_count)); - srv->requests_processed = 0; - srv->request_time = 0; - srv->dequeue_count = 0; + if (!params.count) { + ecs_meta_error(ctx, params_decl, "invalid array size"); + goto error; } -error: - return; -} - -#endif + ecs_entity_t element_type = ecs_lookup_symbol(world, params.type.type, true); + if (!element_type) { + ecs_meta_error(ctx, params_decl, "unknown element type '%s'", + params.type.type); + } + if (!e) { + e = ecs_new_id(world); + } + ecs_check(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL); -#ifdef FLECS_DOC + return ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count }); +error: + return 0; +} -static ECS_COPY(EcsDocDescription, dst, src, { - ecs_os_strset((char**)&dst->value, src->value); +static +ecs_entity_t meta_lookup_vector( + ecs_world_t *world, + ecs_entity_t e, + const char *params_decl, + meta_parse_ctx_t *ctx) +{ + meta_parse_ctx_t param_ctx = { + .name = ctx->name, + .desc = params_decl + }; -}) + meta_params_t params; + if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { + goto error; + } -static ECS_MOVE(EcsDocDescription, dst, src, { - ecs_os_free((char*)dst->value); - dst->value = src->value; - src->value = NULL; -}) + if (params.is_key_value) { + ecs_meta_error(ctx, params_decl, + "unexpected key value parameters for vector"); + goto error; + } -static ECS_DTOR(EcsDocDescription, ptr, { - ecs_os_free((char*)ptr->value); -}) + ecs_entity_t element_type = meta_lookup( + world, ¶ms.type, params_decl, 1, ¶m_ctx); -void ecs_doc_set_name( - ecs_world_t *world, - ecs_entity_t entity, - const char *name) -{ - ecs_set_pair(world, entity, EcsDocDescription, EcsName, { - .value = name - }); -} + if (!e) { + e = ecs_new_id(world); + } -void ecs_doc_set_brief( - ecs_world_t *world, - ecs_entity_t entity, - const char *description) -{ - ecs_set_pair(world, entity, EcsDocDescription, EcsDocBrief, { - .value = description - }); + return ecs_set(world, e, EcsVector, { element_type }); +error: + return 0; } -void ecs_doc_set_detail( +static +ecs_entity_t meta_lookup_bitmask( ecs_world_t *world, - ecs_entity_t entity, - const char *description) + ecs_entity_t e, + const char *params_decl, + meta_parse_ctx_t *ctx) { - ecs_set_pair(world, entity, EcsDocDescription, EcsDocDetail, { - .value = description - }); -} + (void)e; -void ecs_doc_set_link( - ecs_world_t *world, - ecs_entity_t entity, - const char *link) -{ - ecs_set_pair(world, entity, EcsDocDescription, EcsDocLink, { - .value = link - }); -} + meta_parse_ctx_t param_ctx = { + .name = ctx->name, + .desc = params_decl + }; -const char* ecs_doc_get_name( - const ecs_world_t *world, - ecs_entity_t entity) -{ - EcsDocDescription *ptr = ecs_get_pair( - world, entity, EcsDocDescription, EcsName); - if (ptr) { - return ptr->value; - } else { - return ecs_get_name(world, entity); + meta_params_t params; + if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { + goto error; } -} -const char* ecs_doc_get_brief( - const ecs_world_t *world, - ecs_entity_t entity) -{ - EcsDocDescription *ptr = ecs_get_pair( - world, entity, EcsDocDescription, EcsDocBrief); - if (ptr) { - return ptr->value; - } else { - return NULL; + if (params.is_key_value) { + ecs_meta_error(ctx, params_decl, + "unexpected key value parameters for bitmask"); + goto error; } -} -const char* ecs_doc_get_detail( - const ecs_world_t *world, - ecs_entity_t entity) -{ - EcsDocDescription *ptr = ecs_get_pair( - world, entity, EcsDocDescription, EcsDocDetail); - if (ptr) { - return ptr->value; - } else { - return NULL; + if (params.is_fixed_size) { + ecs_meta_error(ctx, params_decl, + "unexpected size for bitmask"); + goto error; } -} -const char* ecs_doc_get_link( - const ecs_world_t *world, - ecs_entity_t entity) -{ - EcsDocDescription *ptr = ecs_get_pair( - world, entity, EcsDocDescription, EcsDocLink); - if (ptr) { - return ptr->value; - } else { - return NULL; - } -} + ecs_entity_t bitmask_type = meta_lookup( + world, ¶ms.type, params_decl, 1, ¶m_ctx); + ecs_check(bitmask_type != 0, ECS_INVALID_PARAMETER, NULL); -void FlecsDocImport( - ecs_world_t *world) -{ - ECS_MODULE(world, FlecsDoc); +#ifndef FLECS_NDEBUG + /* Make sure this is a bitmask type */ + const EcsMetaType *type_ptr = ecs_get(world, bitmask_type, EcsMetaType); + ecs_check(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL); +#endif - ecs_set_name_prefix(world, "EcsDoc"); + return bitmask_type; +error: + return 0; +} - flecs_bootstrap_component(world, EcsDocDescription); - flecs_bootstrap_tag(world, EcsDocBrief); - flecs_bootstrap_tag(world, EcsDocDetail); - flecs_bootstrap_tag(world, EcsDocLink); +static +ecs_entity_t meta_lookup( + ecs_world_t *world, + meta_type_t *token, + const char *ptr, + int64_t count, + meta_parse_ctx_t *ctx) +{ + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(token != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_set_component_actions(world, EcsDocDescription, { - .ctor = ecs_default_ctor, - .move = ecs_move(EcsDocDescription), - .copy = ecs_copy(EcsDocDescription), - .dtor = ecs_dtor(EcsDocDescription) - }); + const char *typename = token->type; + ecs_entity_t type = 0; - ecs_add_id(world, ecs_id(EcsDocDescription), EcsDontInherit); -} + /* Parse vector type */ + if (!token->is_ptr) { + if (!ecs_os_strcmp(typename, "ecs_array")) { + type = meta_lookup_array(world, 0, token->params, ctx); -#endif + } else if (!ecs_os_strcmp(typename, "ecs_vector") || + !ecs_os_strcmp(typename, "flecs::vector")) + { + type = meta_lookup_vector(world, 0, token->params, ctx); + } else if (!ecs_os_strcmp(typename, "flecs::bitmask")) { + type = meta_lookup_bitmask(world, 0, token->params, ctx); -#ifdef FLECS_PARSER + } else if (!ecs_os_strcmp(typename, "flecs::byte")) { + type = ecs_id(ecs_byte_t); -#include + } else if (!ecs_os_strcmp(typename, "char")) { + type = ecs_id(ecs_char_t); -#define ECS_ANNOTATION_LENGTH_MAX (16) + } else if (!ecs_os_strcmp(typename, "bool") || + !ecs_os_strcmp(typename, "_Bool")) + { + type = ecs_id(ecs_bool_t); -#define TOK_NEWLINE '\n' -#define TOK_COLON ':' -#define TOK_AND ',' -#define TOK_OR "||" -#define TOK_NOT '!' -#define TOK_OPTIONAL '?' -#define TOK_BITWISE_OR '|' -#define TOK_NAME_SEP '.' -#define TOK_BRACKET_OPEN '[' -#define TOK_BRACKET_CLOSE ']' -#define TOK_WILDCARD '*' -#define TOK_SINGLETON '$' -#define TOK_PAREN_OPEN '(' -#define TOK_PAREN_CLOSE ')' -#define TOK_AS_ENTITY '\\' + } else if (!ecs_os_strcmp(typename, "int8_t")) { + type = ecs_id(ecs_i8_t); + } else if (!ecs_os_strcmp(typename, "int16_t")) { + type = ecs_id(ecs_i16_t); + } else if (!ecs_os_strcmp(typename, "int32_t")) { + type = ecs_id(ecs_i32_t); + } else if (!ecs_os_strcmp(typename, "int64_t")) { + type = ecs_id(ecs_i64_t); -#define TOK_SELF "self" -#define TOK_SUPERSET "super" -#define TOK_SUBSET "sub" -#define TOK_CASCADE "cascade" -#define TOK_PARENT "parent" -#define TOK_ALL "all" + } else if (!ecs_os_strcmp(typename, "uint8_t")) { + type = ecs_id(ecs_u8_t); + } else if (!ecs_os_strcmp(typename, "uint16_t")) { + type = ecs_id(ecs_u16_t); + } else if (!ecs_os_strcmp(typename, "uint32_t")) { + type = ecs_id(ecs_u32_t); + } else if (!ecs_os_strcmp(typename, "uint64_t")) { + type = ecs_id(ecs_u64_t); -#define TOK_OVERRIDE "OVERRIDE" + } else if (!ecs_os_strcmp(typename, "float")) { + type = ecs_id(ecs_f32_t); + } else if (!ecs_os_strcmp(typename, "double")) { + type = ecs_id(ecs_f64_t); -#define TOK_ROLE_PAIR "PAIR" -#define TOK_ROLE_AND "AND" -#define TOK_ROLE_OR "OR" -#define TOK_ROLE_XOR "XOR" -#define TOK_ROLE_NOT "NOT" -#define TOK_ROLE_SWITCH "SWITCH" -#define TOK_ROLE_CASE "CASE" -#define TOK_ROLE_DISABLED "DISABLED" + } else if (!ecs_os_strcmp(typename, "ecs_entity_t")) { + type = ecs_id(ecs_entity_t); -#define TOK_IN "in" -#define TOK_OUT "out" -#define TOK_INOUT "inout" -#define TOK_INOUT_FILTER "filter" + } else if (!ecs_os_strcmp(typename, "char*")) { + type = ecs_id(ecs_string_t); + } else { + type = ecs_lookup_symbol(world, typename, true); + } + } else { + if (!ecs_os_strcmp(typename, "char")) { + typename = "flecs.meta.string"; + } else + if (token->is_ptr) { + typename = "flecs.meta.uptr"; + } else + if (!ecs_os_strcmp(typename, "char*") || + !ecs_os_strcmp(typename, "flecs::string")) + { + typename = "flecs.meta.string"; + } -#define ECS_MAX_TOKEN_SIZE (256) + type = ecs_lookup_symbol(world, typename, true); + } -typedef char ecs_token_t[ECS_MAX_TOKEN_SIZE]; + if (count != 1) { + ecs_check(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL); -const char* ecs_parse_eol_and_whitespace( - const char *ptr) -{ - while (isspace(*ptr)) { - ptr ++; + type = ecs_set(world, 0, EcsArray, {type, (int32_t)count}); } - return ptr; -} - -/** Skip spaces when parsing signature */ -const char* ecs_parse_whitespace( - const char *ptr) -{ - while ((*ptr != '\n') && isspace(*ptr)) { - ptr ++; + if (!type) { + ecs_meta_error(ctx, ptr, "unknown type '%s'", typename); + goto error; } - return ptr; + return type; +error: + return 0; } -const char* ecs_parse_digit( - const char *ptr, - char *token) +static +int meta_parse_struct( + ecs_world_t *world, + ecs_entity_t t, + const char *desc) { - char *tptr = token; - char ch = ptr[0]; + const char *ptr = desc; + const char *name = ecs_get_name(world, t); - if (!isdigit(ch) && ch != '-') { - ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr); - return NULL; - } + meta_member_t token; + meta_parse_ctx_t ctx = { + .name = name, + .desc = ptr + }; - tptr[0] = ch; - tptr ++; - ptr ++; + ecs_entity_t old_scope = ecs_set_scope(world, t); - for (; (ch = *ptr); ptr ++) { - if (!isdigit(ch)) { - break; + while ((ptr = meta_parse_member(ptr, &token, &ctx)) && ptr[0]) { + ecs_entity_t m = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = token.name + }); + + ecs_entity_t type = meta_lookup( + world, &token.type, ptr, 1, &ctx); + if (!type) { + goto error; } - tptr[0] = ch; - tptr ++; + ecs_set(world, m, EcsMember, { + .type = type, + .count = (ecs_size_t)token.count + }); } - tptr[0] = '\0'; - - return ptr; + ecs_set_scope(world, old_scope); + + return 0; +error: + return -1; } static -bool is_newline_comment( - const char *ptr) +int meta_parse_constants( + ecs_world_t *world, + ecs_entity_t t, + const char *desc, + bool is_bitmask) { - if (ptr[0] == '/' && ptr[1] == '/') { - return true; - } - return false; -} + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(t != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(desc != NULL, ECS_INTERNAL_ERROR, NULL); -const char* ecs_parse_fluff( - const char *ptr, - char **last_comment) -{ - const char *last_comment_start = NULL; + const char *ptr = desc; + const char *name = ecs_get_name(world, t); - do { - /* Skip whitespaces before checking for a comment */ - ptr = ecs_parse_whitespace(ptr); + meta_parse_ctx_t ctx = { + .name = name, + .desc = ptr + }; - /* Newline comment, skip until newline character */ - if (is_newline_comment(ptr)) { - ptr += 2; - last_comment_start = ptr; + meta_constant_t token; + int64_t last_value = 0; - while (ptr[0] && ptr[0] != TOK_NEWLINE) { - ptr ++; - } - } + ecs_entity_t old_scope = ecs_set_scope(world, t); - /* If a newline character is found, skip it */ - if (ptr[0] == TOK_NEWLINE) { - ptr ++; + while ((ptr = meta_parse_constant(ptr, &token, &ctx))) { + if (token.is_value_set) { + last_value = token.value; + } else if (is_bitmask) { + ecs_meta_error(&ctx, ptr, + "bitmask requires explicit value assignment"); + goto error; } - } while (isspace(ptr[0]) || is_newline_comment(ptr)); + ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = token.name + }); - if (last_comment) { - *last_comment = (char*)last_comment_start; + if (!is_bitmask) { + ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, + {(ecs_i32_t)last_value}); + } else { + ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, + {(ecs_u32_t)last_value}); + } + + last_value ++; } - return ptr; -} + ecs_set_scope(world, old_scope); -/* -- Private functions -- */ + return 0; +error: + return -1; +} static -bool valid_identifier_start_char( - char ch) +int meta_parse_enum( + ecs_world_t *world, + ecs_entity_t t, + const char *desc) { - if (ch && (isalpha(ch) || (ch == '.') || (ch == '_') || (ch == '*') || - (ch == '0') || (ch == TOK_AS_ENTITY) || isdigit(ch))) - { - return true; - } - - return false; + ecs_add(world, t, EcsEnum); + return meta_parse_constants(world, t, desc, false); } static -bool valid_token_start_char( - char ch) +int meta_parse_bitmask( + ecs_world_t *world, + ecs_entity_t t, + const char *desc) { - if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-') - || (ch == '[') || (ch == ']') || valid_identifier_start_char(ch)) - { - return true; + ecs_add(world, t, EcsBitmask); + return meta_parse_constants(world, t, desc, true); +} + +int ecs_meta_from_desc( + ecs_world_t *world, + ecs_entity_t component, + ecs_type_kind_t kind, + const char *desc) +{ + switch(kind) { + case EcsStructType: + if (meta_parse_struct(world, component, desc)) { + goto error; + } + break; + case EcsEnumType: + if (meta_parse_enum(world, component, desc)) { + goto error; + } + break; + case EcsBitmaskType: + if (meta_parse_bitmask(world, component, desc)) { + goto error; + } + break; + default: + break; } - return false; + return 0; +error: + return -1; } +#endif + + +#ifdef FLECS_LOG + +#include +#include + static -bool valid_token_char( - char ch) +char *ecs_vasprintf( + const char *fmt, + va_list args) { - if (ch && - (isalpha(ch) || isdigit(ch) || ch == '_' || ch == '.' || ch == '"')) - { - return true; + ecs_size_t size = 0; + char *result = NULL; + va_list tmpa; + + va_copy(tmpa, args); + + size = vsnprintf(result, 0, fmt, tmpa); + + va_end(tmpa); + + if ((int32_t)size < 0) { + return NULL; } - return false; -} + result = (char *) ecs_os_malloc(size + 1); -static -bool valid_operator_char( - char ch) -{ - if (ch == TOK_OPTIONAL || ch == TOK_NOT) { - return true; + if (!result) { + return NULL; } - return false; + ecs_os_vsprintf(result, fmt, args); + + return result; } static -const char* parse_digit( - const char *ptr, - char *token_out) +void ecs_colorize_buf( + char *msg, + bool enable_colors, + ecs_strbuf_t *buf) { - ptr = ecs_parse_whitespace(ptr); - ptr = ecs_parse_digit(ptr, token_out); - return ecs_parse_whitespace(ptr); -} + char *ptr, ch, prev = '\0'; + bool isNum = false; + char isStr = '\0'; + bool isVar = false; + bool overrideColor = false; + bool autoColor = true; + bool dontAppend = false; -const char* ecs_parse_token( - const char *name, - const char *expr, - const char *ptr, - char *token_out) -{ - int64_t column = ptr - expr; + for (ptr = msg; (ch = *ptr); ptr++) { + dontAppend = false; - ptr = ecs_parse_whitespace(ptr); - char *tptr = token_out, ch = ptr[0]; + if (!overrideColor) { + if (isNum && !isdigit(ch) && !isalpha(ch) && (ch != '.') && (ch != '%')) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + isNum = false; + } + if (isStr && (isStr == ch) && prev != '\\') { + isStr = '\0'; + } else if (((ch == '\'') || (ch == '"')) && !isStr && + !isalpha(prev) && (prev != '\\')) + { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); + isStr = ch; + } - if (!valid_token_start_char(ch)) { - if (ch == '\0' || ch == '\n') { - ecs_parser_error(name, expr, column, - "unexpected end of expression"); - } else { - ecs_parser_error(name, expr, column, - "invalid start of token '%s'", ptr); - } - return NULL; - } + if ((isdigit(ch) || (ch == '%' && isdigit(prev)) || + (ch == '-' && isdigit(ptr[1]))) && !isNum && !isStr && !isVar && + !isalpha(prev) && !isdigit(prev) && (prev != '_') && + (prev != '.')) + { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREEN); + isNum = true; + } - tptr[0] = ch; - tptr ++; - ptr ++; + if (isVar && !isalpha(ch) && !isdigit(ch) && ch != '_') { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + isVar = false; + } - if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',') { - tptr[0] = 0; - return ptr; - } + if (!isStr && !isVar && ch == '$' && isalpha(ptr[1])) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); + isVar = true; + } + } - int tmpl_nesting = 0; - bool in_str = ch == '"'; + if (!isVar && !isStr && !isNum && ch == '#' && ptr[1] == '[') { + bool isColor = true; + overrideColor = true; - for (; (ch = *ptr); ptr ++) { - if (ch == '<') { - tmpl_nesting ++; - } else if (ch == '>') { - if (!tmpl_nesting) { - break; + /* Custom colors */ + if (!ecs_os_strncmp(&ptr[2], "]", ecs_os_strlen("]"))) { + autoColor = false; + } else if (!ecs_os_strncmp(&ptr[2], "green]", ecs_os_strlen("green]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREEN); + } else if (!ecs_os_strncmp(&ptr[2], "red]", ecs_os_strlen("red]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_RED); + } else if (!ecs_os_strncmp(&ptr[2], "blue]", ecs_os_strlen("red]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_BLUE); + } else if (!ecs_os_strncmp(&ptr[2], "magenta]", ecs_os_strlen("magenta]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_MAGENTA); + } else if (!ecs_os_strncmp(&ptr[2], "cyan]", ecs_os_strlen("cyan]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_CYAN); + } else if (!ecs_os_strncmp(&ptr[2], "yellow]", ecs_os_strlen("yellow]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_YELLOW); + } else if (!ecs_os_strncmp(&ptr[2], "grey]", ecs_os_strlen("grey]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_GREY); + } else if (!ecs_os_strncmp(&ptr[2], "white]", ecs_os_strlen("white]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + } else if (!ecs_os_strncmp(&ptr[2], "bold]", ecs_os_strlen("bold]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_BOLD); + } else if (!ecs_os_strncmp(&ptr[2], "normal]", ecs_os_strlen("normal]"))) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + } else if (!ecs_os_strncmp(&ptr[2], "reset]", ecs_os_strlen("reset]"))) { + overrideColor = false; + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + } else { + isColor = false; + overrideColor = false; + } + + if (isColor) { + ptr += 2; + while ((ch = *ptr) != ']') ptr ++; + dontAppend = true; + } + if (!autoColor) { + overrideColor = true; } - tmpl_nesting --; - } else if (ch == '"') { - in_str = !in_str; - } else - if (!valid_token_char(ch) && !in_str) { - break; } - tptr[0] = ch; - tptr ++; - } + if (ch == '\n') { + if (isNum || isStr || isVar || overrideColor) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + overrideColor = false; + isNum = false; + isStr = false; + isVar = false; + } + } - tptr[0] = '\0'; + if (!dontAppend) { + ecs_strbuf_appendstrn(buf, ptr, 1); + } - if (tmpl_nesting != 0) { - ecs_parser_error(name, expr, column, - "identifier '%s' has mismatching < > pairs", ptr); - return NULL; - } + if (!overrideColor) { + if (((ch == '\'') || (ch == '"')) && !isStr) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); + } + } - const char *next_ptr = ecs_parse_whitespace(ptr); - if (next_ptr[0] == ':' && next_ptr != ptr) { - /* Whitespace between token and : is significant */ - ptr = next_ptr - 1; - } else { - ptr = next_ptr; + prev = ch; } - return ptr; -} - -static -const char* ecs_parse_identifier( - const char *name, - const char *expr, - const char *ptr, - char *token_out) -{ - if (!valid_identifier_start_char(ptr[0])) { - ecs_parser_error(name, expr, (ptr - expr), - "expected start of identifier"); - return NULL; + if (isNum || isStr || isVar || overrideColor) { + if (enable_colors) ecs_strbuf_appendstr(buf, ECS_NORMAL); } - - ptr = ecs_parse_token(name, expr, ptr, token_out); - - return ptr; } -static -int parse_identifier( - const char *token, - ecs_term_id_t *out) +void _ecs_logv( + int level, + const char *file, + int32_t line, + const char *fmt, + va_list args) { - char ch = token[0]; - - const char *tptr = token; - if (ch == TOK_AS_ENTITY) { - tptr ++; - } + (void)level; + (void)line; - out->name = ecs_os_strdup(tptr); + ecs_strbuf_t msg_buf = ECS_STRBUF_INIT; - if (ch == TOK_AS_ENTITY) { - out->var = EcsVarIsEntity; + if (level > ecs_os_api.log_level_) { + return; } - return 0; -} - -static -ecs_entity_t parse_role( - const char *name, - const char *sig, - int64_t column, - const char *token) -{ - if (!ecs_os_strcmp(token, TOK_ROLE_PAIR)) - { - return ECS_PAIR; - } else if (!ecs_os_strcmp(token, TOK_ROLE_AND)) { - return ECS_AND; - } else if (!ecs_os_strcmp(token, TOK_ROLE_OR)) { - return ECS_OR; - } else if (!ecs_os_strcmp(token, TOK_ROLE_XOR)) { - return ECS_XOR; - } else if (!ecs_os_strcmp(token, TOK_ROLE_NOT)) { - return ECS_NOT; - } else if (!ecs_os_strcmp(token, TOK_ROLE_SWITCH)) { - return ECS_SWITCH; - } else if (!ecs_os_strcmp(token, TOK_ROLE_CASE)) { - return ECS_CASE; - } else if (!ecs_os_strcmp(token, TOK_OVERRIDE)) { - return ECS_OVERRIDE; - } else if (!ecs_os_strcmp(token, TOK_ROLE_DISABLED)) { - return ECS_DISABLED; - } else { - ecs_parser_error(name, sig, column, "invalid role '%s'", token); - return 0; - } + /* Apply color. Even if we don't want color, we still need to call the + * colorize function to get rid of the color tags (e.g. #[green]) */ + char *msg_nocolor = ecs_vasprintf(fmt, args); + ecs_colorize_buf(msg_nocolor, ecs_os_api.log_with_color_, &msg_buf); + ecs_os_free(msg_nocolor); + + char *msg = ecs_strbuf_get(&msg_buf); + ecs_os_api.log_(level, file, line, msg); + ecs_os_free(msg); } -static -ecs_oper_kind_t parse_operator( - char ch) +void _ecs_log( + int level, + const char *file, + int32_t line, + const char *fmt, + ...) { - if (ch == TOK_OPTIONAL) { - return EcsOptional; - } else if (ch == TOK_NOT) { - return EcsNot; - } else { - ecs_abort(ECS_INTERNAL_ERROR, NULL); - } + va_list args; + va_start(args, fmt); + _ecs_logv(level, file, line, fmt, args); + va_end(args); } -static -const char* parse_annotation( - const char *name, - const char *sig, - int64_t column, - const char *ptr, - ecs_inout_kind_t *inout_kind_out) +void _ecs_log_push( + int32_t level) { - char token[ECS_MAX_TOKEN_SIZE]; - - ptr = ecs_parse_identifier(name, sig, ptr, token); - if (!ptr) { - return NULL; - } - - if (!ecs_os_strcmp(token, TOK_IN)) { - *inout_kind_out = EcsIn; - } else - if (!ecs_os_strcmp(token, TOK_OUT)) { - *inout_kind_out = EcsOut; - } else - if (!ecs_os_strcmp(token, TOK_INOUT)) { - *inout_kind_out = EcsInOut; - } else if (!ecs_os_strcmp(token, TOK_INOUT_FILTER)) { - *inout_kind_out = EcsInOutFilter; - } - - ptr = ecs_parse_whitespace(ptr); - - if (ptr[0] != TOK_BRACKET_CLOSE) { - ecs_parser_error(name, sig, column, "expected ]"); - return NULL; + if (level <= ecs_os_api.log_level_) { + ecs_os_api.log_indent_ ++; } - - return ptr + 1; } -static -uint8_t parse_set_token( - const char *token) +void _ecs_log_pop( + int32_t level) { - if (!ecs_os_strcmp(token, TOK_SELF)) { - return EcsSelf; - } else if (!ecs_os_strcmp(token, TOK_SUPERSET)) { - return EcsSuperSet; - } else if (!ecs_os_strcmp(token, TOK_SUBSET)) { - return EcsSubSet; - } else if (!ecs_os_strcmp(token, TOK_CASCADE)) { - return EcsCascade; - } else if (!ecs_os_strcmp(token, TOK_ALL)) { - return EcsAll; - } else if (!ecs_os_strcmp(token, TOK_PARENT)) { - return EcsParent; - } else { - return 0; + if (level <= ecs_os_api.log_level_) { + ecs_os_api.log_indent_ --; } } -static -const char* parse_set_expr( - const ecs_world_t *world, +void _ecs_parser_errorv( const char *name, - const char *expr, - int64_t column, - const char *ptr, - char *token, - ecs_term_id_t *id, - char tok_end) + const char *expr, + int64_t column_arg, + const char *fmt, + va_list args) { - char token_buf[ECS_MAX_TOKEN_SIZE] = {0}; - if (!token) { - token = token_buf; - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - return NULL; - } - } - - do { - uint8_t tok = parse_set_token(token); - if (!tok) { - ecs_parser_error(name, expr, column, - "invalid set token '%s'", token); - return NULL; - } - - if (id->set.mask & tok) { - ecs_parser_error(name, expr, column, - "duplicate set token '%s'", token); - return NULL; - } - - if ((tok == EcsSubSet && id->set.mask & EcsSuperSet) || - (tok == EcsSuperSet && id->set.mask & EcsSubSet)) - { - ecs_parser_error(name, expr, column, - "cannot mix super and sub", token); - return NULL; - } - - id->set.mask |= tok; - - if (ptr[0] == TOK_PAREN_OPEN) { - ptr ++; - - /* Relationship (overrides IsA default) */ - if (!isdigit(ptr[0]) && valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - return NULL; - } - - id->set.relation = ecs_lookup_fullpath(world, token); - if (!id->set.relation) { - ecs_parser_error(name, expr, column, - "unresolved identifier '%s'", token); - return NULL; - } - - if (ptr[0] == TOK_AND) { - ptr = ecs_parse_whitespace(ptr + 1); - } else if (ptr[0] != TOK_PAREN_CLOSE) { - ecs_parser_error(name, expr, column, - "expected ',' or ')'"); - return NULL; - } - } + int32_t column = flecs_itoi32(column_arg); - /* Max depth of search */ - if (isdigit(ptr[0])) { - ptr = parse_digit(ptr, token); - if (!ptr) { - return NULL; - } + if (ecs_os_api.log_level_ >= -2) { + ecs_strbuf_t msg_buf = ECS_STRBUF_INIT; - id->set.max_depth = atoi(token); - if (id->set.max_depth < 0) { - ecs_parser_error(name, expr, column, - "invalid negative depth"); - return NULL; - } + ecs_strbuf_vappend(&msg_buf, fmt, args); - if (ptr[0] == ',') { - ptr = ecs_parse_whitespace(ptr + 1); - } - } + if (expr) { + ecs_strbuf_appendstr(&msg_buf, "\n"); - /* If another digit is found, previous depth was min depth */ - if (isdigit(ptr[0])) { - ptr = parse_digit(ptr, token); - if (!ptr) { - return NULL; + /* Find start of line by taking column and looking for the + * last occurring newline */ + if (column != -1) { + const char *ptr = &expr[column]; + while (ptr[0] != '\n' && ptr > expr) { + ptr --; } - id->set.min_depth = id->set.max_depth; - id->set.max_depth = atoi(token); - if (id->set.max_depth < 0) { - ecs_parser_error(name, expr, column, - "invalid negative depth"); - return NULL; + if (ptr == expr) { + /* ptr is already at start of line */ + } else { + column -= (int32_t)(ptr - expr + 1); + expr = ptr + 1; } } - if (ptr[0] != TOK_PAREN_CLOSE) { - ecs_parser_error(name, expr, column, "expected ')', got '%c'", - ptr[0]); - return NULL; + /* Strip newlines from current statement, if any */ + char *newline_ptr = strchr(expr, '\n'); + if (newline_ptr) { + /* Strip newline from expr */ + ecs_strbuf_appendstrn(&msg_buf, expr, + (int32_t)(newline_ptr - expr)); } else { - ptr = ecs_parse_whitespace(ptr + 1); - if (ptr[0] != tok_end && ptr[0] != TOK_AND && ptr[0] != 0) { - ecs_parser_error(name, expr, column, - "expected end of set expr"); - return NULL; - } + ecs_strbuf_appendstr(&msg_buf, expr); } - } - /* Next token in set expression */ - if (ptr[0] == TOK_BITWISE_OR) { - ptr ++; - if (valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - return NULL; - } - } + ecs_strbuf_appendstr(&msg_buf, "\n"); - /* End of set expression */ - } else if (ptr[0] == tok_end || ptr[0] == TOK_AND || !ptr[0]) { - break; + if (column != -1) { + ecs_strbuf_append(&msg_buf, "%*s^", column, ""); + } } - } while (true); - - if (id->set.mask & EcsCascade && !(id->set.mask & EcsSuperSet) && - !(id->set.mask & EcsSubSet)) - { - /* If cascade is used without specifying super or sub, assume - * super */ - id->set.mask |= EcsSuperSet; - } - if (id->set.mask & EcsSelf && id->set.min_depth != 0) { - ecs_parser_error(name, expr, column, - "min_depth must be zero for set expression with 'self'"); - return NULL; + char *msg = ecs_strbuf_get(&msg_buf); + ecs_os_err(name, 0, msg); + ecs_os_free(msg); } - - return ptr; } -static -const char* parse_arguments( - const ecs_world_t *world, +void _ecs_parser_error( const char *name, - const char *expr, + const char *expr, int64_t column, - const char *ptr, - char *token, - ecs_term_t *term) + const char *fmt, + ...) { - (void)column; + if (ecs_os_api.log_level_ >= -2) { + va_list args; + va_start(args, fmt); + _ecs_parser_errorv(name, expr, column, fmt, args); + va_end(args); + } +} - int32_t arg = 0; +void _ecs_abort( + int32_t err, + const char *file, + int32_t line, + const char *fmt, + ...) +{ + if (fmt) { + va_list args; + va_start(args, fmt); + char *msg = ecs_vasprintf(fmt, args); + va_end(args); + _ecs_fatal(file, line, "%s (%s)", msg, ecs_strerror(err)); + ecs_os_free(msg); + } else { + _ecs_fatal(file, line, "%s", ecs_strerror(err)); + } + ecs_os_api.log_last_error_ = err; +} - do { - if (valid_token_start_char(ptr[0])) { - if (arg == 2) { - ecs_parser_error(name, expr, (ptr - expr), - "too many arguments in term"); - return NULL; - } +bool _ecs_assert( + bool condition, + int32_t err, + const char *cond_str, + const char *file, + int32_t line, + const char *fmt, + ...) +{ + if (!condition) { + if (fmt) { + va_list args; + va_start(args, fmt); + char *msg = ecs_vasprintf(fmt, args); + va_end(args); + _ecs_fatal(file, line, "assert: %s %s (%s)", + cond_str, msg, ecs_strerror(err)); + ecs_os_free(msg); + } else { + _ecs_fatal(file, line, "assert: %s %s", + cond_str, ecs_strerror(err)); + } + ecs_os_api.log_last_error_ = err; + } - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - return NULL; - } + return condition; +} - ecs_term_id_t *term_id = NULL; +void _ecs_deprecated( + const char *file, + int32_t line, + const char *msg) +{ + _ecs_err(file, line, "%s", msg); +} - if (arg == 0) { - term_id = &term->subj; - } else if (arg == 1) { - term_id = &term->obj; - } +bool ecs_should_log(int32_t level) { +# if !defined(ECS_TRACE_3) + if (level == 3) { + return false; + } +# endif +# if !defined(ECS_TRACE_2) + if (level == 2) { + return false; + } +# endif +# if !defined(ECS_TRACE_1) + if (level == 1) { + return false; + } +# endif - /* If token is a colon, the token is an identifier followed by a - * set expression. */ - if (ptr[0] == TOK_COLON) { - if (parse_identifier(token, term_id)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); - return NULL; - } + return level <= ecs_os_api.log_level_; +} - ptr = ecs_parse_whitespace(ptr + 1); - ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, - NULL, term_id, TOK_PAREN_CLOSE); - if (!ptr) { - return NULL; - } +#define ECS_ERR_STR(code) case code: return &(#code[4]) - /* If token is a self, super or sub token, this is a set - * expression */ - } else if (!ecs_os_strcmp(token, TOK_ALL) || - !ecs_os_strcmp(token, TOK_CASCADE) || - !ecs_os_strcmp(token, TOK_SELF) || - !ecs_os_strcmp(token, TOK_SUPERSET) || - !ecs_os_strcmp(token, TOK_SUBSET) || - !(ecs_os_strcmp(token, TOK_PARENT))) - { - ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, - token, term_id, TOK_PAREN_CLOSE); - if (!ptr) { - return NULL; - } +const char* ecs_strerror( + int32_t error_code) +{ + switch (error_code) { + ECS_ERR_STR(ECS_INVALID_PARAMETER); + ECS_ERR_STR(ECS_NOT_A_COMPONENT); + ECS_ERR_STR(ECS_INTERNAL_ERROR); + ECS_ERR_STR(ECS_ALREADY_DEFINED); + ECS_ERR_STR(ECS_INVALID_COMPONENT_SIZE); + ECS_ERR_STR(ECS_INVALID_COMPONENT_ALIGNMENT); + ECS_ERR_STR(ECS_NAME_IN_USE); + ECS_ERR_STR(ECS_OUT_OF_MEMORY); + ECS_ERR_STR(ECS_OPERATION_FAILED); + ECS_ERR_STR(ECS_INVALID_CONVERSION); + ECS_ERR_STR(ECS_MODULE_UNDEFINED); + ECS_ERR_STR(ECS_MISSING_SYMBOL); + ECS_ERR_STR(ECS_ALREADY_IN_USE); + ECS_ERR_STR(ECS_COLUMN_INDEX_OUT_OF_RANGE); + ECS_ERR_STR(ECS_COLUMN_IS_NOT_SHARED); + ECS_ERR_STR(ECS_COLUMN_IS_SHARED); + ECS_ERR_STR(ECS_COLUMN_TYPE_MISMATCH); + ECS_ERR_STR(ECS_INVALID_WHILE_ITERATING); + ECS_ERR_STR(ECS_INVALID_FROM_WORKER); + ECS_ERR_STR(ECS_OUT_OF_RANGE); + ECS_ERR_STR(ECS_MISSING_OS_API); + ECS_ERR_STR(ECS_UNSUPPORTED); + ECS_ERR_STR(ECS_COLUMN_ACCESS_VIOLATION); + ECS_ERR_STR(ECS_COMPONENT_NOT_REGISTERED); + ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ID); + ECS_ERR_STR(ECS_TYPE_INVALID_CASE); + ECS_ERR_STR(ECS_INCONSISTENT_NAME); + ECS_ERR_STR(ECS_INCONSISTENT_COMPONENT_ACTION); + ECS_ERR_STR(ECS_INVALID_OPERATION); + ECS_ERR_STR(ECS_CONSTRAINT_VIOLATED); + ECS_ERR_STR(ECS_LOCKED_STORAGE); + ECS_ERR_STR(ECS_ID_IN_USE); + } - /* Regular identifier */ - } else if (parse_identifier(token, term_id)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); - return NULL; - } + return "unknown error code"; +} - if (ptr[0] == TOK_AND) { - ptr = ecs_parse_whitespace(ptr + 1); +#else - term->role = ECS_PAIR; +/* Empty bodies for when logging is disabled */ - } else if (ptr[0] == TOK_PAREN_CLOSE) { - ptr = ecs_parse_whitespace(ptr + 1); - break; +void _ecs_log( + int32_t level, + const char *file, + int32_t line, + const char *fmt, + ...) +{ + (void)level; + (void)file; + (void)line; + (void)fmt; +} - } else { - ecs_parser_error(name, expr, (ptr - expr), - "expected ',' or ')'"); - return NULL; - } +void _ecs_parser_error( + const char *name, + const char *expr, + int64_t column, + const char *fmt, + ...) +{ + (void)name; + (void)expr; + (void)column; + (void)fmt; +} - } else { - ecs_parser_error(name, expr, (ptr - expr), - "expected identifier or set expression"); - return NULL; - } +void _ecs_parser_errorv( + const char *name, + const char *expr, + int64_t column, + const char *fmt, + va_list args) +{ + (void)name; + (void)expr; + (void)column; + (void)fmt; + (void)args; +} - arg ++; +void _ecs_abort( + int32_t error_code, + const char *file, + int32_t line, + const char *fmt, + ...) +{ + (void)error_code; + (void)file; + (void)line; + (void)fmt; +} - } while (true); +bool _ecs_assert( + bool condition, + int32_t error_code, + const char *condition_str, + const char *file, + int32_t line, + const char *fmt, + ...) +{ + (void)condition; + (void)error_code; + (void)condition_str; + (void)file; + (void)line; + (void)fmt; + return true; +} - return ptr; +#endif + +int ecs_log_set_level( + int level) +{ + int prev = level; + ecs_os_api.log_level_ = level; + return prev; } -static -void parser_unexpected_char( - const char *name, - const char *expr, - const char *ptr, - char ch) +bool ecs_log_enable_colors( + bool enabled) { - if (ch && (ch != '\n')) { - ecs_parser_error(name, expr, (ptr - expr), - "unexpected character '%c'", ch); - } else { - ecs_parser_error(name, expr, (ptr - expr), - "unexpected end of term"); - } + bool prev = ecs_os_api.log_with_color_; + ecs_os_api.log_with_color_ = enabled; + return prev; } -static -const char* parse_term( - const ecs_world_t *world, - const char *name, - const char *expr, - ecs_term_t *term_out) +int ecs_log_last_error(void) { - const char *ptr = expr; - char token[ECS_MAX_TOKEN_SIZE] = {0}; - ecs_term_t term = { .move = true /* parser never owns resources */ }; + int result = ecs_os_api.log_last_error_; + ecs_os_api.log_last_error_ = 0; + return result; +} - ptr = ecs_parse_whitespace(ptr); - /* Inout specifiers always come first */ - if (ptr[0] == TOK_BRACKET_OPEN) { - ptr = parse_annotation(name, expr, (ptr - expr), ptr + 1, &term.inout); - if (!ptr) { - goto error; - } - ptr = ecs_parse_whitespace(ptr); - } - if (valid_operator_char(ptr[0])) { - term.oper = parse_operator(ptr[0]); - ptr = ecs_parse_whitespace(ptr + 1); - } +#ifdef FLECS_JSON - /* If next token is the start of an identifier, it could be either a type - * role, source or component identifier */ - if (valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - goto error; - } +void json_next( + ecs_strbuf_t *buf); - /* Is token a type role? */ - if (ptr[0] == TOK_BITWISE_OR && ptr[1] != TOK_BITWISE_OR) { - ptr ++; - goto parse_role; - } +void json_literal( + ecs_strbuf_t *buf, + const char *value); - /* Is token a predicate? */ - if (ptr[0] == TOK_PAREN_OPEN) { - goto parse_predicate; - } +void json_number( + ecs_strbuf_t *buf, + double value); - /* Next token must be a predicate */ - goto parse_predicate; +void json_true( + ecs_strbuf_t *buf); - /* If next token is a singleton, assign identifier to pred and subject */ - } else if (ptr[0] == TOK_SINGLETON) { - ptr ++; - if (valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - goto error; - } +void json_false( + ecs_strbuf_t *buf); - goto parse_singleton; +void json_bool( + ecs_strbuf_t *buf, + bool value); - } else { - ecs_parser_error(name, expr, (ptr - expr), - "expected identifier after singleton operator"); - goto error; - } +void json_array_push( + ecs_strbuf_t *buf); - /* Pair with implicit subject */ - } else if (ptr[0] == TOK_PAREN_OPEN) { - goto parse_pair; +void json_array_pop( + ecs_strbuf_t *buf); - /* Nothing else expected here */ - } else { - parser_unexpected_char(name, expr, ptr, ptr[0]); - goto error; - } +void json_object_push( + ecs_strbuf_t *buf); -parse_role: - term.role = parse_role(name, expr, (ptr - expr), token); - if (!term.role) { - goto error; - } +void json_object_pop( + ecs_strbuf_t *buf); - ptr = ecs_parse_whitespace(ptr); +void json_string( + ecs_strbuf_t *buf, + const char *value); - /* If next token is the source token, this is an empty source */ - if (valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - goto error; - } +void json_member( + ecs_strbuf_t *buf, + const char *name); - /* If not, it's a predicate */ - goto parse_predicate; +void json_path( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_entity_t e); - } else if (ptr[0] == TOK_PAREN_OPEN) { - goto parse_pair; - } else { - ecs_parser_error(name, expr, (ptr - expr), - "expected identifier after role"); - goto error; - } +void json_label( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_entity_t e); -parse_predicate: - if (parse_identifier(token, &term.pred)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); +void json_id( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_id_t id); + +ecs_primitive_kind_t json_op_to_primitive_kind( + ecs_meta_type_op_kind_t kind); + +#endif + +#include + +#ifdef FLECS_JSON + +static +int json_ser_type( + const ecs_world_t *world, + ecs_vector_t *ser, + const void *base, + ecs_strbuf_t *str); + +static +int json_ser_type_ops( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + ecs_strbuf_t *str); + +static +int json_ser_type_op( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str); + +/* Serialize enumeration */ +static +int json_ser_enum( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str) +{ + const EcsEnum *enum_type = ecs_get(world, op->type, EcsEnum); + ecs_check(enum_type != NULL, ECS_INVALID_PARAMETER, NULL); + + int32_t value = *(int32_t*)base; + + /* Enumeration constants are stored in a map that is keyed on the + * enumeration value. */ + ecs_enum_constant_t *constant = ecs_map_get( + enum_type->constants, ecs_enum_constant_t, value); + if (!constant) { goto error; } - /* Set expression */ - if (ptr[0] == TOK_COLON) { - ptr = ecs_parse_whitespace(ptr + 1); - ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, NULL, - &term.pred, TOK_COLON); - if (!ptr) { - goto error; - } - - ptr = ecs_parse_whitespace(ptr); + ecs_strbuf_appendch(str, '"'); + ecs_strbuf_appendstr(str, ecs_get_name(world, constant->constant)); + ecs_strbuf_appendch(str, '"'); - if (ptr[0] == TOK_AND || !ptr[0]) { - goto parse_done; - } + return 0; +error: + return -1; +} - if (ptr[0] != TOK_COLON) { - ecs_parser_error(name, expr, (ptr - expr), - "unexpected token '%c' after predicate set expression", ptr[0]); - goto error; - } +/* Serialize bitmask */ +static +int json_ser_bitmask( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) +{ + const EcsBitmask *bitmask_type = ecs_get(world, op->type, EcsBitmask); + ecs_check(bitmask_type != NULL, ECS_INVALID_PARAMETER, NULL); - ptr = ecs_parse_whitespace(ptr + 1); - } else { - ptr = ecs_parse_whitespace(ptr); - } - - if (ptr[0] == TOK_PAREN_OPEN) { - ptr ++; - if (ptr[0] == TOK_PAREN_CLOSE) { - term.subj.set.mask = EcsNothing; - ptr ++; - ptr = ecs_parse_whitespace(ptr); - } else { - ptr = parse_arguments( - world, name, expr, (ptr - expr), ptr, token, &term); - } + uint32_t value = *(uint32_t*)ptr; + ecs_map_key_t key; + ecs_bitmask_constant_t *constant; - goto parse_done; + if (!value) { + ecs_strbuf_appendch(str, '0'); + return 0; } - goto parse_done; + ecs_strbuf_list_push(str, "\"", "|"); -parse_pair: - ptr = ecs_parse_identifier(name, expr, ptr + 1, token); - if (!ptr) { - goto error; + /* Multiple flags can be set at a given time. Iterate through all the flags + * and append the ones that are set. */ + ecs_map_iter_t it = ecs_map_iter(bitmask_type->constants); + while ((constant = ecs_map_next(&it, ecs_bitmask_constant_t, &key))) { + if ((value & key) == key) { + ecs_strbuf_list_appendstr(str, + ecs_get_name(world, constant->constant)); + value -= (uint32_t)key; + } } - if (ptr[0] == TOK_AND) { - ptr ++; - term.subj.entity = EcsThis; - goto parse_pair_predicate; - } else if (ptr[0] == TOK_PAREN_CLOSE) { - term.subj.entity = EcsThis; - goto parse_pair_predicate; - } else { - parser_unexpected_char(name, expr, ptr, ptr[0]); + if (value != 0) { + /* All bits must have been matched by a constant */ goto error; } -parse_pair_predicate: - if (parse_identifier(token, &term.pred)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); - goto error; - } + ecs_strbuf_list_pop(str, "\""); - ptr = ecs_parse_whitespace(ptr); - if (valid_token_start_char(ptr[0])) { - ptr = ecs_parse_identifier(name, expr, ptr, token); - if (!ptr) { - goto error; - } + return 0; +error: + return -1; +} - if (ptr[0] == TOK_PAREN_CLOSE) { - ptr ++; - goto parse_pair_object; - } else { - parser_unexpected_char(name, expr, ptr, ptr[0]); - goto error; - } - } else if (ptr[0] == TOK_PAREN_CLOSE) { - /* No object */ - ptr ++; - goto parse_done; - } else { - ecs_parser_error(name, expr, (ptr - expr), - "expected pair object or ')'"); - goto error; - } +/* Serialize elements of a contiguous array */ +static +int json_ser_elements( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + int32_t elem_count, + int32_t elem_size, + ecs_strbuf_t *str) +{ + json_array_push(str); -parse_pair_object: - if (parse_identifier(token, &term.obj)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); - goto error; - } + const void *ptr = base; - if (term.role != 0) { - if (term.role != ECS_PAIR && term.role != ECS_CASE) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid combination of role '%s' with pair", - ecs_role_str(term.role)); - goto error; + int i; + for (i = 0; i < elem_count; i ++) { + ecs_strbuf_list_next(str); + if (json_ser_type_ops(world, ops, op_count, ptr, str)) { + return -1; } - } else { - term.role = ECS_PAIR; + ptr = ECS_OFFSET(ptr, elem_size); } - ptr = ecs_parse_whitespace(ptr); - goto parse_done; + json_array_pop(str); -parse_singleton: - if (parse_identifier(token, &term.pred)) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid identifier '%s'", token); - goto error; - } + return 0; +} - parse_identifier(token, &term.subj); - goto parse_done; +static +int json_ser_type_elements( + const ecs_world_t *world, + ecs_entity_t type, + const void *base, + int32_t elem_count, + ecs_strbuf_t *str) +{ + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + ecs_assert(ser != NULL, ECS_INTERNAL_ERROR, NULL); -parse_done: - *term_out = term; - return ptr; + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); -error: - ecs_term_fini(&term); - *term_out = (ecs_term_t){0}; - return NULL; + ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); + int32_t op_count = ecs_vector_count(ser->ops); + + return json_ser_elements( + world, ops, op_count, base, elem_count, comp->size, str); } +/* Serialize array */ static -bool is_valid_end_of_term( - const char *ptr) +int json_ser_array( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) { - if ((ptr[0] == TOK_AND) || /* another term with And operator */ - (ptr[0] == TOK_OR[0]) || /* another term with Or operator */ - (ptr[0] == '\n') || /* newlines are valid */ - (ptr[0] == '\0') || /* end of string */ - (ptr[0] == '/') || /* comment (in plecs) */ - (ptr[0] == '{') || /* scope (in plecs) */ - (ptr[0] == '}') || - (ptr[0] == ':') || /* inheritance (in plecs) */ - (ptr[0] == '=')) /* assignment (in plecs) */ - { - return true; - } - return false; + const EcsArray *a = ecs_get(world, op->type, EcsArray); + ecs_assert(a != NULL, ECS_INTERNAL_ERROR, NULL); + + return json_ser_type_elements( + world, a->type, ptr, a->count, str); } -char* ecs_parse_term( +/* Serialize vector */ +static +int json_ser_vector( const ecs_world_t *world, - const char *name, - const char *expr, - const char *ptr, - ecs_term_t *term) + ecs_meta_type_op_t *op, + const void *base, + ecs_strbuf_t *str) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_term_id_t *subj = &term->subj; - - bool prev_or = false; - if (ptr != expr) { - if (ptr[0]) { - if (ptr[0] == ',') { - ptr ++; - } else if (ptr[0] == '|') { - ptr += 2; - prev_or = true; - } else { - ecs_parser_error(name, expr, (ptr - expr), - "invalid preceding token"); - } - } - } - - ptr = ecs_parse_eol_and_whitespace(ptr); - if (!ptr[0]) { - *term = (ecs_term_t){0}; - return (char*)ptr; + ecs_vector_t *value = *(ecs_vector_t**)base; + if (!value) { + ecs_strbuf_appendstr(str, "null"); + return 0; } - if (ptr == expr && !strcmp(expr, "0")) { - return (char*)&ptr[1]; - } + const EcsVector *v = ecs_get(world, op->type, EcsVector); + ecs_assert(v != NULL, ECS_INTERNAL_ERROR, NULL); - int32_t prev_set = subj->set.mask; + const EcsComponent *comp = ecs_get(world, v->type, EcsComponent); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); - /* Parse next element */ - ptr = parse_term(world, name, ptr, term); - if (!ptr) { - goto error; - } + int32_t count = ecs_vector_count(value); + void *array = ecs_vector_first_t(value, comp->size, comp->alignment); - /* Post-parse consistency checks */ + /* Serialize contiguous buffer of vector */ + return json_ser_type_elements(world, v->type, array, count, str); +} - /* If next token is OR, term is part of an OR expression */ - if (!ecs_os_strncmp(ptr, TOK_OR, 2) || prev_or) { - /* An OR operator must always follow an AND or another OR */ - if (term->oper != EcsAnd) { - ecs_parser_error(name, expr, (ptr - expr), - "cannot combine || with other operators"); +/* Forward serialization to the different type kinds */ +static +int json_ser_type_op( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + const void *ptr, + ecs_strbuf_t *str) +{ + switch(op->kind) { + case EcsOpPush: + case EcsOpPop: + /* Should not be parsed as single op */ + ecs_throw(ECS_INVALID_PARAMETER, NULL); + break; + case EcsOpF32: + ecs_strbuf_appendflt(str, + (ecs_f64_t)*(ecs_f32_t*)ECS_OFFSET(ptr, op->offset), '"'); + break; + case EcsOpF64: + ecs_strbuf_appendflt(str, + *(ecs_f64_t*)ECS_OFFSET(ptr, op->offset), '"'); + break; + case EcsOpEnum: + if (json_ser_enum(world, op, ECS_OFFSET(ptr, op->offset), str)) { goto error; } - - term->oper = EcsOr; - } - - /* Term must either end in end of expression, AND or OR token */ - if (!is_valid_end_of_term(ptr)) { - ecs_parser_error(name, expr, (ptr - expr), - "expected end of expression or next term"); - goto error; - } - - /* If the term just contained a 0, the expression has nothing. Ensure - * that after the 0 nothing else follows */ - if (!ecs_os_strcmp(term->pred.name, "0")) { - if (ptr[0]) { - ecs_parser_error(name, expr, (ptr - expr), - "unexpected term after 0"); + break; + case EcsOpBitmask: + if (json_ser_bitmask(world, op, ECS_OFFSET(ptr, op->offset), str)) { goto error; } - - if (subj->set.mask != EcsDefaultSet || - (subj->entity && subj->entity != EcsThis) || - (subj->name && ecs_os_strcmp(subj->name, "This"))) - { - ecs_parser_error(name, expr, (ptr - expr), - "invalid combination of 0 with non-default subject"); + break; + case EcsOpArray: + if (json_ser_array(world, op, ECS_OFFSET(ptr, op->offset), str)) { goto error; } - - subj->set.mask = EcsNothing; - ecs_os_free(term->pred.name); - term->pred.name = NULL; - } - - /* Cannot combine EcsNothing with operators other than AND */ - if (term->oper != EcsAnd && subj->set.mask == EcsNothing) { - ecs_parser_error(name, expr, (ptr - expr), - "invalid operator for empty source"); - goto error; - } - - /* Verify consistency of OR expression */ - if (prev_or && term->oper == EcsOr) { - /* Set expressions must be the same for all OR terms */ - if (subj->set.mask != prev_set) { - ecs_parser_error(name, expr, (ptr - expr), - "cannot combine different sources in OR expression"); + break; + case EcsOpVector: + if (json_ser_vector(world, op, ECS_OFFSET(ptr, op->offset), str)) { goto error; } - - term->oper = EcsOr; - } - - /* Automatically assign This if entity is not assigned and the set is - * nothing */ - if (subj->set.mask != EcsNothing) { - if (!subj->name) { - if (!subj->entity) { - subj->entity = EcsThis; - } + break; + case EcsOpEntity: { + ecs_entity_t e = *(ecs_entity_t*)ECS_OFFSET(ptr, op->offset); + if (!e) { + ecs_strbuf_appendch(str, '0'); + } else { + json_path(str, world, e); } + break; } - if (subj->name && !ecs_os_strcmp(subj->name, "0")) { - subj->entity = 0; - subj->set.mask = EcsNothing; - } - - /* Process role */ - if (term->role == ECS_AND) { - term->oper = EcsAndFrom; - term->role = 0; - } else if (term->role == ECS_OR) { - term->oper = EcsOrFrom; - term->role = 0; - } else if (term->role == ECS_NOT) { - term->oper = EcsNotFrom; - term->role = 0; + default: + if (ecs_primitive_to_expr_buf(world, + json_op_to_primitive_kind(op->kind), + ECS_OFFSET(ptr, op->offset), str)) + { + /* Unknown operation */ + ecs_throw(ECS_INTERNAL_ERROR, NULL); + return -1; + } + break; } - ptr = ecs_parse_whitespace(ptr); - - return (char*)ptr; + return 0; error: - if (term) { - ecs_term_fini(term); - } - return NULL; + return -1; } -#endif - - -#ifdef FLECS_META_C - -#include - -#define ECS_META_IDENTIFIER_LENGTH (256) - -#define ecs_meta_error(ctx, ptr, ...)\ - ecs_parser_error((ctx)->name, (ctx)->desc, ptr - (ctx)->desc, __VA_ARGS__); - -typedef char ecs_meta_token_t[ECS_META_IDENTIFIER_LENGTH]; - -typedef struct meta_parse_ctx_t { - const char *name; - const char *desc; -} meta_parse_ctx_t; - -typedef struct meta_type_t { - ecs_meta_token_t type; - ecs_meta_token_t params; - bool is_const; - bool is_ptr; -} meta_type_t; - -typedef struct meta_member_t { - meta_type_t type; - ecs_meta_token_t name; - int64_t count; - bool is_partial; -} meta_member_t; - -typedef struct meta_constant_t { - ecs_meta_token_t name; - int64_t value; - bool is_value_set; -} meta_constant_t; - -typedef struct meta_params_t { - meta_type_t key_type; - meta_type_t type; - int64_t count; - bool is_key_value; - bool is_fixed_size; -} meta_params_t; - +/* Iterate over a slice of the type ops array */ static -const char* skip_scope(const char *ptr, meta_parse_ctx_t *ctx) { - /* Keep track of which characters were used to open the scope */ - char stack[256]; - int32_t sp = 0; - char ch; - - while ((ch = *ptr)) { - if (ch == '(' || ch == '<') { - stack[sp] = ch; +int json_ser_type_ops( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + const void *base, + ecs_strbuf_t *str) +{ + for (int i = 0; i < op_count; i ++) { + ecs_meta_type_op_t *op = &ops[i]; - sp ++; - if (sp >= 256) { - ecs_meta_error(ctx, ptr, "maximum level of nesting reached"); - goto error; - } - } else if (ch == ')' || ch == '>') { - sp --; - if ((sp < 0) || (ch == '>' && stack[sp] != '<') || - (ch == ')' && stack[sp] != '(')) - { - ecs_meta_error(ctx, ptr, "mismatching %c in identifier", ch); - goto error; + if (op != ops) { + if (op->name) { + json_member(str, op->name); } - } - ptr ++; + int32_t elem_count = op->count; + if (elem_count > 1 && op != ops) { + /* Serialize inline array */ + if (json_ser_elements(world, op, op->op_count, base, + elem_count, op->size, str)) + { + return -1; + } - if (!sp) { + i += op->op_count - 1; + continue; + } + } + + switch(op->kind) { + case EcsOpPush: + json_object_push(str); + break; + case EcsOpPop: + json_object_pop(str); + break; + default: + if (json_ser_type_op(world, op, base, str)) { + goto error; + } break; } } - return ptr; + return 0; error: - return NULL; + return -1; } +/* Iterate over the type ops of a type */ static -const char* parse_c_digit( - const char *ptr, - int64_t *value_out) +int json_ser_type( + const ecs_world_t *world, + ecs_vector_t *v_ops, + const void *base, + ecs_strbuf_t *str) { - char token[24]; - ptr = ecs_parse_eol_and_whitespace(ptr); - ptr = ecs_parse_digit(ptr, token); - if (!ptr) { - goto error; - } - - *value_out = strtol(token, NULL, 0); - - return ecs_parse_eol_and_whitespace(ptr); -error: - return NULL; + ecs_meta_type_op_t *ops = ecs_vector_first(v_ops, ecs_meta_type_op_t); + int32_t count = ecs_vector_count(v_ops); + return json_ser_type_ops(world, ops, count, base, str); } static -const char* parse_c_identifier( - const char *ptr, - char *buff, - char *params, - meta_parse_ctx_t *ctx) +int array_to_json_buf_w_type_data( + const ecs_world_t *world, + const void *ptr, + int32_t count, + ecs_strbuf_t *buf, + const EcsComponent *comp, + const EcsMetaTypeSerialized *ser) { - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(buff != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL); - - char *bptr = buff, ch; - - if (params) { - params[0] = '\0'; - } - - /* Ignore whitespaces */ - ptr = ecs_parse_eol_and_whitespace(ptr); + if (count) { + ecs_size_t size = comp->size; - if (!isalpha(*ptr)) { - ecs_meta_error(ctx, ptr, - "invalid identifier (starts with '%c')", *ptr); - goto error; - } + json_array_push(buf); - while ((ch = *ptr) && !isspace(ch) && ch != ';' && ch != ',' && ch != ')' && ch != '>' && ch != '}') { - /* Type definitions can contain macro's or templates */ - if (ch == '(' || ch == '<') { - if (!params) { - ecs_meta_error(ctx, ptr, "unexpected %c", *ptr); - goto error; + do { + ecs_strbuf_list_next(buf); + if (json_ser_type(world, ser->ops, ptr, buf)) { + return -1; } - const char *end = skip_scope(ptr, ctx); - ecs_os_strncpy(params, ptr, (ecs_size_t)(end - ptr)); - params[end - ptr] = '\0'; + ptr = ECS_OFFSET(ptr, size); + } while (-- count); - ptr = end; - } else { - *bptr = ch; - bptr ++; - ptr ++; + json_array_pop(buf); + } else { + if (json_ser_type(world, ser->ops, ptr, buf)) { + return -1; } } - *bptr = '\0'; - - if (!ch) { - ecs_meta_error(ctx, ptr, "unexpected end of token"); - goto error; - } - - return ptr; -error: - return NULL; + return 0; } -static -const char * meta_open_scope( - const char *ptr, - meta_parse_ctx_t *ctx) +int ecs_array_to_json_buf( + const ecs_world_t *world, + ecs_entity_t type, + const void *ptr, + int32_t count, + ecs_strbuf_t *buf) { - /* Skip initial whitespaces */ - ptr = ecs_parse_eol_and_whitespace(ptr); - - /* Is this the start of the type definition? */ - if (ctx->desc == ptr) { - if (*ptr != '{') { - ecs_meta_error(ctx, ptr, "missing '{' in struct definition"); - goto error; - } - - ptr ++; - ptr = ecs_parse_eol_and_whitespace(ptr); + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + if (!comp) { + char *path = ecs_get_fullpath(world, type); + ecs_err("cannot serialize to JSON, '%s' is not a component", path); + ecs_os_free(path); + return -1; } - /* Is this the end of the type definition? */ - if (!*ptr) { - ecs_meta_error(ctx, ptr, "missing '}' at end of struct definition"); - goto error; - } - - /* Is this the end of the type definition? */ - if (*ptr == '}') { - ptr = ecs_parse_eol_and_whitespace(ptr + 1); - if (*ptr) { - ecs_meta_error(ctx, ptr, - "stray characters after struct definition"); - goto error; - } - return NULL; + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + if (!ser) { + char *path = ecs_get_fullpath(world, type); + ecs_err("cannot serialize to JSON, '%s' has no reflection data", path); + ecs_os_free(path); + return -1; } - return ptr; -error: - return NULL; + return array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser); } -static -const char* meta_parse_constant( - const char *ptr, - meta_constant_t *token, - meta_parse_ctx_t *ctx) -{ - ptr = meta_open_scope(ptr, ctx); - if (!ptr) { - return NULL; - } - - token->is_value_set = false; - - /* Parse token, constant identifier */ - ptr = parse_c_identifier(ptr, token->name, NULL, ctx); - if (!ptr) { - return NULL; - } +char* ecs_array_to_json( + const ecs_world_t *world, + ecs_entity_t type, + const void* ptr, + int32_t count) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; - ptr = ecs_parse_eol_and_whitespace(ptr); - if (!ptr) { + if (ecs_array_to_json_buf(world, type, ptr, count, &str) != 0) { + ecs_strbuf_reset(&str); return NULL; } - /* Explicit value assignment */ - if (*ptr == '=') { - int64_t value = 0; - ptr = parse_c_digit(ptr + 1, &value); - token->value = value; - token->is_value_set = true; - } + return ecs_strbuf_get(&str); +} - /* Expect a ',' or '}' */ - if (*ptr != ',' && *ptr != '}') { - ecs_meta_error(ctx, ptr, "missing , after enum constant"); - goto error; - } +int ecs_ptr_to_json_buf( + const ecs_world_t *world, + ecs_entity_t type, + const void *ptr, + ecs_strbuf_t *buf) +{ + return ecs_array_to_json_buf(world, type, ptr, 0, buf); +} - if (*ptr == ',') { - return ptr + 1; - } else { - return ptr; - } -error: - return NULL; +char* ecs_ptr_to_json( + const ecs_world_t *world, + ecs_entity_t type, + const void* ptr) +{ + return ecs_array_to_json(world, type, ptr, 0); } static -const char* meta_parse_type( - const char *ptr, - meta_type_t *token, - meta_parse_ctx_t *ctx) +bool skip_id( + const ecs_world_t *world, + ecs_id_t id, + const ecs_entity_to_json_desc_t *desc, + ecs_entity_t ent, + ecs_entity_t inst, + ecs_entity_t *pred_out, + ecs_entity_t *obj_out, + ecs_entity_t *role_out, + bool *hidden_out) { - token->is_ptr = false; - token->is_const = false; - - ptr = ecs_parse_eol_and_whitespace(ptr); + bool is_base = ent != inst; + ecs_entity_t pred = 0, obj = 0, role = 0; + bool hidden = false; - /* Parse token, expect type identifier or ECS_PROPERTY */ - ptr = parse_c_identifier(ptr, token->type, token->params, ctx); - if (!ptr) { - goto error; + if (ECS_HAS_ROLE(id, PAIR)) { + pred = ecs_pair_first(world, id); + obj = ecs_pair_second(world, id); + } else { + pred = id & ECS_COMPONENT_MASK; + if (id & ECS_ROLE_MASK) { + role = id & ECS_ROLE_MASK; + } } - if (!strcmp(token->type, "ECS_PRIVATE")) { - /* Members from this point are not stored in metadata */ - ptr += ecs_os_strlen(ptr); - goto done; + if (!desc || !desc->serialize_meta_ids) { + if (pred == EcsIsA || pred == EcsChildOf || + pred == ecs_id(EcsIdentifier)) + { + return true; + } +#ifdef FLECS_DOC + if (pred == ecs_id(EcsDocDescription)) { + return true; + } +#endif } - /* If token is const, set const flag and continue parsing type */ - if (!strcmp(token->type, "const")) { - token->is_const = true; - - /* Parse type after const */ - ptr = parse_c_identifier(ptr + 1, token->type, token->params, ctx); + if (is_base) { + if (ecs_has_id(world, pred, EcsDontInherit)) { + return true; + } } - - /* Check if type is a pointer */ - ptr = ecs_parse_eol_and_whitespace(ptr); - if (*ptr == '*') { - token->is_ptr = true; - ptr ++; + if (!desc || !desc->serialize_private) { + if (ecs_has_id(world, pred, EcsPrivate)) { + return true; + } + } + if (is_base) { + if (ecs_get_object_for_id(world, inst, EcsIsA, id) != ent) { + hidden = true; + } + } + if (hidden && (!desc || !desc->serialize_hidden)) { + return true; } -done: - return ptr; -error: - return NULL; + *pred_out = pred; + *obj_out = obj; + *role_out = role; + if (hidden_out) *hidden_out = hidden; + + return false; } static -const char* meta_parse_member( - const char *ptr, - meta_member_t *token, - meta_parse_ctx_t *ctx) +int append_type_labels( + const ecs_world_t *world, + ecs_strbuf_t *buf, + const ecs_id_t *ids, + int32_t count, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - ptr = meta_open_scope(ptr, ctx); - if (!ptr) { - return NULL; - } - - token->count = 1; - token->is_partial = false; - - /* Parse member type */ - ptr = meta_parse_type(ptr, &token->type, ctx); - if (!ptr) { - token->is_partial = true; - goto error; - } - - /* Next token is the identifier */ - ptr = parse_c_identifier(ptr, token->name, NULL, ctx); - if (!ptr) { - goto error; + (void)world; (void)buf; (void)ids; (void)count; (void)ent; (void)inst; + (void)desc; + +#ifdef FLECS_DOC + if (!desc || !desc->serialize_id_labels) { + return 0; } - /* Skip whitespace between member and [ or ; */ - ptr = ecs_parse_eol_and_whitespace(ptr); + json_member(buf, "id_labels"); + json_array_push(buf); - /* Check if this is an array */ - char *array_start = strchr(token->name, '['); - if (!array_start) { - /* If the [ was separated by a space, it will not be parsed as part of - * the name */ - if (*ptr == '[') { - array_start = (char*)ptr; /* safe, will not be modified */ + int32_t i; + for (i = 0; i < count; i ++) { + ecs_entity_t pred = 0, obj = 0, role = 0; + if (skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) { + continue; } - } - - if (array_start) { - /* Check if the [ matches with a ] */ - char *array_end = strchr(array_start, ']'); - if (!array_end) { - ecs_meta_error(ctx, ptr, "missing ']'"); - goto error; - } else if (array_end - array_start == 0) { - ecs_meta_error(ctx, ptr, "dynamic size arrays are not supported"); - goto error; - } + if (desc && desc->serialize_id_labels) { + json_next(buf); - token->count = atoi(array_start + 1); + json_array_push(buf); + json_next(buf); + json_label(buf, world, pred); + if (obj) { + json_next(buf); + json_label(buf, world, obj); + } - if (array_start == ptr) { - /* If [ was found after name, continue parsing after ] */ - ptr = array_end + 1; - } else { - /* If [ was fonud in name, replace it with 0 terminator */ - array_start[0] = '\0'; + json_array_pop(buf); } } - /* Expect a ; */ - if (*ptr != ';') { - ecs_meta_error(ctx, ptr, "missing ; after member declaration"); - goto error; - } - - return ptr + 1; -error: - return NULL; + json_array_pop(buf); +#endif + return 0; } static -int meta_parse_desc( - const char *ptr, - meta_params_t *token, - meta_parse_ctx_t *ctx) +int append_type_values( + const ecs_world_t *world, + ecs_strbuf_t *buf, + const ecs_id_t *ids, + int32_t count, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - token->is_key_value = false; - token->is_fixed_size = false; - - ptr = ecs_parse_eol_and_whitespace(ptr); - if (*ptr != '(' && *ptr != '<') { - ecs_meta_error(ctx, ptr, - "expected '(' at start of collection definition"); - goto error; + if (!desc || !desc->serialize_values) { + return 0; } - ptr ++; + json_member(buf, "values"); + json_array_push(buf); - /* Parse type identifier */ - ptr = meta_parse_type(ptr, &token->type, ctx); - if (!ptr) { - goto error; - } + int32_t i; + for (i = 0; i < count; i ++) { + bool hidden; + ecs_entity_t pred = 0, obj = 0, role = 0; + ecs_id_t id = ids[i]; + if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, + &hidden)) + { + continue; + } - ptr = ecs_parse_eol_and_whitespace(ptr); + if (!hidden) { + bool serialized = false; + ecs_entity_t typeid = ecs_get_typeid(world, id); + if (typeid) { + const EcsMetaTypeSerialized *ser = ecs_get( + world, typeid, EcsMetaTypeSerialized); + if (ser) { + const void *ptr = ecs_get_id(world, ent, id); + ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - /* If next token is a ',' the first type was a key type */ - if (*ptr == ',') { - ptr = ecs_parse_eol_and_whitespace(ptr + 1); - - if (isdigit(*ptr)) { - int64_t value; - ptr = parse_c_digit(ptr, &value); - if (!ptr) { - goto error; + json_next(buf); + if (json_ser_type(world, ser->ops, ptr, buf) != 0) { + /* Entity contains invalid value */ + return -1; + } + serialized = true; + } + } + if (!serialized) { + json_next(buf); + json_number(buf, 0); } - - token->count = value; - token->is_fixed_size = true; } else { - token->key_type = token->type; - - /* Parse element type */ - ptr = meta_parse_type(ptr, &token->type, ctx); - ptr = ecs_parse_eol_and_whitespace(ptr); - - token->is_key_value = true; + if (!desc || desc->serialize_hidden) { + json_next(buf); + json_number(buf, 0); + } } } - if (*ptr != ')' && *ptr != '>') { - ecs_meta_error(ctx, ptr, - "expected ')' at end of collection definition"); - goto error; - } - + json_array_pop(buf); + return 0; -error: - return -1; } static -ecs_entity_t meta_lookup( - ecs_world_t *world, - meta_type_t *token, - const char *ptr, - int64_t count, - meta_parse_ctx_t *ctx); - -static -ecs_entity_t meta_lookup_array( - ecs_world_t *world, - ecs_entity_t e, - const char *params_decl, - meta_parse_ctx_t *ctx) +int append_type_info( + const ecs_world_t *world, + ecs_strbuf_t *buf, + const ecs_id_t *ids, + int32_t count, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - meta_parse_ctx_t param_ctx = { - .name = ctx->name, - .desc = params_decl - }; - - meta_params_t params; - if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { - goto error; - } - if (!params.is_fixed_size) { - ecs_meta_error(ctx, params_decl, "missing size for array"); - goto error; + if (!desc || !desc->serialize_type_info) { + return 0; } - if (!params.count) { - ecs_meta_error(ctx, params_decl, "invalid array size"); - goto error; - } + json_member(buf, "type_info"); + json_array_push(buf); - ecs_entity_t element_type = ecs_lookup_symbol(world, params.type.type, true); - if (!element_type) { - ecs_meta_error(ctx, params_decl, "unknown element type '%s'", - params.type.type); - } + int32_t i; + for (i = 0; i < count; i ++) { + bool hidden; + ecs_entity_t pred = 0, obj = 0, role = 0; + ecs_id_t id = ids[i]; + if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, + &hidden)) + { + continue; + } - if (!e) { - e = ecs_new_id(world); + if (!hidden) { + ecs_entity_t typeid = ecs_get_typeid(world, id); + if (typeid) { + json_next(buf); + if (ecs_type_info_to_json_buf(world, typeid, buf) != 0) { + return -1; + } + } else { + json_next(buf); + json_number(buf, 0); + } + } else { + if (!desc || desc->serialize_hidden) { + json_next(buf); + json_number(buf, 0); + } + } } - ecs_check(params.count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL); - - return ecs_set(world, e, EcsArray, { element_type, (int32_t)params.count }); -error: + json_array_pop(buf); + return 0; } static -ecs_entity_t meta_lookup_vector( - ecs_world_t *world, - ecs_entity_t e, - const char *params_decl, - meta_parse_ctx_t *ctx) +int append_type_hidden( + const ecs_world_t *world, + ecs_strbuf_t *buf, + const ecs_id_t *ids, + int32_t count, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - meta_parse_ctx_t param_ctx = { - .name = ctx->name, - .desc = params_decl - }; - - meta_params_t params; - if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { - goto error; + if (!desc || !desc->serialize_hidden) { + return 0; } - if (params.is_key_value) { - ecs_meta_error(ctx, params_decl, - "unexpected key value parameters for vector"); - goto error; + if (ent == inst) { + return 0; /* if this is not a base, components are never hidden */ } - ecs_entity_t element_type = meta_lookup( - world, ¶ms.type, params_decl, 1, ¶m_ctx); + json_member(buf, "hidden"); + json_array_push(buf); - if (!e) { - e = ecs_new_id(world); + int32_t i; + for (i = 0; i < count; i ++) { + bool hidden; + ecs_entity_t pred = 0, obj = 0, role = 0; + ecs_id_t id = ids[i]; + if (skip_id(world, id, desc, ent, inst, &pred, &obj, &role, + &hidden)) + { + continue; + } + + json_next(buf); + json_bool(buf, hidden); } - return ecs_set(world, e, EcsVector, { element_type }); -error: + json_array_pop(buf); + return 0; } + static -ecs_entity_t meta_lookup_bitmask( - ecs_world_t *world, - ecs_entity_t e, - const char *params_decl, - meta_parse_ctx_t *ctx) +int append_type( + const ecs_world_t *world, + ecs_strbuf_t *buf, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - (void)e; + ecs_type_t type = ecs_get_type(world, ent); + const ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t i, count = ecs_vector_count(type); - meta_parse_ctx_t param_ctx = { - .name = ctx->name, - .desc = params_decl - }; + json_member(buf, "ids"); + json_array_push(buf); - meta_params_t params; - if (meta_parse_desc(params_decl, ¶ms, ¶m_ctx)) { - goto error; - } + for (i = 0; i < count; i ++) { + ecs_entity_t pred = 0, obj = 0, role = 0; + if (skip_id(world, ids[i], desc, ent, inst, &pred, &obj, &role, 0)) { + continue; + } - if (params.is_key_value) { - ecs_meta_error(ctx, params_decl, - "unexpected key value parameters for bitmask"); - goto error; + + json_next(buf); + json_array_push(buf); + json_next(buf); + json_path(buf, world, pred); + if (obj || role) { + json_next(buf); + if (obj) { + json_path(buf, world, obj); + } else { + json_number(buf, 0); + } + if (role) { + json_next(buf); + json_string(buf, ecs_role_str(role)); + } + } + json_array_pop(buf); } - if (params.is_fixed_size) { - ecs_meta_error(ctx, params_decl, - "unexpected size for bitmask"); - goto error; + json_array_pop(buf); + + if (append_type_labels(world, buf, ids, count, ent, inst, desc)) { + return -1; + } + + if (append_type_values(world, buf, ids, count, ent, inst, desc)) { + return -1; } - ecs_entity_t bitmask_type = meta_lookup( - world, ¶ms.type, params_decl, 1, ¶m_ctx); - ecs_check(bitmask_type != 0, ECS_INVALID_PARAMETER, NULL); + if (append_type_info(world, buf, ids, count, ent, inst, desc)) { + return -1; + } -#ifndef FLECS_NDEBUG - /* Make sure this is a bitmask type */ - const EcsMetaType *type_ptr = ecs_get(world, bitmask_type, EcsMetaType); - ecs_check(type_ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(type_ptr->kind == EcsBitmaskType, ECS_INVALID_PARAMETER, NULL); -#endif + if (append_type_hidden(world, buf, ids, count, ent, inst, desc)) { + return -1; + } - return bitmask_type; -error: return 0; } static -ecs_entity_t meta_lookup( - ecs_world_t *world, - meta_type_t *token, - const char *ptr, - int64_t count, - meta_parse_ctx_t *ctx) +int append_base( + const ecs_world_t *world, + ecs_strbuf_t *buf, + ecs_entity_t ent, + ecs_entity_t inst, + const ecs_entity_to_json_desc_t *desc) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(token != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ptr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ctx != NULL, ECS_INTERNAL_ERROR, NULL); - - const char *typename = token->type; - ecs_entity_t type = 0; - - /* Parse vector type */ - if (!token->is_ptr) { - if (!ecs_os_strcmp(typename, "ecs_array")) { - type = meta_lookup_array(world, 0, token->params, ctx); - - } else if (!ecs_os_strcmp(typename, "ecs_vector") || - !ecs_os_strcmp(typename, "flecs::vector")) - { - type = meta_lookup_vector(world, 0, token->params, ctx); + ecs_type_t type = ecs_get_type(world, ent); + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t i, count = ecs_vector_count(type); - } else if (!ecs_os_strcmp(typename, "flecs::bitmask")) { - type = meta_lookup_bitmask(world, 0, token->params, ctx); + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + if (ECS_HAS_RELATION(id, EcsIsA)) { + if (append_base(world, buf, ecs_pair_second(world, id), inst, desc)) + { + return -1; + } + } + } - } else if (!ecs_os_strcmp(typename, "flecs::byte")) { - type = ecs_id(ecs_byte_t); + json_object_push(buf); + json_member(buf, "path"); + json_path(buf, world, ent); - } else if (!ecs_os_strcmp(typename, "char")) { - type = ecs_id(ecs_char_t); + if (append_type(world, buf, ent, inst, desc)) { + return -1; + } - } else if (!ecs_os_strcmp(typename, "bool") || - !ecs_os_strcmp(typename, "_Bool")) - { - type = ecs_id(ecs_bool_t); + json_object_pop(buf); - } else if (!ecs_os_strcmp(typename, "int8_t")) { - type = ecs_id(ecs_i8_t); - } else if (!ecs_os_strcmp(typename, "int16_t")) { - type = ecs_id(ecs_i16_t); - } else if (!ecs_os_strcmp(typename, "int32_t")) { - type = ecs_id(ecs_i32_t); - } else if (!ecs_os_strcmp(typename, "int64_t")) { - type = ecs_id(ecs_i64_t); + return 0; +} - } else if (!ecs_os_strcmp(typename, "uint8_t")) { - type = ecs_id(ecs_u8_t); - } else if (!ecs_os_strcmp(typename, "uint16_t")) { - type = ecs_id(ecs_u16_t); - } else if (!ecs_os_strcmp(typename, "uint32_t")) { - type = ecs_id(ecs_u32_t); - } else if (!ecs_os_strcmp(typename, "uint64_t")) { - type = ecs_id(ecs_u64_t); +int ecs_entity_to_json_buf( + const ecs_world_t *world, + ecs_entity_t entity, + ecs_strbuf_t *buf, + const ecs_entity_to_json_desc_t *desc) +{ + if (!entity || !ecs_is_valid(world, entity)) { + return -1; + } - } else if (!ecs_os_strcmp(typename, "float")) { - type = ecs_id(ecs_f32_t); - } else if (!ecs_os_strcmp(typename, "double")) { - type = ecs_id(ecs_f64_t); + json_object_push(buf); - } else if (!ecs_os_strcmp(typename, "ecs_entity_t")) { - type = ecs_id(ecs_entity_t); + if (!desc || desc->serialize_path) { + char *path = ecs_get_fullpath(world, entity); + json_member(buf, "path"); + json_string(buf, path); + ecs_os_free(path); + } - } else if (!ecs_os_strcmp(typename, "char*")) { - type = ecs_id(ecs_string_t); +#ifdef FLECS_DOC + if (desc && desc->serialize_label) { + json_member(buf, "label"); + const char *doc_name = ecs_doc_get_name(world, entity); + if (doc_name) { + json_string(buf, doc_name); } else { - type = ecs_lookup_symbol(world, typename, true); + char num_buf[20]; + ecs_os_sprintf(num_buf, "%u", (uint32_t)entity); + json_string(buf, num_buf); } - } else { - if (!ecs_os_strcmp(typename, "char")) { - typename = "flecs.meta.string"; - } else - if (token->is_ptr) { - typename = "flecs.meta.uptr"; - } else - if (!ecs_os_strcmp(typename, "char*") || - !ecs_os_strcmp(typename, "flecs::string")) - { - typename = "flecs.meta.string"; + } + + if (desc && desc->serialize_brief) { + const char *doc_brief = ecs_doc_get_brief(world, entity); + if (doc_brief) { + json_member(buf, "brief"); + json_string(buf, doc_brief); } + } - type = ecs_lookup_symbol(world, typename, true); + if (desc && desc->serialize_link) { + const char *doc_link = ecs_doc_get_link(world, entity); + if (doc_link) { + json_member(buf, "link"); + json_string(buf, doc_link); + } } +#endif - if (count != 1) { - ecs_check(count <= INT32_MAX, ECS_INVALID_PARAMETER, NULL); + ecs_type_t type = ecs_get_type(world, entity); + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t i, count = ecs_vector_count(type); - type = ecs_set(world, 0, EcsArray, {type, (int32_t)count}); + if (!desc || desc->serialize_base) { + if (ecs_has_pair(world, entity, EcsIsA, EcsWildcard)) { + json_member(buf, "is_a"); + json_array_push(buf); + + for (i = 0; i < count; i ++) { + ecs_id_t id = ids[i]; + if (ECS_HAS_RELATION(id, EcsIsA)) { + if (append_base( + world, buf, ecs_pair_second(world, id), entity, desc)) + { + return -1; + } + } + } + + json_array_pop(buf); + } } - if (!type) { - ecs_meta_error(ctx, ptr, "unknown type '%s'", typename); + if (append_type(world, buf, entity, entity, desc)) { goto error; } - return type; -error: + json_object_pop(buf); + return 0; +error: + return -1; } -static -int meta_parse_struct( - ecs_world_t *world, - ecs_entity_t t, - const char *desc) +char* ecs_entity_to_json( + const ecs_world_t *world, + ecs_entity_t entity, + const ecs_entity_to_json_desc_t *desc) { - const char *ptr = desc; - const char *name = ecs_get_name(world, t); + ecs_strbuf_t buf = ECS_STRBUF_INIT; - meta_member_t token; - meta_parse_ctx_t ctx = { - .name = name, - .desc = ptr - }; + if (ecs_entity_to_json_buf(world, entity, &buf, desc) != 0) { + ecs_strbuf_reset(&buf); + return NULL; + } - ecs_entity_t old_scope = ecs_set_scope(world, t); + return ecs_strbuf_get(&buf); +} - while ((ptr = meta_parse_member(ptr, &token, &ctx)) && ptr[0]) { - ecs_entity_t m = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = token.name - }); +static +bool skip_variable( + const char *name) +{ + if (!name || name[0] == '_' || name[0] == '.') { + return true; + } else { + return false; + } +} - ecs_entity_t type = meta_lookup( - world, &token.type, ptr, 1, &ctx); - if (!type) { - goto error; - } +static +void serialize_id( + const ecs_world_t *world, + ecs_id_t id, + ecs_strbuf_t *buf) +{ + json_id(buf, world, id); +} - ecs_set(world, m, EcsMember, { - .type = type, - .count = (ecs_size_t)token.count - }); +static +void serialize_iter_ids( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) +{ + int32_t term_count = it->term_count; + if (!term_count) { + return; } - ecs_set_scope(world, old_scope); + json_member(buf, "ids"); + json_array_push(buf); - return 0; -error: - return -1; + for (int i = 0; i < term_count; i ++) { + json_next(buf); + serialize_id(world, it->terms[i].id, buf); + } + + json_array_pop(buf); } static -int meta_parse_constants( - ecs_world_t *world, - ecs_entity_t t, - const char *desc, - bool is_bitmask) +void serialize_type_info( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(t != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(desc != NULL, ECS_INTERNAL_ERROR, NULL); - - const char *ptr = desc; - const char *name = ecs_get_name(world, t); + int32_t term_count = it->term_count; + if (!term_count) { + return; + } - meta_parse_ctx_t ctx = { - .name = name, - .desc = ptr - }; + json_member(buf, "type_info"); + json_object_push(buf); - meta_constant_t token; - int64_t last_value = 0; + for (int i = 0; i < term_count; i ++) { + json_next(buf); + ecs_entity_t typeid = ecs_get_typeid(world, it->terms[i].id); + if (typeid) { + serialize_id(world, typeid, buf); + ecs_strbuf_appendstr(buf, ":"); + ecs_type_info_to_json_buf(world, typeid, buf); + } else { + serialize_id(world, it->terms[i].id, buf); + ecs_strbuf_appendstr(buf, ":"); + ecs_strbuf_appendstr(buf, "0"); + } + } - ecs_entity_t old_scope = ecs_set_scope(world, t); + json_object_pop(buf); +} - while ((ptr = meta_parse_constant(ptr, &token, &ctx))) { - if (token.is_value_set) { - last_value = token.value; - } else if (is_bitmask) { - ecs_meta_error(&ctx, ptr, - "bitmask requires explicit value assignment"); - goto error; - } +static +void serialize_iter_variables(ecs_iter_t *it, ecs_strbuf_t *buf) { + char **variable_names = it->variable_names; + int32_t var_count = it->variable_count; + int32_t actual_count = 0; - ecs_entity_t c = ecs_entity_init(world, &(ecs_entity_desc_t) { - .name = token.name - }); + for (int i = 0; i < var_count; i ++) { + const char *var_name = variable_names[i]; + if (skip_variable(var_name)) continue; - if (!is_bitmask) { - ecs_set_pair_object(world, c, EcsConstant, ecs_i32_t, - {(ecs_i32_t)last_value}); - } else { - ecs_set_pair_object(world, c, EcsConstant, ecs_u32_t, - {(ecs_u32_t)last_value}); + if (!actual_count) { + json_member(buf, "vars"); + json_array_push(buf); + actual_count ++; } - last_value ++; + ecs_strbuf_list_next(buf); + json_string(buf, var_name); } - ecs_set_scope(world, old_scope); - - return 0; -error: - return -1; + if (actual_count) { + json_array_pop(buf); + } } static -int meta_parse_enum( - ecs_world_t *world, - ecs_entity_t t, - const char *desc) +void serialize_iter_result_ids( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - ecs_add(world, t, EcsEnum); - return meta_parse_constants(world, t, desc, false); + json_member(buf, "ids"); + json_array_push(buf); + + for (int i = 0; i < it->term_count; i ++) { + json_next(buf); + serialize_id(world, ecs_term_id(it, i + 1), buf); + } + + json_array_pop(buf); } static -int meta_parse_bitmask( - ecs_world_t *world, - ecs_entity_t t, - const char *desc) +void serialize_iter_result_subjects( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - ecs_add(world, t, EcsBitmask); - return meta_parse_constants(world, t, desc, true); -} + json_member(buf, "subjects"); + json_array_push(buf); -int ecs_meta_from_desc( - ecs_world_t *world, - ecs_entity_t component, - ecs_type_kind_t kind, - const char *desc) -{ - switch(kind) { - case EcsStructType: - if (meta_parse_struct(world, component, desc)) { - goto error; - } - break; - case EcsEnumType: - if (meta_parse_enum(world, component, desc)) { - goto error; - } - break; - case EcsBitmaskType: - if (meta_parse_bitmask(world, component, desc)) { - goto error; + for (int i = 0; i < it->term_count; i ++) { + json_next(buf); + ecs_entity_t subj = it->subjects[i]; + if (subj) { + json_path(buf, world, subj); + } else { + json_literal(buf, "0"); } - break; - default: - break; } - return 0; -error: - return -1; + json_array_pop(buf); } -#endif +static +void serialize_iter_result_is_set( + const ecs_iter_t *it, + ecs_strbuf_t *buf) +{ + json_member(buf, "is_set"); + json_array_push(buf); + for (int i = 0; i < it->term_count; i ++) { + ecs_strbuf_list_next(buf); + if (ecs_term_is_set(it, i + 1)) { + json_true(buf); + } else { + json_false(buf); + } + } -#ifdef FLECS_APP + json_array_pop(buf); +} static -int default_run_action( - ecs_world_t *world, - ecs_app_desc_t *desc) +void serialize_iter_result_variables( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - if (desc->init) { - desc->init(world); - } + char **variable_names = it->variable_names; + ecs_entity_t *variables = it->variables; + int32_t var_count = it->variable_count; + int32_t actual_count = 0; - int result; - while ((result = ecs_app_run_frame(world, desc)) == 0) { } + for (int i = 0; i < var_count; i ++) { + const char *var_name = variable_names[i]; + if (skip_variable(var_name)) continue; - if (result == 1) { - return 0; /* Normal exit */ - } else { - return result; /* Error code */ + if (!actual_count) { + json_member(buf, "vars"); + json_array_push(buf); + actual_count ++; + } + + ecs_strbuf_list_next(buf); + json_path(buf, world, variables[i]); + } + + if (actual_count) { + json_array_pop(buf); } } static -int default_frame_action( - ecs_world_t *world, - const ecs_app_desc_t *desc) +void serialize_iter_result_variable_labels( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - return !ecs_progress(world, desc->delta_time); -} + char **variable_names = it->variable_names; + ecs_entity_t *variables = it->variables; + int32_t var_count = it->variable_count; + int32_t actual_count = 0; -static ecs_app_run_action_t run_action = default_run_action; -static ecs_app_frame_action_t frame_action = default_frame_action; -static ecs_app_desc_t ecs_app_desc; + for (int i = 0; i < var_count; i ++) { + const char *var_name = variable_names[i]; + if (skip_variable(var_name)) continue; -int ecs_app_run( - ecs_world_t *world, - ecs_app_desc_t *desc) -{ - ecs_app_desc = *desc; + if (!actual_count) { + json_member(buf, "var_labels"); + json_array_push(buf); + actual_count ++; + } - /* Don't set FPS & threads if custom run action is set, as the platform on - * which the app is running may not support it. */ - if (run_action == default_run_action) { - ecs_set_target_fps(world, ecs_app_desc.target_fps); - ecs_set_threads(world, ecs_app_desc.threads); + ecs_strbuf_list_next(buf); + json_label(buf, world, variables[i]); } - /* REST server enables connecting to app with explorer */ - if (desc->enable_rest) { -#ifdef FLECS_REST - ecs_set(world, EcsWorld, EcsRest, {.port = 0}); -#else - ecs_warn("cannot enable remote API, REST addon not available"); -#endif + if (actual_count) { + json_array_pop(buf); } - - return run_action(world, &ecs_app_desc); } -int ecs_app_run_frame( - ecs_world_t *world, - const ecs_app_desc_t *desc) +static +void serialize_iter_result_entities( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - return frame_action(world, desc); + int32_t count = it->count; + if (!it->count) { + return; + } + + json_member(buf, "entities"); + json_array_push(buf); + + ecs_entity_t *entities = it->entities; + + for (int i = 0; i < count; i ++) { + json_next(buf); + json_path(buf, world, entities[i]); + } + + json_array_pop(buf); } -int ecs_app_set_run_action( - ecs_app_run_action_t callback) +static +void serialize_iter_result_entity_labels( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - if (run_action != default_run_action) { - ecs_err("run action already set"); - return -1; + int32_t count = it->count; + if (!it->count) { + return; } - run_action = callback; + json_member(buf, "entity_labels"); + json_array_push(buf); - return 0; + ecs_entity_t *entities = it->entities; + + for (int i = 0; i < count; i ++) { + json_next(buf); + json_label(buf, world, entities[i]); + } + + json_array_pop(buf); } -int ecs_app_set_frame_action( - ecs_app_frame_action_t callback) +static +void serialize_iter_result_values( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf) { - if (frame_action != default_frame_action) { - ecs_err("frame action already set"); - return -1; + int32_t count = it->count; + if (!it->count) { + return; } - frame_action = callback; + json_member(buf, "values"); + json_array_push(buf); - return 0; + int32_t i, term_count = it->term_count; + for (i = 0; i < term_count; i ++) { + ecs_strbuf_list_next(buf); + + const void *ptr = NULL; + if (it->ptrs) { + ptr = it->ptrs[i]; + } + if (!ptr) { + /* No data in column. Append 0 if this is not an optional term */ + if (ecs_term_is_set(it, i + 1)) { + json_literal(buf, "0"); + continue; + } + } + + if (ecs_term_is_writeonly(it, i + 1)) { + json_literal(buf, "0"); + continue; + } + + /* Get component id (can be different in case of pairs) */ + ecs_entity_t type = ecs_get_typeid(world, it->ids[i]); + if (!type) { + /* Odd, we have a ptr but no Component? Not the place of the + * serializer to complain about that. */ + json_literal(buf, "0"); + continue; + } + + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + if (!comp) { + /* Also odd, typeid but not a component? */ + json_literal(buf, "0"); + continue; + } + + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + if (!ser) { + /* Not odd, component just has no reflection data */ + json_literal(buf, "0"); + continue; + } + + /* If term is not set, append empty array. This indicates that the term + * could have had data but doesn't */ + if (!ecs_term_is_set(it, i + 1)) { + ecs_assert(ptr == NULL, ECS_INTERNAL_ERROR, NULL); + json_array_push(buf); + json_array_pop(buf); + continue; + } + + if (ecs_term_is_owned(it, i + 1)) { + array_to_json_buf_w_type_data(world, ptr, count, buf, comp, ser); + } else { + array_to_json_buf_w_type_data(world, ptr, 0, buf, comp, ser); + } + } + + json_array_pop(buf); } -#endif +static +void serialize_iter_result( + const ecs_world_t *world, + const ecs_iter_t *it, + ecs_strbuf_t *buf, + const ecs_iter_to_json_desc_t *desc) +{ + json_next(buf); + json_object_push(buf); + /* Each result can be matched with different component ids. Add them to + * the result so clients know with which component an entity was matched */ + if (!desc || desc->serialize_ids) { + serialize_iter_result_ids(world, it, buf); + } -/* Roles */ -const ecs_id_t ECS_CASE = (ECS_ROLE | (0x7Cull << 56)); -const ecs_id_t ECS_SWITCH = (ECS_ROLE | (0x7Bull << 56)); -const ecs_id_t ECS_PAIR = (ECS_ROLE | (0x7Aull << 56)); -const ecs_id_t ECS_OVERRIDE = (ECS_ROLE | (0x75ull << 56)); -const ecs_id_t ECS_DISABLED = (ECS_ROLE | (0x74ull << 56)); + /* Include information on which entity the term is matched with */ + if (!desc || desc->serialize_ids) { + serialize_iter_result_subjects(world, it, buf); + } -/** Builtin component ids */ -const ecs_entity_t ecs_id(EcsComponent) = 1; -const ecs_entity_t ecs_id(EcsComponentLifecycle) = 2; -const ecs_entity_t ecs_id(EcsType) = 3; -const ecs_entity_t ecs_id(EcsIdentifier) = 4; -const ecs_entity_t ecs_id(EcsTrigger) = 5; -const ecs_entity_t ecs_id(EcsQuery) = 6; -const ecs_entity_t ecs_id(EcsObserver) = 7; -const ecs_entity_t ecs_id(EcsIterable) = 8; + /* Write variable values for current result */ + if (!desc || desc->serialize_variables) { + serialize_iter_result_variables(world, it, buf); + } -/* System module component ids */ -const ecs_entity_t ecs_id(EcsSystem) = 10; -const ecs_entity_t ecs_id(EcsTickSource) = 11; + /* Write labels for variables */ + if (desc && desc->serialize_variable_labels) { + serialize_iter_result_variable_labels(world, it, buf); + } -/** Pipeline module component ids */ -const ecs_entity_t ecs_id(EcsPipelineQuery) = 12; + /* Include information on which terms are set, to support optional terms */ + if (!desc || desc->serialize_is_set) { + serialize_iter_result_is_set(it, buf); + } -/** Timer module component ids */ -const ecs_entity_t ecs_id(EcsTimer) = 13; -const ecs_entity_t ecs_id(EcsRateFilter) = 14; + /* Write entity ids for current result (for queries with This terms) */ + if (!desc || desc->serialize_entities) { + serialize_iter_result_entities(world, it, buf); + } -/** Meta module component ids */ -const ecs_entity_t ecs_id(EcsMetaType) = 15; -const ecs_entity_t ecs_id(EcsMetaTypeSerialized) = 16; -const ecs_entity_t ecs_id(EcsPrimitive) = 17; -const ecs_entity_t ecs_id(EcsEnum) = 18; -const ecs_entity_t ecs_id(EcsBitmask) = 19; -const ecs_entity_t ecs_id(EcsMember) = 20; -const ecs_entity_t ecs_id(EcsStruct) = 21; -const ecs_entity_t ecs_id(EcsArray) = 22; -const ecs_entity_t ecs_id(EcsVector) = 23; -const ecs_entity_t ecs_id(EcsUnit) = 24; -const ecs_entity_t ecs_id(EcsUnitPrefix) = 25; + /* Write labels for entities */ + if (desc && desc->serialize_entity_labels) { + serialize_iter_result_entity_labels(world, it, buf); + } -/* Core scopes & entities */ -const ecs_entity_t EcsWorld = ECS_HI_COMPONENT_ID + 0; -const ecs_entity_t EcsFlecs = ECS_HI_COMPONENT_ID + 1; -const ecs_entity_t EcsFlecsCore = ECS_HI_COMPONENT_ID + 2; -const ecs_entity_t EcsFlecsHidden = ECS_HI_COMPONENT_ID + 3; -const ecs_entity_t EcsModule = ECS_HI_COMPONENT_ID + 4; -const ecs_entity_t EcsPrivate = ECS_HI_COMPONENT_ID + 5; -const ecs_entity_t EcsPrefab = ECS_HI_COMPONENT_ID + 6; -const ecs_entity_t EcsDisabled = ECS_HI_COMPONENT_ID + 7; + /* Serialize component values */ + if (!desc || desc->serialize_values) { + serialize_iter_result_values(world, it, buf); + } -/* Relation properties */ -const ecs_entity_t EcsWildcard = ECS_HI_COMPONENT_ID + 10; -const ecs_entity_t EcsAny = ECS_HI_COMPONENT_ID + 11; -const ecs_entity_t EcsThis = ECS_HI_COMPONENT_ID + 12; -const ecs_entity_t EcsTransitive = ECS_HI_COMPONENT_ID + 13; -const ecs_entity_t EcsReflexive = ECS_HI_COMPONENT_ID + 14; -const ecs_entity_t EcsSymmetric = ECS_HI_COMPONENT_ID + 15; -const ecs_entity_t EcsFinal = ECS_HI_COMPONENT_ID + 16; -const ecs_entity_t EcsDontInherit = ECS_HI_COMPONENT_ID + 17; -const ecs_entity_t EcsTag = ECS_HI_COMPONENT_ID + 18; -const ecs_entity_t EcsExclusive = ECS_HI_COMPONENT_ID + 19; -const ecs_entity_t EcsAcyclic = ECS_HI_COMPONENT_ID + 20; -const ecs_entity_t EcsWith = ECS_HI_COMPONENT_ID + 21; + json_object_pop(buf); +} -/* Builtin relations */ -const ecs_entity_t EcsChildOf = ECS_HI_COMPONENT_ID + 25; -const ecs_entity_t EcsIsA = ECS_HI_COMPONENT_ID + 26; +int ecs_iter_to_json_buf( + const ecs_world_t *world, + ecs_iter_t *it, + ecs_strbuf_t *buf, + const ecs_iter_to_json_desc_t *desc) +{ + ecs_time_t duration = {0}; + if (desc && desc->measure_eval_duration) { + ecs_time_measure(&duration); + } -/* Identifier tags */ -const ecs_entity_t EcsName = ECS_HI_COMPONENT_ID + 27; -const ecs_entity_t EcsSymbol = ECS_HI_COMPONENT_ID + 28; -const ecs_entity_t EcsAlias = ECS_HI_COMPONENT_ID + 29; + json_object_push(buf); -/* Events */ -const ecs_entity_t EcsOnAdd = ECS_HI_COMPONENT_ID + 30; -const ecs_entity_t EcsOnRemove = ECS_HI_COMPONENT_ID + 31; -const ecs_entity_t EcsOnSet = ECS_HI_COMPONENT_ID + 32; -const ecs_entity_t EcsUnSet = ECS_HI_COMPONENT_ID + 33; -const ecs_entity_t EcsOnDelete = ECS_HI_COMPONENT_ID + 34; -const ecs_entity_t EcsOnCreateTable = ECS_HI_COMPONENT_ID + 35; -const ecs_entity_t EcsOnDeleteTable = ECS_HI_COMPONENT_ID + 36; -const ecs_entity_t EcsOnTableEmpty = ECS_HI_COMPONENT_ID + 37; -const ecs_entity_t EcsOnTableFill = ECS_HI_COMPONENT_ID + 38; -const ecs_entity_t EcsOnCreateTrigger = ECS_HI_COMPONENT_ID + 39; -const ecs_entity_t EcsOnDeleteTrigger = ECS_HI_COMPONENT_ID + 40; -const ecs_entity_t EcsOnDeleteObservable = ECS_HI_COMPONENT_ID + 41; -const ecs_entity_t EcsOnComponentLifecycle = ECS_HI_COMPONENT_ID + 42; -const ecs_entity_t EcsOnDeleteObject = ECS_HI_COMPONENT_ID + 43; + /* Serialize component ids of the terms (usually provided by query) */ + if (!desc || desc->serialize_term_ids) { + serialize_iter_ids(world, it, buf); + } -/* Actions */ -const ecs_entity_t EcsRemove = ECS_HI_COMPONENT_ID + 50; -const ecs_entity_t EcsDelete = ECS_HI_COMPONENT_ID + 51; -const ecs_entity_t EcsThrow = ECS_HI_COMPONENT_ID + 52; + /* Serialize type info if enabled */ + if (desc && desc->serialize_type_info) { + serialize_type_info(world, it, buf); + } -/* Misc */ -const ecs_entity_t EcsDefaultChildComponent = ECS_HI_COMPONENT_ID + 55; + /* Serialize variable names, if iterator has any */ + serialize_iter_variables(it, buf); -/* Systems */ -const ecs_entity_t EcsMonitor = ECS_HI_COMPONENT_ID + 61; -const ecs_entity_t EcsInactive = ECS_HI_COMPONENT_ID + 63; -const ecs_entity_t EcsPipeline = ECS_HI_COMPONENT_ID + 64; -const ecs_entity_t EcsPreFrame = ECS_HI_COMPONENT_ID + 65; -const ecs_entity_t EcsOnLoad = ECS_HI_COMPONENT_ID + 66; -const ecs_entity_t EcsPostLoad = ECS_HI_COMPONENT_ID + 67; -const ecs_entity_t EcsPreUpdate = ECS_HI_COMPONENT_ID + 68; -const ecs_entity_t EcsOnUpdate = ECS_HI_COMPONENT_ID + 69; -const ecs_entity_t EcsOnValidate = ECS_HI_COMPONENT_ID + 70; -const ecs_entity_t EcsPostUpdate = ECS_HI_COMPONENT_ID + 71; -const ecs_entity_t EcsPreStore = ECS_HI_COMPONENT_ID + 72; -const ecs_entity_t EcsOnStore = ECS_HI_COMPONENT_ID + 73; -const ecs_entity_t EcsPostFrame = ECS_HI_COMPONENT_ID + 74; + /* Serialize results */ + json_member(buf, "results"); + json_array_push(buf); -/* Meta primitive components (don't use low ids to save id space) */ -const ecs_entity_t ecs_id(ecs_bool_t) = ECS_HI_COMPONENT_ID + 80; -const ecs_entity_t ecs_id(ecs_char_t) = ECS_HI_COMPONENT_ID + 81; -const ecs_entity_t ecs_id(ecs_byte_t) = ECS_HI_COMPONENT_ID + 82; -const ecs_entity_t ecs_id(ecs_u8_t) = ECS_HI_COMPONENT_ID + 83; -const ecs_entity_t ecs_id(ecs_u16_t) = ECS_HI_COMPONENT_ID + 84; -const ecs_entity_t ecs_id(ecs_u32_t) = ECS_HI_COMPONENT_ID + 85; -const ecs_entity_t ecs_id(ecs_u64_t) = ECS_HI_COMPONENT_ID + 86; -const ecs_entity_t ecs_id(ecs_uptr_t) = ECS_HI_COMPONENT_ID + 87; -const ecs_entity_t ecs_id(ecs_i8_t) = ECS_HI_COMPONENT_ID + 88; -const ecs_entity_t ecs_id(ecs_i16_t) = ECS_HI_COMPONENT_ID + 89; -const ecs_entity_t ecs_id(ecs_i32_t) = ECS_HI_COMPONENT_ID + 90; -const ecs_entity_t ecs_id(ecs_i64_t) = ECS_HI_COMPONENT_ID + 91; -const ecs_entity_t ecs_id(ecs_iptr_t) = ECS_HI_COMPONENT_ID + 92; -const ecs_entity_t ecs_id(ecs_f32_t) = ECS_HI_COMPONENT_ID + 93; -const ecs_entity_t ecs_id(ecs_f64_t) = ECS_HI_COMPONENT_ID + 94; -const ecs_entity_t ecs_id(ecs_string_t) = ECS_HI_COMPONENT_ID + 95; -const ecs_entity_t ecs_id(ecs_entity_t) = ECS_HI_COMPONENT_ID + 96; -const ecs_entity_t EcsConstant = ECS_HI_COMPONENT_ID + 97; -const ecs_entity_t EcsQuantity = ECS_HI_COMPONENT_ID + 98; + /* Use instancing for improved performance */ + it->is_instanced = true; -/* Doc module components */ -const ecs_entity_t ecs_id(EcsDocDescription) =ECS_HI_COMPONENT_ID + 100; -const ecs_entity_t EcsDocBrief = ECS_HI_COMPONENT_ID + 101; -const ecs_entity_t EcsDocDetail = ECS_HI_COMPONENT_ID + 102; -const ecs_entity_t EcsDocLink = ECS_HI_COMPONENT_ID + 103; + ecs_iter_next_action_t next = it->next; + while (next(it)) { + serialize_iter_result(world, it, buf, desc); + } -/* REST module components */ -const ecs_entity_t ecs_id(EcsRest) = ECS_HI_COMPONENT_ID + 105; + json_array_pop(buf); + + if (desc && desc->measure_eval_duration) { + double dt = ecs_time_measure(&duration); + json_member(buf, "eval_duration"); + json_number(buf, dt); + } -/* Default lookup path */ -static ecs_entity_t ecs_default_lookup_path[2] = { 0, 0 }; + json_object_pop(buf); -/* -- Private functions -- */ + return 0; +} -const ecs_stage_t* flecs_stage_from_readonly_world( - const ecs_world_t *world) +char* ecs_iter_to_json( + const ecs_world_t *world, + ecs_iter_t *it, + const ecs_iter_to_json_desc_t *desc) { - ecs_assert(ecs_poly_is(world, ecs_world_t) || - ecs_poly_is(world, ecs_stage_t), - ECS_INTERNAL_ERROR, - NULL); - - if (ecs_poly_is(world, ecs_world_t)) { - return &world->stage; + ecs_strbuf_t buf = ECS_STRBUF_INIT; - } else if (ecs_poly_is(world, ecs_stage_t)) { - return (ecs_stage_t*)world; + if (ecs_iter_to_json_buf(world, it, &buf, desc)) { + ecs_strbuf_reset(&buf); + return NULL; } - - return NULL; + + return ecs_strbuf_get(&buf); } -ecs_stage_t *flecs_stage_from_world( - ecs_world_t **world_ptr) -{ - ecs_world_t *world = *world_ptr; +#endif - ecs_assert(ecs_poly_is(world, ecs_world_t) || - ecs_poly_is(world, ecs_stage_t), - ECS_INTERNAL_ERROR, - NULL); - if (ecs_poly_is(world, ecs_world_t)) { - ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); - return &world->stage; - } else if (ecs_poly_is(world, ecs_stage_t)) { - ecs_stage_t *stage = (ecs_stage_t*)world; - *world_ptr = stage->world; - return stage; - } - - return NULL; -} +#ifdef FLECS_JSON -ecs_world_t* flecs_suspend_readonly( - const ecs_world_t *stage_world, - ecs_suspend_readonly_state_t *state) +const char* ecs_parse_json( + const ecs_world_t *world, + const char *ptr, + ecs_entity_t type, + void *data_out, + const ecs_parse_json_desc_t *desc) { - ecs_assert(stage_world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL); + char token[ECS_MAX_TOKEN_SIZE]; + int depth = 0; - ecs_world_t *world = (ecs_world_t*)ecs_get_world(stage_world); - ecs_poly_assert(world, ecs_world_t); + const char *name = NULL; + const char *expr = NULL; - bool is_readonly = world->is_readonly; - bool is_deferred = ecs_is_deferred(world); + ptr = ecs_parse_fluff(ptr, NULL); - if (!world->is_readonly && !is_deferred) { - state->is_readonly = false; - state->is_deferred = false; - return world; + ecs_meta_cursor_t cur = ecs_meta_cursor(world, type, data_out); + if (cur.valid == false) { + return NULL; } - ecs_dbg_3("suspending readonly mode"); + if (desc) { + name = desc->name; + expr = desc->expr; + } - /* Cannot suspend when running with multiple threads */ - ecs_assert(ecs_get_stage_count(world) <= 1, - ECS_INVALID_WHILE_ITERATING, NULL); + while ((ptr = ecs_parse_expr_token(name, expr, ptr, token))) { - state->is_readonly = is_readonly; - state->is_deferred = is_deferred; + ptr = ecs_parse_fluff(ptr, NULL); - /* Silence readonly checks */ - world->is_readonly = false; + if (!ecs_os_strcmp(token, "{")) { + depth ++; + if (ecs_meta_push(&cur) != 0) { + goto error; + } - /* Hack around safety checks (this ought to look ugly) */ - ecs_world_t *temp_world = world; - ecs_stage_t *stage = flecs_stage_from_world(&temp_world); - state->defer_count = stage->defer; - state->defer_queue = stage->defer_queue; - state->scope = world->stage.scope; - state->with = world->stage.with; - stage->defer = 0; - stage->defer_queue = NULL; + if (ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected '['"); + return NULL; + } + } - if (&world->stage != (ecs_stage_t*)stage_world) { - world->stage.scope = stage->scope; - world->stage.with = stage->with; - } - - return world; -} + else if (!ecs_os_strcmp(token, "}")) { + depth --; -void flecs_resume_readonly( - ecs_world_t *world, - ecs_suspend_readonly_state_t *state) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_assert(state != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_world_t *temp_world = world; - ecs_stage_t *stage = flecs_stage_from_world(&temp_world); + if (ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected ']'"); + return NULL; + } - if (state->is_readonly || state->is_deferred) { - ecs_dbg_3("resuming readonly mode"); - - ecs_force_aperiodic(world); + if (ecs_meta_pop(&cur) != 0) { + goto error; + } + } - /* Restore readonly state / defer count */ - world->is_readonly = state->is_readonly; - stage->defer = state->defer_count; - stage->defer_queue = state->defer_queue; - world->stage.scope = state->scope; - world->stage.with = state->with; - } -} + else if (!ecs_os_strcmp(token, "[")) { + depth ++; + if (ecs_meta_push(&cur) != 0) { + goto error; + } -/* Evaluate component monitor. If a monitored entity changed it will have set a - * flag in one of the world's component monitors. Queries can register - * themselves with component monitors to determine whether they need to rematch - * with tables. */ -static -void eval_component_monitor( - ecs_world_t *world) -{ - ecs_poly_assert(world, ecs_world_t); + if (!ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected '{'"); + return NULL; + } + } - ecs_relation_monitor_t *rm = &world->monitors; + else if (!ecs_os_strcmp(token, "]")) { + depth --; - if (!rm->is_dirty) { - return; - } + if (!ecs_meta_is_collection(&cur)) { + ecs_parser_error(name, expr, ptr - expr, "expected '}'"); + return NULL; + } - ecs_map_iter_t it = ecs_map_iter(&rm->monitor_sets); - ecs_monitor_set_t *ms; + if (ecs_meta_pop(&cur) != 0) { + goto error; + } + } - while ((ms = ecs_map_next(&it, ecs_monitor_set_t, NULL))) { - if (!ms->is_dirty) { - continue; + else if (!ecs_os_strcmp(token, ",")) { + if (ecs_meta_next(&cur) != 0) { + goto error; + } } - ecs_map_iter_t mit = ecs_map_iter(&ms->monitors); - ecs_monitor_t *m; - while ((m = ecs_map_next(&mit, ecs_monitor_t, NULL))) { - if (!m->is_dirty) { - continue; + else if (!ecs_os_strcmp(token, "null")) { + if (ecs_meta_set_null(&cur) != 0) { + goto error; } + } - ecs_vector_each(m->queries, ecs_query_t*, q_ptr, { - flecs_query_notify(world, *q_ptr, &(ecs_query_event_t) { - .kind = EcsQueryTableRematch - }); - }); + else if (token[0] == '\"') { + if (ptr[0] == ':') { + /* Member assignment */ + ptr ++; - m->is_dirty = false; + /* Strip trailing " */ + ecs_size_t len = ecs_os_strlen(token); + if (token[len - 1] != '"') { + ecs_parser_error(name, expr, ptr - expr, "expected \""); + return NULL; + } else { + token[len - 1] = '\0'; + } + + if (ecs_meta_member(&cur, token + 1) != 0) { + goto error; + } + } else { + if (ecs_meta_set_string_literal(&cur, token) != 0) { + goto error; + } + } } - ms->is_dirty = false; + else { + if (ecs_meta_set_string(&cur, token) != 0) { + goto error; + } + } + + if (!depth) { + break; + } } - rm->is_dirty = false; + return ptr; +error: + return NULL; } -void flecs_monitor_mark_dirty( - ecs_world_t *world, - ecs_entity_t relation, - ecs_entity_t id) +#endif + + +#ifdef FLECS_JSON + +void json_next( + ecs_strbuf_t *buf) { - /* Only flag if there are actually monitors registered, so that we - * don't waste cycles evaluating monitors if there's no interest */ - ecs_monitor_set_t *ms = ecs_map_get(&world->monitors.monitor_sets, - ecs_monitor_set_t, relation); - if (ms && ecs_map_is_initialized(&ms->monitors)) { - ecs_monitor_t *m = ecs_map_get(&ms->monitors, - ecs_monitor_t, id); - if (m) { - m->is_dirty = true; - ms->is_dirty = true; - world->monitors.is_dirty = true; - } - } + ecs_strbuf_list_next(buf); } -void flecs_monitor_register( - ecs_world_t *world, - ecs_entity_t relation, - ecs_entity_t id, - ecs_query_t *query) +void json_literal( + ecs_strbuf_t *buf, + const char *value) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_appendstr(buf, value); +} - ecs_monitor_set_t *ms = ecs_map_ensure( - &world->monitors.monitor_sets, ecs_monitor_set_t, relation); - ecs_assert(ms != NULL, ECS_INTERNAL_ERROR, NULL); +void json_number( + ecs_strbuf_t *buf, + double value) +{ + ecs_strbuf_appendflt(buf, value, '"'); +} - if (!ecs_map_is_initialized(&ms->monitors)) { - ecs_map_init(&ms->monitors, ecs_monitor_t, 1); +void json_true( + ecs_strbuf_t *buf) +{ + json_literal(buf, "true"); +} + +void json_false( + ecs_strbuf_t *buf) +{ + json_literal(buf, "false"); +} + +void json_bool( + ecs_strbuf_t *buf, + bool value) +{ + if (value) { + json_true(buf); + } else { + json_false(buf); } +} - ecs_monitor_t *m = ecs_map_ensure(&ms->monitors, ecs_monitor_t, id); - ecs_assert(m != NULL, ECS_INTERNAL_ERROR, NULL); +void json_array_push( + ecs_strbuf_t *buf) +{ + ecs_strbuf_list_push(buf, "[", ", "); +} - ecs_query_t **q = ecs_vector_add(&m->queries, ecs_query_t*); - *q = query; +void json_array_pop( + ecs_strbuf_t *buf) +{ + ecs_strbuf_list_pop(buf, "]"); } -void flecs_monitor_unregister( - ecs_world_t *world, - ecs_entity_t relation, - ecs_entity_t id, - ecs_query_t *query) +void json_object_push( + ecs_strbuf_t *buf) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_list_push(buf, "{", ", "); +} - ecs_monitor_set_t *ms = ecs_map_get( - &world->monitors.monitor_sets, ecs_monitor_set_t, relation); - if (!ms) { - return; - } +void json_object_pop( + ecs_strbuf_t *buf) +{ + ecs_strbuf_list_pop(buf, "}"); +} - if (!ecs_map_is_initialized(&ms->monitors)) { - return; +void json_string( + ecs_strbuf_t *buf, + const char *value) +{ + ecs_strbuf_appendch(buf, '"'); + ecs_strbuf_appendstr(buf, value); + ecs_strbuf_appendch(buf, '"'); +} + +void json_member( + ecs_strbuf_t *buf, + const char *name) +{ + ecs_strbuf_list_appendstr(buf, "\""); + ecs_strbuf_appendstr(buf, name); + ecs_strbuf_appendstr(buf, "\":"); +} + +void json_path( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_entity_t e) +{ + ecs_strbuf_appendch(buf, '"'); + ecs_get_path_w_sep_buf(world, 0, e, ".", "", buf); + ecs_strbuf_appendch(buf, '"'); +} + +void json_label( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_entity_t e) +{ + const char *lbl = NULL; +#ifdef FLECS_DOC + lbl = ecs_doc_get_name(world, e); +#else + lbl = ecs_get_name(world, e); +#endif + + if (lbl) { + ecs_strbuf_appendch(buf, '"'); + ecs_strbuf_appendstr(buf, lbl); + ecs_strbuf_appendch(buf, '"'); + } else { + ecs_strbuf_appendstr(buf, "0"); } +} - ecs_monitor_t *m = ecs_map_get(&ms->monitors, ecs_monitor_t, id); - if (!m) { - return; +void json_id( + ecs_strbuf_t *buf, + const ecs_world_t *world, + ecs_id_t id) +{ + ecs_strbuf_appendch(buf, '"'); + ecs_id_str_buf(world, id, buf); + ecs_strbuf_appendch(buf, '"'); +} + +ecs_primitive_kind_t json_op_to_primitive_kind( + ecs_meta_type_op_kind_t kind) +{ + return kind - EcsOpPrimitive; +} + +#endif + + +#ifdef FLECS_JSON + +static +int json_typeinfo_ser_type( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *buf); + +static +int json_typeinfo_ser_primitive( + ecs_primitive_kind_t kind, + ecs_strbuf_t *str) +{ + switch(kind) { + case EcsBool: + json_string(str, "bool"); + break; + case EcsChar: + case EcsString: + json_string(str, "text"); + break; + case EcsByte: + json_string(str, "byte"); + break; + case EcsU8: + case EcsU16: + case EcsU32: + case EcsU64: + case EcsI8: + case EcsI16: + case EcsI32: + case EcsI64: + case EcsIPtr: + case EcsUPtr: + json_string(str, "int"); + break; + case EcsF32: + case EcsF64: + json_string(str, "float"); + break; + case EcsEntity: + json_string(str, "entity"); + break; + default: + return -1; } - int32_t i, count = ecs_vector_count(m->queries); - ecs_query_t **queries = ecs_vector_first(m->queries, ecs_query_t*); - for (i = 0; i < count; i ++) { - if (queries[i] == query) { - ecs_vector_remove(m->queries, ecs_query_t*, i); - count --; - break; + return 0; +} + +static +void json_typeinfo_ser_constants( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *str) +{ + ecs_iter_t it = ecs_term_iter(world, &(ecs_term_t) { + .id = ecs_pair(EcsChildOf, type) + }); + + while (ecs_term_next(&it)) { + int32_t i, count = it.count; + for (i = 0; i < count; i ++) { + json_next(str); + json_string(str, ecs_get_name(world, it.entities[i])); } } +} - if (!count) { - ecs_vector_free(m->queries); - ecs_map_remove(&ms->monitors, id); - } +static +void json_typeinfo_ser_enum( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_appendstr(str, "\"enum\""); + json_typeinfo_ser_constants(world, type, str); +} + +static +void json_typeinfo_ser_bitmask( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_appendstr(str, "\"bitmask\""); + json_typeinfo_ser_constants(world, type, str); +} - if (!ecs_map_count(&ms->monitors)) { - ecs_map_fini(&ms->monitors); - ecs_map_remove(&world->monitors.monitor_sets, relation); - } +static +int json_typeinfo_ser_array( + const ecs_world_t *world, + ecs_entity_t elem_type, + int32_t count, + ecs_strbuf_t *str) +{ + ecs_strbuf_list_appendstr(str, "\"array\""); - if (!ecs_map_count(&world->monitors.monitor_sets)) { - ecs_map_fini(&world->monitors.monitor_sets); + json_next(str); + if (json_typeinfo_ser_type(world, elem_type, str)) { + goto error; } + + ecs_strbuf_list_append(str, "%u", count); + return 0; +error: + return -1; } static -void monitors_init( - ecs_relation_monitor_t *rm) +int json_typeinfo_ser_array_type( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *str) { - ecs_map_init(&rm->monitor_sets, ecs_monitor_set_t, 0); - rm->is_dirty = false; + const EcsArray *arr = ecs_get(world, type, EcsArray); + ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL); + if (json_typeinfo_ser_array(world, arr->type, arr->count, str)) { + goto error; + } + + return 0; +error: + return -1; } static -void monitors_fini( - ecs_relation_monitor_t *rm) +int json_typeinfo_ser_vector( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *str) { - ecs_map_iter_t it = ecs_map_iter(&rm->monitor_sets); - ecs_monitor_set_t *ms; + const EcsVector *arr = ecs_get(world, type, EcsVector); + ecs_assert(arr != NULL, ECS_INTERNAL_ERROR, NULL); - while ((ms = ecs_map_next(&it, ecs_monitor_set_t, NULL))) { - ecs_map_iter_t mit = ecs_map_iter(&ms->monitors); - ecs_monitor_t *m; - while ((m = ecs_map_next(&mit, ecs_monitor_t, NULL))) { - ecs_vector_free(m->queries); - } + ecs_strbuf_list_appendstr(str, "\"vector\""); - ecs_map_fini(&ms->monitors); + json_next(str); + if (json_typeinfo_ser_type(world, arr->type, str)) { + goto error; } - ecs_map_fini(&rm->monitor_sets); + return 0; +error: + return -1; } +/* Serialize unit information */ static -void init_store( - ecs_world_t *world) +int json_typeinfo_ser_unit( + const ecs_world_t *world, + ecs_strbuf_t *str, + ecs_entity_t unit) { - ecs_os_memset(&world->store, 0, ECS_SIZEOF(ecs_store_t)); - - /* Initialize entity index */ - flecs_sparse_init(&world->store.entity_index, ecs_record_t); - flecs_sparse_set_id_source(&world->store.entity_index, - &world->stats.last_id); - - /* Initialize root table */ - flecs_sparse_init(&world->store.tables, ecs_table_t); + json_member(str, "unit"); + json_path(str, world, unit); - /* Initialize table map */ - flecs_table_hashmap_init(&world->store.table_map); + const EcsUnit *uptr = ecs_get(world, unit, EcsUnit); + if (uptr) { + if (uptr->symbol) { + json_member(str, "symbol"); + json_string(str, uptr->symbol); + } + ecs_entity_t quantity = ecs_get_object(world, unit, EcsQuantity, 0); + if (quantity) { + json_member(str, "quantity"); + json_path(str, world, quantity); + } + } - /* Initialize one root table per stage */ - flecs_init_root_table(world); + return 0; } +/* Forward serialization to the different type kinds */ static -void clean_tables( - ecs_world_t *world) +int json_typeinfo_ser_type_op( + const ecs_world_t *world, + ecs_meta_type_op_t *op, + ecs_strbuf_t *str) { - int32_t i, count = flecs_sparse_count(&world->store.tables); - - /* Ensure that first table in sparse set has id 0. This is a dummy table - * that only exists so that there is no table with id 0 */ - ecs_table_t *first = flecs_sparse_get_dense(&world->store.tables, - ecs_table_t, 0); - ecs_assert(first->id == 0, ECS_INTERNAL_ERROR, NULL); - (void)first; + json_array_push(str); - for (i = 1; i < count; i ++) { - ecs_table_t *t = flecs_sparse_get_dense(&world->store.tables, - ecs_table_t, i); - flecs_table_release(world, t); + switch(op->kind) { + case EcsOpPush: + case EcsOpPop: + /* Should not be parsed as single op */ + ecs_throw(ECS_INVALID_PARAMETER, NULL); + break; + case EcsOpEnum: + json_typeinfo_ser_enum(world, op->type, str); + break; + case EcsOpBitmask: + json_typeinfo_ser_bitmask(world, op->type, str); + break; + case EcsOpArray: + json_typeinfo_ser_array_type(world, op->type, str); + break; + case EcsOpVector: + json_typeinfo_ser_vector(world, op->type, str); + break; + default: + if (json_typeinfo_ser_primitive( + json_op_to_primitive_kind(op->kind), str)) + { + /* Unknown operation */ + ecs_throw(ECS_INTERNAL_ERROR, NULL); + return -1; + } + break; } - /* Free table types separately so that if application destructors rely on - * a type it's still valid. */ - for (i = 1; i < count; i ++) { - ecs_table_t *t = flecs_sparse_get_dense(&world->store.tables, - ecs_table_t, i); - flecs_table_free_type(t); - } + ecs_entity_t unit = op->unit; + if (unit) { + json_next(str); + json_next(str); - /* Clear the root table */ - if (count) { - flecs_table_reset(world, &world->store.root); + json_object_push(str); + json_typeinfo_ser_unit(world, str, unit); + json_object_pop(str); } + + json_array_pop(str); + + return 0; +error: + return -1; } +/* Iterate over a slice of the type ops array */ static -void fini_store(ecs_world_t *world) { - clean_tables(world); - flecs_sparse_fini(&world->store.tables); - flecs_table_release(world, &world->store.root); - flecs_sparse_clear(&world->store.entity_index); - flecs_hashmap_fini(&world->store.table_map); +int json_typeinfo_ser_type_ops( + const ecs_world_t *world, + ecs_meta_type_op_t *ops, + int32_t op_count, + ecs_strbuf_t *str) +{ + for (int i = 0; i < op_count; i ++) { + ecs_meta_type_op_t *op = &ops[i]; - ecs_graph_edge_hdr_t *cur, *next = world->store.first_free; - while ((cur = next)) { - next = cur->next; - ecs_os_free(cur); + if (op != ops) { + if (op->name) { + json_member(str, op->name); + } + + int32_t elem_count = op->count; + if (elem_count > 1 && op != ops) { + json_array_push(str); + json_typeinfo_ser_array(world, op->type, op->count, str); + json_array_pop(str); + i += op->op_count - 1; + continue; + } + } + + switch(op->kind) { + case EcsOpPush: + json_object_push(str); + break; + case EcsOpPop: + json_object_pop(str); + break; + default: + if (json_typeinfo_ser_type_op(world, op, str)) { + goto error; + } + break; + } } + + return 0; +error: + return -1; } -/* Implementation for iterable mixin */ static -bool world_iter_next( - ecs_iter_t *it) +int json_typeinfo_ser_type( + const ecs_world_t *world, + ecs_entity_t type, + ecs_strbuf_t *buf) { - if (it->is_valid) { - return it->is_valid = false; + const EcsComponent *comp = ecs_get(world, type, EcsComponent); + if (!comp) { + ecs_strbuf_appendstr(buf, "0"); + return 0; } - ecs_world_t *world = it->real_world; - ecs_sparse_t *entity_index = &world->store.entity_index; - it->entities = (ecs_entity_t*)flecs_sparse_ids(entity_index); - it->count = flecs_sparse_count(entity_index); - return it->is_valid = true; + const EcsMetaTypeSerialized *ser = ecs_get( + world, type, EcsMetaTypeSerialized); + if (!ser) { + ecs_strbuf_appendstr(buf, "0"); + return 0; + } + + ecs_meta_type_op_t *ops = ecs_vector_first(ser->ops, ecs_meta_type_op_t); + int32_t count = ecs_vector_count(ser->ops); + + return json_typeinfo_ser_type_ops(world, ops, count, buf); } -static -void world_iter_init( +int ecs_type_info_to_json_buf( const ecs_world_t *world, - const ecs_poly_t *poly, - ecs_iter_t *iter, - ecs_term_t *filter) + ecs_entity_t type, + ecs_strbuf_t *buf) { - ecs_poly_assert(poly, ecs_world_t); - (void)poly; + return json_typeinfo_ser_type(world, type, buf); +} - if (filter) { - iter[0] = ecs_term_iter(world, filter); - } else { - iter[0] = (ecs_iter_t){ - .world = (ecs_world_t*)world, - .real_world = (ecs_world_t*)ecs_get_world(world), - .next = world_iter_next - }; +char* ecs_type_info_to_json( + const ecs_world_t *world, + ecs_entity_t type) +{ + ecs_strbuf_t str = ECS_STRBUF_INIT; + + if (ecs_type_info_to_json_buf(world, type, &str) != 0) { + ecs_strbuf_reset(&str); + return NULL; } -} -static -void log_addons(void) { - ecs_trace("addons included in build:"); - ecs_log_push(); - #ifdef FLECS_CPP - ecs_trace("FLECS_CPP"); - #endif - #ifdef FLECS_MODULE - ecs_trace("FLECS_MODULE"); - #endif - #ifdef FLECS_PARSER - ecs_trace("FLECS_PARSER"); - #endif - #ifdef FLECS_PLECS - ecs_trace("FLECS_PLECS"); - #endif - #ifdef FLECS_RULES - ecs_trace("FLECS_RULES"); - #endif - #ifdef FLECS_SNAPSHOT - ecs_trace("FLECS_SNAPSHOT"); - #endif - #ifdef FLECS_STATS - ecs_trace("FLECS_STATS"); - #endif - #ifdef FLECS_SYSTEM - ecs_trace("FLECS_SYSTEM"); - #endif - #ifdef FLECS_PIPELINE - ecs_trace("FLECS_PIPELINE"); - #endif - #ifdef FLECS_TIMER - ecs_trace("FLECS_TIMER"); - #endif - #ifdef FLECS_META - ecs_trace("FLECS_META"); - #endif - #ifdef FLECS_META_C - ecs_trace("FLECS_META_C"); - #endif - #ifdef FLECS_UNITS - ecs_trace("FLECS_UNITS"); - #endif - #ifdef FLECS_EXPR - ecs_trace("FLECS_EXPR"); - #endif - #ifdef FLECS_JSON - ecs_trace("FLECS_JSON"); - #endif - #ifdef FLECS_DOC - ecs_trace("FLECS_DOC"); - #endif - #ifdef FLECS_COREDOC - ecs_trace("FLECS_COREDOC"); - #endif - #ifdef FLECS_LOG - ecs_trace("FLECS_LOG"); - #endif - #ifdef FLECS_APP - ecs_trace("FLECS_APP"); - #endif - #ifdef FLECS_OS_API_IMPL - ecs_trace("FLECS_OS_API_IMPL"); - #endif - #ifdef FLECS_HTTP - ecs_trace("FLECS_HTTP"); - #endif - #ifdef FLECS_REST - ecs_trace("FLECS_REST"); - #endif - ecs_log_pop(); + return ecs_strbuf_get(&str); } -/* -- Public functions -- */ +#endif -ecs_world_t *ecs_mini(void) { -#ifdef FLECS_OS_API_IMPL - ecs_set_os_api_impl(); + + +#ifdef FLECS_SYSTEM #endif - ecs_os_init(); - ecs_trace("#[bold]bootstrapping world"); - ecs_log_push(); +#ifdef FLECS_PIPELINE +#ifndef FLECS_PIPELINE_PRIVATE_H +#define FLECS_PIPELINE_PRIVATE_H - ecs_trace("tracing enabled, call ecs_log_set_level(-1) to disable"); - if (!ecs_os_has_heap()) { - ecs_abort(ECS_MISSING_OS_API, NULL); - } +/** Instruction data for pipeline. + * This type is the element type in the "ops" vector of a pipeline and contains + * information about the set of systems that need to be ran before a merge. */ +typedef struct ecs_pipeline_op_t { + int32_t count; /* Number of systems to run before merge */ + bool multi_threaded; /* Whether systems can be ran multi threaded */ + bool no_staging; /* Whether systems are staged or not */ +} ecs_pipeline_op_t; - if (!ecs_os_has_threading()) { - ecs_trace("threading unavailable, to use threads set OS API first (see examples)"); - } +typedef struct EcsPipelineQuery { + ecs_query_t *query; + ecs_query_t *build_query; + ecs_vector_t *ops; + int32_t match_count; + int32_t rebuild_count; + ecs_entity_t last_system; +} EcsPipelineQuery; - if (!ecs_os_has_time()) { - ecs_trace("time management not available"); - } +//////////////////////////////////////////////////////////////////////////////// +//// Pipeline API +//////////////////////////////////////////////////////////////////////////////// - log_addons(); +/** Update a pipeline (internal function). + * Before running a pipeline, it must be updated. During this update phase + * all systems in the pipeline are collected, ordered and sync points are + * inserted where necessary. This operation may only be called when staging is + * disabled. + * + * Because multiple threads may run a pipeline, preparing the pipeline must + * happen synchronously, which is why this function is separate from + * ecs_run_pipeline. Not running the prepare step may cause systems to not get + * ran, or ran in the wrong order. + * + * If 0 is provided for the pipeline id, the default pipeline will be ran (this + * is either the builtin pipeline or the pipeline set with set_pipeline()). + * + * @param world The world. + * @param pipeline The pipeline to run. + * @return The number of elements in the pipeline. + */ +bool ecs_pipeline_update( + ecs_world_t *world, + ecs_entity_t pipeline, + bool start_of_frame); -#ifdef FLECS_SANITIZE - ecs_trace("sanitize build, rebuild witohut FLECS_SANITIZE for (much) " - "improved performance"); -#elif defined(FLECS_DEBUG) - ecs_trace("debug build, rebuild with NDEBUG or FLECS_NDEBUG for improved " - "performance"); -#else - ecs_trace("#[green]release#[reset] build"); -#endif +int32_t ecs_pipeline_reset_iter( + ecs_world_t *world, + const EcsPipelineQuery *pq, + ecs_iter_t *iter_out, + ecs_pipeline_op_t **op_out, + ecs_pipeline_op_t **last_op_out); -#ifdef __clang__ - ecs_trace("compiled with clang %s", __clang_version__); -#elif defined(__GNUC__) - ecs_trace("compiled with gcc %d.%d", __GNUC__, __GNUC_MINOR__); -#elif defined (_MSC_VER) - ecs_trace("compiled with msvc %d", _MSC_VER); -#endif +//////////////////////////////////////////////////////////////////////////////// +//// Worker API +//////////////////////////////////////////////////////////////////////////////// - ecs_world_t *world = ecs_os_calloc_t(ecs_world_t); - ecs_assert(world != NULL, ECS_OUT_OF_MEMORY, NULL); - ecs_poly_init(world, ecs_world_t); +void ecs_worker_begin( + ecs_world_t *world); - world->self = world; - world->type_info = flecs_sparse_new(ecs_type_info_t); - ecs_map_init(&world->id_index, ecs_id_record_t*, ECS_HI_COMPONENT_ID); - flecs_observable_init(&world->observable); - world->iterable.init = world_iter_init; +int32_t ecs_worker_sync( + ecs_world_t *world, + const EcsPipelineQuery *pq, + ecs_iter_t *it, + int32_t i, + ecs_pipeline_op_t **op_out, + ecs_pipeline_op_t **last_op_out); - world->queries = flecs_sparse_new(ecs_query_t); - world->triggers = flecs_sparse_new(ecs_trigger_t); - world->observers = flecs_sparse_new(ecs_observer_t); - - world->pending_tables = flecs_sparse_new(ecs_table_t*); - world->pending_buffer = flecs_sparse_new(ecs_table_t*); +void ecs_worker_end( + ecs_world_t *world); - world->fini_tasks = ecs_vector_new(ecs_entity_t, 0); - flecs_name_index_init(&world->aliases); - flecs_name_index_init(&world->symbols); - ecs_map_init(&world->type_handles, ecs_entity_t, 0); +void ecs_workers_progress( + ecs_world_t *world, + ecs_entity_t pipeline, + FLECS_FLOAT delta_time); - world->stats.time_scale = 1.0; - - monitors_init(&world->monitors); +#endif - if (ecs_os_has_time()) { - ecs_os_get_time(&world->world_start_time); - } +#endif - flecs_stage_init(world, &world->stage); - ecs_set_stages(world, 1); +#ifdef FLECS_STATS - ecs_default_lookup_path[0] = EcsFlecsCore; - ecs_set_lookup_path(world, ecs_default_lookup_path); +#include + +static +int32_t t_next( + int32_t t) +{ + return (t + 1) % ECS_STAT_WINDOW; +} + +static +int32_t t_prev( + int32_t t) +{ + return (t - 1 + ECS_STAT_WINDOW) % ECS_STAT_WINDOW; +} + +static +void _record_gauge( + ecs_gauge_t *m, + int32_t t, + float value) +{ + m->avg[t] = value; + m->min[t] = value; + m->max[t] = value; +} - init_store(world); - ecs_trace("table store initialized"); +static +float _record_counter( + ecs_counter_t *m, + int32_t t, + float value) +{ + int32_t tp = t_prev(t); + float prev = m->value[tp]; + m->value[t] = value; + _record_gauge((ecs_gauge_t*)m, t, value - prev); + return value - prev; +} - flecs_bootstrap(world); +/* Macro's to silence conversion warnings without adding casts everywhere */ +#define record_gauge(m, t, value)\ + _record_gauge(m, t, (float)value) - ecs_trace("world ready!"); - ecs_log_pop(); +#define record_counter(m, t, value)\ + _record_counter(m, t, (float)value) - return world; +static +void print_value( + const char *name, + float value) +{ + ecs_size_t len = ecs_os_strlen(name); + printf("%s: %*s %.2f\n", name, 32 - len, "", (double)value); } -ecs_world_t *ecs_init(void) { - ecs_world_t *world = ecs_mini(); - -#ifdef FLECS_MODULE_H - ecs_trace("#[bold]import addons"); - ecs_log_push(); - ecs_trace("use ecs_mini to create world without importing addons"); -#ifdef FLECS_SYSTEM - ECS_IMPORT(world, FlecsSystem); -#endif -#ifdef FLECS_PIPELINE - ECS_IMPORT(world, FlecsPipeline); -#endif -#ifdef FLECS_TIMER - ECS_IMPORT(world, FlecsTimer); -#endif -#ifdef FLECS_META - ECS_IMPORT(world, FlecsMeta); -#endif -#ifdef FLECS_DOC - ECS_IMPORT(world, FlecsDoc); -#endif -#ifdef FLECS_COREDOC - ECS_IMPORT(world, FlecsCoreDoc); -#endif -#ifdef FLECS_REST - ECS_IMPORT(world, FlecsRest); -#endif -#ifdef FLECS_UNITS - ecs_trace("#[green]module#[reset] flecs.units is not automatically imported"); -#endif - ecs_trace("addons imported!"); - ecs_log_pop(); -#endif - return world; +static +void print_gauge( + const char *name, + int32_t t, + const ecs_gauge_t *m) +{ + print_value(name, m->avg[t]); } -#define ARG(short, long, action)\ - if (i < argc) {\ - if (argv[i][0] == '-') {\ - if (argv[i][1] == '-') {\ - if (long && !strcmp(&argv[i][2], long ? long : "")) {\ - action;\ - parsed = true;\ - }\ - } else {\ - if (short && argv[i][1] == short) {\ - action;\ - parsed = true;\ - }\ - }\ - }\ - } +static +void print_counter( + const char *name, + int32_t t, + const ecs_counter_t *m) +{ + print_value(name, m->rate.avg[t]); +} -ecs_world_t* ecs_init_w_args( - int argc, - char *argv[]) +void ecs_gauge_reduce( + ecs_gauge_t *dst, + int32_t t_dst, + ecs_gauge_t *src, + int32_t t_src) { - ecs_world_t *world = ecs_init(); + ecs_check(dst != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(src != NULL, ECS_INVALID_PARAMETER, NULL); - (void)argc; - (void) argv; + bool min_set = false; + dst->min[t_dst] = 0; + dst->avg[t_dst] = 0; + dst->max[t_dst] = 0; -#ifdef FLECS_DOC - if (argc) { - char *app = argv[0]; - char *last_elem = strrchr(app, '/'); - if (!last_elem) { - last_elem = strrchr(app, '\\'); + int32_t i; + for (i = 0; i < ECS_STAT_WINDOW; i ++) { + int32_t t = (t_src + i) % ECS_STAT_WINDOW; + dst->avg[t_dst] += src->avg[t] / (float)ECS_STAT_WINDOW; + if (!min_set || (src->min[t] < dst->min[t_dst])) { + dst->min[t_dst] = src->min[t]; + min_set = true; } - if (last_elem) { - app = last_elem + 1; + if ((src->max[t] > dst->max[t_dst])) { + dst->max[t_dst] = src->max[t]; } - ecs_set_pair(world, EcsWorld, EcsDocDescription, EcsName, {app}); } -#endif - - return world; -} - -void ecs_quit( - ecs_world_t *world) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - flecs_stage_from_world(&world); - world->should_quit = true; error: return; } -bool ecs_should_quit( - const ecs_world_t *world) +void ecs_get_world_stats( + const ecs_world_t *world, + ecs_world_stats_t *s) { ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); + world = ecs_get_world(world); - return world->should_quit; -error: - return true; -} -void flecs_notify_tables( - ecs_world_t *world, - ecs_id_t id, - ecs_table_event_t *event) -{ - ecs_poly_assert(world, ecs_world_t); + int32_t t = s->t = t_next(s->t); - /* If no id is specified, broadcast to all tables */ - if (!id) { - ecs_sparse_t *tables = &world->store.tables; - int32_t i, count = flecs_sparse_count(tables); - for (i = 0; i < count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); - flecs_table_notify(world, table, event); - } + float delta_world_time = record_counter(&s->world_time_total_raw, t, world->stats.world_time_total_raw); + record_counter(&s->world_time_total, t, world->stats.world_time_total); + record_counter(&s->frame_time_total, t, world->stats.frame_time_total); + record_counter(&s->system_time_total, t, world->stats.system_time_total); + record_counter(&s->merge_time_total, t, world->stats.merge_time_total); - /* If id is specified, only broadcast to tables with id */ + float delta_frame_count = record_counter(&s->frame_count_total, t, world->stats.frame_count_total); + record_counter(&s->merge_count_total, t, world->stats.merge_count_total); + record_counter(&s->pipeline_build_count_total, t, world->stats.pipeline_build_count_total); + record_counter(&s->systems_ran_frame, t, world->stats.systems_ran_frame); + + if (delta_world_time != 0.0f && delta_frame_count != 0.0f) { + record_gauge( + &s->fps, t, 1.0f / (delta_world_time / (float)delta_frame_count)); } else { - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return; - } + record_gauge(&s->fps, t, 0); + } - ecs_table_cache_iter_t it; - const ecs_table_record_t *tr; + record_gauge(&s->entity_count, t, flecs_sparse_count(ecs_eis(world))); + record_gauge(&s->component_count, t, ecs_count_id(world, ecs_id(EcsComponent))); + record_gauge(&s->query_count, t, flecs_sparse_count(world->queries)); + record_gauge(&s->system_count, t, ecs_count_id(world, ecs_id(EcsSystem))); - flecs_table_cache_iter(&idr->cache, &it); - while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) { - flecs_table_notify(world, tr->hdr.table, event); + record_counter(&s->new_count, t, world->new_count); + record_counter(&s->bulk_new_count, t, world->bulk_new_count); + record_counter(&s->delete_count, t, world->delete_count); + record_counter(&s->clear_count, t, world->clear_count); + record_counter(&s->add_count, t, world->add_count); + record_counter(&s->remove_count, t, world->remove_count); + record_counter(&s->set_count, t, world->set_count); + record_counter(&s->discard_count, t, world->discard_count); + + /* Compute table statistics */ + int32_t empty_table_count = 0; + int32_t singleton_table_count = 0; + int32_t matched_table_count = 0, matched_entity_count = 0; + + int32_t i, count = flecs_sparse_count(&world->store.tables); + for (i = 0; i < count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense(&world->store.tables, + ecs_table_t, i); + int32_t entity_count = ecs_table_count(table); + + if (!entity_count) { + empty_table_count ++; } - flecs_table_cache_empty_iter(&idr->cache, &it); - while ((tr = flecs_table_cache_next(&it, ecs_table_record_t))) { - flecs_table_notify(world, tr->hdr.table, event); + /* Singleton tables are tables that have just one entity that also has + * itself in the table type. */ + if (entity_count == 1) { + ecs_entity_t *entities = ecs_vector_first( + table->storage.entities, ecs_entity_t); + if (ecs_search_relation(world, table, 0, entities[0], EcsIsA, + 0, 0, 0, 0, 0) != -1) + { + singleton_table_count ++; + } } } -} -void ecs_default_ctor( - ecs_world_t *world, - const ecs_entity_t *entity_ptr, - void *ptr, - int32_t count, - const ecs_type_info_t *ti) -{ - (void)world; (void)entity_ptr; - ecs_os_memset(ptr, 0, ti->size * count); -} + record_gauge(&s->matched_table_count, t, matched_table_count); + record_gauge(&s->matched_entity_count, t, matched_entity_count); + + record_gauge(&s->table_count, t, count); + record_gauge(&s->empty_table_count, t, empty_table_count); + record_gauge(&s->singleton_table_count, t, singleton_table_count); -static -void default_copy_ctor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, const void *src_ptr, - int32_t count, const ecs_type_info_t *ti) -{ - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->ctor(world, dst_entity, dst_ptr, count, ti); - cl->copy(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); +error: + return; } -static -void default_move_ctor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) +void ecs_get_query_stats( + const ecs_world_t *world, + const ecs_query_t *query, + ecs_query_stats_t *s) { - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->ctor(world, dst_entity, dst_ptr, count, ti); - cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); -} + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); + (void)world; -static -void default_ctor_w_move_w_dtor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) -{ - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->ctor(world, dst_entity, dst_ptr, count, ti); - cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); - cl->dtor(world, src_entity, src_ptr, count, ti); -} + int32_t t = s->t = t_next(s->t); -static -void default_move_ctor_w_dtor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) -{ - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->move_ctor(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); - cl->dtor(world, src_entity, src_ptr, count, ti); + ecs_iter_t it = ecs_query_iter(world, (ecs_query_t*)query); + record_gauge(&s->matched_entity_count, t, ecs_iter_count(&it)); + record_gauge(&s->matched_table_count, t, ecs_query_table_count(query)); + record_gauge(&s->matched_empty_table_count, t, + ecs_query_empty_table_count(query)); +error: + return; } -static -void default_move( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) +#ifdef FLECS_SYSTEM +bool ecs_get_system_stats( + const ecs_world_t *world, + ecs_entity_t system, + ecs_system_stats_t *s) { - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); -} + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); -static -void default_dtor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) -{ - (void)src_entity; + world = ecs_get_world(world); - /* When there is no move, destruct the destination component & memcpy the - * component to dst. The src component does not have to be destructed when - * a component has a trivial move. */ - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->dtor(world, dst_entity, dst_ptr, count, ti); - ecs_os_memcpy(dst_ptr, src_ptr, flecs_uto(ecs_size_t, ti->size) * count); -} + const EcsSystem *ptr = ecs_get(world, system, EcsSystem); + if (!ptr) { + return false; + } -static -void default_move_w_dtor( - ecs_world_t *world, const ecs_entity_t *dst_entity, - const ecs_entity_t *src_entity, void *dst_ptr, void *src_ptr, - int32_t count, const ecs_type_info_t *ti) -{ - /* If a component has a move, the move will take care of memcpying the data - * and destroying any data in dst. Because this is not a trivial move, the - * src component must also be destructed. */ - const EcsComponentLifecycle *cl = &ti->lifecycle; - cl->move(world, dst_entity, src_entity, dst_ptr, src_ptr, count, ti); - cl->dtor(world, src_entity, src_ptr, count, ti); + ecs_get_query_stats(world, ptr->query, &s->query_stats); + int32_t t = s->query_stats.t; + + record_counter(&s->time_spent, t, ptr->time_spent); + record_counter(&s->invoke_count, t, ptr->invoke_count); + record_gauge(&s->active, t, !ecs_has_id(world, system, EcsInactive)); + record_gauge(&s->enabled, t, !ecs_has_id(world, system, EcsDisabled)); + + return true; +error: + return false; } +#endif -void ecs_set_component_actions_w_id( - ecs_world_t *world, - ecs_entity_t component, - EcsComponentLifecycle *lifecycle) + +#ifdef FLECS_PIPELINE + +static +ecs_system_stats_t* get_system_stats( + ecs_map_t *systems, + ecs_entity_t system) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - flecs_stage_from_world(&world); + ecs_check(systems != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(system != 0, ECS_INVALID_PARAMETER, NULL); - ecs_type_info_t *ti = flecs_ensure_type_info(world, component); - ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_system_stats_t *s = ecs_map_get(systems, ecs_system_stats_t, system); + if (!s) { + s = ecs_map_ensure(systems, ecs_system_stats_t, system); + } - ecs_size_t size = ti->size; - ecs_size_t alignment = ti->alignment; + return s; +error: + return NULL; +} - if (!size) { - const EcsComponent *component_ptr = ecs_get( - world, component, EcsComponent); +bool ecs_get_pipeline_stats( + ecs_world_t *stage, + ecs_entity_t pipeline, + ecs_pipeline_stats_t *s) +{ + ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(pipeline != 0, ECS_INVALID_PARAMETER, NULL); - /* Cannot register lifecycle actions for things that aren't a component */ - ecs_check(component_ptr != NULL, ECS_INVALID_PARAMETER, NULL); - /* Cannot register lifecycle actions for components with size 0 */ - ecs_check(component_ptr->size != 0, ECS_INVALID_PARAMETER, NULL); + const ecs_world_t *world = ecs_get_world(stage); - size = component_ptr->size; - alignment = component_ptr->alignment; + const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); + if (!pq) { + return false; } - if (ti->lifecycle_set) { - ecs_assert(ti->component == component, ECS_INTERNAL_ERROR, NULL); - ecs_check(!lifecycle->ctor || ti->lifecycle.ctor == lifecycle->ctor, - ECS_INCONSISTENT_COMPONENT_ACTION, NULL); - ecs_check(!lifecycle->dtor || ti->lifecycle.dtor == lifecycle->dtor, - ECS_INCONSISTENT_COMPONENT_ACTION, NULL); - ecs_check(!lifecycle->copy || ti->lifecycle.copy == lifecycle->copy, - ECS_INCONSISTENT_COMPONENT_ACTION, NULL); - ecs_check(!lifecycle->move || ti->lifecycle.move == lifecycle->move, - ECS_INCONSISTENT_COMPONENT_ACTION, NULL); + int32_t sys_count = 0, active_sys_count = 0; - if (!ti->lifecycle.on_set) { - ti->lifecycle.on_set = lifecycle->on_set; - } - if (!ti->lifecycle.on_remove) { - ti->lifecycle.on_remove = lifecycle->on_remove; - } - } else { - ti->component = component; - ti->lifecycle = *lifecycle; - ti->lifecycle_set = true; - ti->size = size; - ti->alignment = alignment; + /* Count number of active systems */ + ecs_iter_t it = ecs_query_iter(stage, pq->query); + while (ecs_query_next(&it)) { + active_sys_count += it.count; + } - /* If no constructor is set, invoking any of the other lifecycle actions - * is not safe as they will potentially access uninitialized memory. For - * ease of use, if no constructor is specified, set a default one that - * initializes the component to 0. */ - if (!lifecycle->ctor && - (lifecycle->dtor || lifecycle->copy || lifecycle->move)) - { - ti->lifecycle.ctor = ecs_default_ctor; - } + /* Count total number of systems in pipeline */ + it = ecs_query_iter(stage, pq->build_query); + while (ecs_query_next(&it)) { + sys_count += it.count; + } - /* Set default copy ctor, move ctor and merge */ - if (lifecycle->copy && !lifecycle->copy_ctor) { - ti->lifecycle.copy_ctor = default_copy_ctor; - } + /* Also count synchronization points */ + ecs_vector_t *ops = pq->ops; + ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); + ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); + int32_t pip_count = active_sys_count + ecs_vector_count(ops); - if (lifecycle->move && !lifecycle->move_ctor) { - ti->lifecycle.move_ctor = default_move_ctor; - } + if (!sys_count) { + return false; + } - if (!lifecycle->ctor_move_dtor) { - if (lifecycle->move) { - if (lifecycle->dtor) { - if (lifecycle->move_ctor) { - /* If an explicit move ctor has been set, use callback - * that uses the move ctor vs. using a ctor+move */ - ti->lifecycle.ctor_move_dtor = - default_move_ctor_w_dtor; - } else { - /* If no explicit move_ctor has been set, use - * combination of ctor + move + dtor */ - ti->lifecycle.ctor_move_dtor = - default_ctor_w_move_w_dtor; - } - } else { - /* If no dtor has been set, this is just a move ctor */ - ti->lifecycle.ctor_move_dtor = - ti->lifecycle.move_ctor; - } - } - } + if (s->system_stats && !sys_count) { + ecs_map_free(s->system_stats); + } + if (!s->system_stats && sys_count) { + s->system_stats = ecs_map_new(ecs_system_stats_t, sys_count); + } + if (!sys_count) { + s->system_stats = NULL; + } - if (!lifecycle->move_dtor) { - if (lifecycle->move) { - if (lifecycle->dtor) { - ti->lifecycle.move_dtor = default_move_w_dtor; - } else { - ti->lifecycle.move_dtor = default_move; - } - } else { - if (lifecycle->dtor) { - ti->lifecycle.move_dtor = default_dtor; + /* Make sure vector is large enough to store all systems & sync points */ + ecs_entity_t *systems = NULL; + if (pip_count) { + ecs_vector_set_count(&s->systems, ecs_entity_t, pip_count); + systems = ecs_vector_first(s->systems, ecs_entity_t); + + /* Populate systems vector, keep track of sync points */ + it = ecs_query_iter(stage, pq->query); + + int32_t i, i_system = 0, ran_since_merge = 0; + while (ecs_query_next(&it)) { + for (i = 0; i < it.count; i ++) { + systems[i_system ++] = it.entities[i]; + ran_since_merge ++; + if (op != op_last && ran_since_merge == op->count) { + ran_since_merge = 0; + op++; + systems[i_system ++] = 0; /* 0 indicates a merge point */ } } } - /* Ensure that no tables have yet been created for the component */ - ecs_assert( flecs_id_existst(world, component) == false, - ECS_ALREADY_IN_USE, ecs_get_name(world, component)); - ecs_assert( flecs_id_existst(world, - ecs_pair(component, EcsWildcard)) == false, - ECS_ALREADY_IN_USE, ecs_get_name(world, component)); + systems[i_system ++] = 0; /* Last merge */ + ecs_assert(pip_count == i_system, ECS_INTERNAL_ERROR, NULL); + } else { + ecs_vector_free(s->systems); + s->systems = NULL; } -error: - return; -} -bool ecs_component_has_actions( - const ecs_world_t *world, - ecs_entity_t component) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(component != 0, ECS_INVALID_PARAMETER, NULL); - - world = ecs_get_world(world); - const ecs_type_info_t *ti = flecs_get_type_info(world, component); - return (ti != NULL) && ti->lifecycle_set; + /* Separately populate system stats map from build query, which includes + * systems that aren't currently active */ + it = ecs_query_iter(stage, pq->build_query); + while (ecs_query_next(&it)) { + int i; + for (i = 0; i < it.count; i ++) { + ecs_system_stats_t *sys_stats = get_system_stats( + s->system_stats, it.entities[i]); + ecs_get_system_stats(world, it.entities[i], sys_stats); + } + } + + return true; error: return false; } -void ecs_atfini( - ecs_world_t *world, - ecs_fini_action_t action, - void *ctx) +void ecs_pipeline_stats_fini( + ecs_pipeline_stats_t *stats) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_action_elem_t *elem = ecs_vector_add(&world->fini_actions, - ecs_action_elem_t); - ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - - elem->action = action; - elem->ctx = ctx; -error: - return; + ecs_map_free(stats->system_stats); + ecs_vector_free(stats->systems); } -void ecs_run_post_frame( - ecs_world_t *world, - ecs_fini_action_t action, - void *ctx) +#endif + +void ecs_dump_world_stats( + const ecs_world_t *world, + const ecs_world_stats_t *s) { + int32_t t = s->t; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(action != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_stage_t *stage = flecs_stage_from_world(&world); - ecs_action_elem_t *elem = ecs_vector_add(&stage->post_frame_actions, - ecs_action_elem_t); - ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_check(s != NULL, ECS_INVALID_PARAMETER, NULL); - elem->action = action; - elem->ctx = ctx; + world = ecs_get_world(world); + + print_counter("Frame", t, &s->frame_count_total); + printf("-------------------------------------\n"); + print_counter("pipeline rebuilds", t, &s->pipeline_build_count_total); + print_counter("systems ran last frame", t, &s->systems_ran_frame); + printf("\n"); + print_value("target FPS", world->stats.target_fps); + print_value("time scale", world->stats.time_scale); + printf("\n"); + print_gauge("actual FPS", t, &s->fps); + print_counter("frame time", t, &s->frame_time_total); + print_counter("system time", t, &s->system_time_total); + print_counter("merge time", t, &s->merge_time_total); + print_counter("simulation time elapsed", t, &s->world_time_total); + printf("\n"); + print_gauge("entity count", t, &s->entity_count); + print_gauge("component count", t, &s->component_count); + print_gauge("query count", t, &s->query_count); + print_gauge("system count", t, &s->system_count); + print_gauge("table count", t, &s->table_count); + print_gauge("singleton table count", t, &s->singleton_table_count); + print_gauge("empty table count", t, &s->empty_table_count); + printf("\n"); + print_counter("deferred new operations", t, &s->new_count); + print_counter("deferred bulk_new operations", t, &s->bulk_new_count); + print_counter("deferred delete operations", t, &s->delete_count); + print_counter("deferred clear operations", t, &s->clear_count); + print_counter("deferred add operations", t, &s->add_count); + print_counter("deferred remove operations", t, &s->remove_count); + print_counter("deferred set operations", t, &s->set_count); + print_counter("discarded operations", t, &s->discard_count); + printf("\n"); + error: return; } -/* Unset data in tables */ -static -void fini_unset_tables( - ecs_world_t *world) -{ - ecs_sparse_t *tables = &world->store.tables; - int32_t i, count = flecs_sparse_count(tables); - - for (i = 0; i < count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); - flecs_table_remove_actions(world, table); - } -} +#endif -/* Invoke fini actions */ -static -void fini_actions( - ecs_world_t *world) -{ - ecs_vector_each(world->fini_actions, ecs_action_elem_t, elem, { - elem->action(world, elem->ctx); - }); - ecs_vector_free(world->fini_actions); -} +#ifdef FLECS_APP -/* Cleanup component lifecycle callbacks & systems */ static -void fini_component_lifecycle( - ecs_world_t *world) +int default_run_action( + ecs_world_t *world, + ecs_app_desc_t *desc) { - flecs_sparse_free(world->type_info); -} + if (desc->init) { + desc->init(world); + } -/* Cleanup queries */ -static -void fini_queries( - ecs_world_t *world) -{ - monitors_fini(&world->monitors); - - int32_t i, count = flecs_sparse_count(world->queries); - for (i = 0; i < count; i ++) { - ecs_query_t *query = flecs_sparse_get_dense(world->queries, ecs_query_t, 0); - ecs_query_fini(query); + int result; + while ((result = ecs_app_run_frame(world, desc)) == 0) { } + + if (result == 1) { + return 0; /* Normal exit */ + } else { + return result; /* Error code */ } - flecs_sparse_free(world->queries); } static -void fini_observers( - ecs_world_t *world) +int default_frame_action( + ecs_world_t *world, + const ecs_app_desc_t *desc) { - flecs_sparse_free(world->observers); + return !ecs_progress(world, desc->delta_time); } -/* Cleanup stages */ -static -void fini_stages( - ecs_world_t *world) -{ - flecs_stage_deinit(world, &world->stage); - ecs_set_stages(world, 0); -} +static ecs_app_run_action_t run_action = default_run_action; +static ecs_app_frame_action_t frame_action = default_frame_action; +static ecs_app_desc_t ecs_app_desc; -static -ecs_id_record_t* new_id_record( +int ecs_app_run( ecs_world_t *world, - ecs_id_t id) + ecs_app_desc_t *desc) { - ecs_id_record_t *idr = ecs_os_calloc_t(ecs_id_record_t); - ecs_table_cache_init(&idr->cache); - - ecs_entity_t rel = 0, obj = 0; - if (ECS_HAS_ROLE(id, PAIR)) { - rel = ecs_pair_first(world, id); - ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL); - - /* Relation object can be 0, as tables without a ChildOf relation are - * added to the (ChildOf, 0) id record */ - obj = ECS_PAIR_SECOND(id); - if (obj) { - obj = ecs_get_alive(world, obj); - ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); - } - - /* If id is a pair, inherit flags from relation id record */ - ecs_id_record_t *idr_r = flecs_get_id_record( - world, ECS_PAIR_FIRST(id)); - if (idr_r) { - idr->flags = idr_r->flags; - } - } else { - rel = id & ECS_COMPONENT_MASK; - rel = ecs_get_alive(world, rel); - ecs_assert(rel != 0, ECS_INTERNAL_ERROR, NULL); - } - - /* Mark entities that are used as component/pair ids. When a tracked - * entity is deleted, cleanup policies are applied so that the store - * won't contain any tables with deleted ids. */ + ecs_app_desc = *desc; - /* Flag for OnDelete policies */ - flecs_add_flag(world, rel, ECS_FLAG_OBSERVED_ID); - if (obj) { - /* Flag for OnDeleteObject policies */ - flecs_add_flag(world, obj, ECS_FLAG_OBSERVED_OBJECT); - if (ecs_has_id(world, rel, EcsAcyclic)) { - /* Flag used to determine if object should be traversed when - * propagating events or with super/subset queries */ - flecs_add_flag(world, obj, ECS_FLAG_OBSERVED_ACYCLIC); - } + /* Don't set FPS & threads if custom run action is set, as the platform on + * which the app is running may not support it. */ + if (run_action == default_run_action) { + ecs_set_target_fps(world, ecs_app_desc.target_fps); + ecs_set_threads(world, ecs_app_desc.threads); } - if (ecs_should_log_1()) { - char *id_str = ecs_id_str(world, id); - ecs_dbg_1("#[green]id#[normal] %s #[green]created", id_str); - ecs_os_free(id_str); + /* REST server enables connecting to app with explorer */ + if (desc->enable_rest) { +#ifdef FLECS_REST + ecs_set(world, EcsWorld, EcsRest, {.port = 0}); +#else + ecs_warn("cannot enable remote API, REST addon not available"); +#endif } - return idr; + return run_action(world, &ecs_app_desc); } - -/* Cleanup id index */ -static -bool free_id_record( +int ecs_app_run_frame( ecs_world_t *world, - ecs_id_t id, - ecs_id_record_t *idr) + const ecs_app_desc_t *desc) { - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(id != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_poly_assert(world, ecs_world_t); - (void)id; - - /* Force the empty table administration to be consistent if the non-empty - * list of the id record has elements */ - if (ecs_table_cache_count(&idr->cache)) { - ecs_force_aperiodic(world); - } - - /* If there are still tables in the non-empty list they're really not empty. - * We can't free the record yet. */ - if (ecs_table_cache_count(&idr->cache)) { - return false; - } - - /* If id record contains no more empty tables, free it */ - if (ecs_table_cache_empty_count(&idr->cache) == 0) { - if (ecs_should_log_1()) { - char *id_str = ecs_id_str(world, id); - ecs_dbg_1("#[green]id#[normal] %s #[red]deleted", id_str); - ecs_os_free(id_str); - } - - ecs_table_cache_fini(&idr->cache); - flecs_name_index_free(idr->name_index); - ecs_os_free(idr); - return true; - } - - /* Delete empty tables */ - ecs_table_cache_iter_t cache_it; - flecs_table_cache_empty_iter(&idr->cache, &cache_it); - - const ecs_table_record_t *tr; - while ((tr = flecs_table_cache_next(&cache_it, ecs_table_record_t))) { - if (!flecs_table_release(world, tr->hdr.table)) { - /* Releasing the table did not free it, which means that something - * is keeping the table alive. Cleanup of the id record will happen - * when the last reference(s) to the table are released */ - return false; - } - } - - /* If all tables were deleted for this id record, the last deleted table - * should have removed the record from the world. */ - ecs_assert(flecs_get_id_record(world, id) == NULL, - ECS_INTERNAL_ERROR, NULL); - - return true; + return frame_action(world, desc); } -static -void fini_id_index( - ecs_world_t *world) +int ecs_app_set_run_action( + ecs_app_run_action_t callback) { - ecs_map_iter_t it = ecs_map_iter(&world->id_index); - ecs_id_record_t *idr; - ecs_map_key_t key; - while ((idr = ecs_map_next_ptr(&it, ecs_id_record_t*, &key))) { - free_id_record(world, key, idr); + if (run_action != default_run_action) { + ecs_err("run action already set"); + return -1; } - ecs_map_fini(&world->id_index); - flecs_sparse_free(world->pending_tables); - flecs_sparse_free(world->pending_buffer); -} + run_action = callback; -/* Cleanup misc structures */ -static -void fini_misc( - ecs_world_t *world) -{ - ecs_map_fini(&world->type_handles); - ecs_vector_free(world->fini_tasks); + return 0; } -/* The destroyer of worlds */ -int ecs_fini( - ecs_world_t *world) +int ecs_app_set_frame_action( + ecs_app_frame_action_t callback) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); - ecs_assert(!world->is_fini, ECS_INVALID_OPERATION, NULL); + if (frame_action != default_frame_action) { + ecs_err("frame action already set"); + return -1; + } - ecs_trace("#[bold]shutting down world"); - ecs_log_push(); + frame_action = callback; - world->is_fini = true; + return 0; +} - /* Operations invoked during UnSet/OnRemove/destructors are deferred and - * will be discarded after world cleanup */ - ecs_defer_begin(world); +#endif - /* Run UnSet/OnRemove actions for components while the store is still - * unmodified by cleanup. */ - fini_unset_tables(world); - - /* Run fini actions (simple callbacks ran when world is deleted) before - * destroying the storage */ - fini_actions(world); - /* This will destroy all entities and components. After this point no more - * user code is executed. */ - fini_store(world); +#ifdef FLECS_RULES - /* Purge deferred operations from the queue. This discards operations but - * makes sure that any resources in the queue are freed */ - flecs_defer_purge(world, &world->stage); +#include - /* Entity index is kept alive until this point so that user code can do - * validity checks on entity ids, even though after store cleanup the index - * will be empty, so all entity ids are invalid. */ - flecs_sparse_fini(&world->store.entity_index); - - if (world->locking_enabled) { - ecs_os_mutex_free(world->mutex); - } +/** Implementation of the rule query engine. + * + * A rule (terminology borrowed from prolog) is a list of constraints that + * specify which conditions must be met for an entity to match the rule. While + * this description matches any kind of ECS query, the rule engine has features + * that go beyond regular (flecs) ECS queries: + * + * - query for all components of an entity (vs. all entities for a component) + * - query for all relationship pairs of an entity + * - support for query variables that are resolved at evaluation time + * - automatic traversal of transitive relationships + * + * Query terms can have the following forms: + * + * - Component(Subject) + * - Relation(Subject, Object) + * + * Additionally the query parser supports the following shorthand notations: + * + * - Component // short for Component(This) + * - (Relation, Object) // short for Relation(This, Object) + * + * The subject, or first arugment of a term represents the entity on which the + * component or relation is matched. By default the subject is set to a builtin + * This variable, which causes the behavior to match a regular ECS query: + * + * - Position, Velocity + * + * Is equivalent to + * + * - Position(This), Velocity(This) + * + * The function of the variable is to ensure that all components are matched on + * the same entity. Conceptually the query first populates the This variable + * with all entities that have Position. When the query evaluates the Velocity + * term, the variable is populated and the entity it contains will be checked + * for whether it has Velocity. + * + * The actual implementation is more efficient and does not check per-entity. + * + * Custom variables can be used to join parts of different terms. For example, + * the following query can be used to find entities with a parent that has a + * Position component (note that variable names start with a _): + * + * - ChildOf(This, _Parent), Component(_Parent) + * + * The rule engine uses a backtracking algorithm to find the set of entities + * and variables that match all terms. As soon as the engine finds a term that + * does not match with the currently evaluated entity, the entity is discarded. + * When an entity is found for which all terms match, the entity is yielded to + * the iterator. + * + * While a rule is being evaluated, a variable can either contain a single + * entity or a table. The engine will attempt to work with tables as much as + * possible so entities can be eliminated/yielded in bulk. A rule may store + * both the table and entity version of a variable and only switch from table to + * entity when necessary. + * + * The rule engine has an algorithm for computing which variables should be + * resolved first. This algorithm works by finding a "root" variable, which is + * the subject variable that occurs in the term with the least dependencies. The + * remaining variables are then resolved based on their "distance" from the root + * with the closest variables being resolved first. + * + * This generally results in an ordering that resolves the variables with the + * least dependencies first and the most dependencies last, which is beneficial + * for two reasons: + * + * - it improves the average performance of all queries + * - it makes performance less dependent on how an application orders the terms + * + * A possible improvement would be for the query engine to also consider + * the number of tables that need to be evaluated for each term, as starting + * with the smallest term reduces the amount of work. Other than static variable + * analysis however, this can only be determined when the query is executed. + * + * Rules are "compiled" into a set of instructions that encode the operations + * the query needs to perform in order to find the right set of entities. + * Operations can either yield data, which progresses the program, or signal + * that there is no (more) matching data, which discards the current variables. + * + * An operation can yield multiple times, if there are multiple matches for its + * inputs. Operations are called with a redo flag, which can be either true or + * false. When redo is true the operation will yield the next result. When redo + * is false, the operation will reset its state and start from the first result. + * + * Operations can have an input, output and a filter. Most commonly an operation + * either matches the filter against an input and yields if it matches, or uses + * the filter to find all matching results and store the result in the output. + * + * Variables are resolved by matching a filter against the output of an + * operation. When a term contains variables, they are encoded as register ids + * in the filter. When the filter is evaluated, the most recent values of the + * register are used to match/lookup the output. + * + * For example, a filter could be (ChildOf, _Parent). When the program starts, + * the _Parent register is initialized with *, so that when this filter is first + * evaluated, the operation will find all tables with (ChildOf, *). The _Parent + * register is then populated by taking the actual value of the table. If the + * table has type [(ChildOf, Sun)], _Parent will be initialized with Sun. + * + * It is possible that a filter matches multiple times. Consider the filter + * (Likes, _Food), and a table [(Likes, Apples), (Likes, Pears)]. In this case + * an operation will yield the table twice, once with _Food=Apples, and once + * with _Food=Pears. + * + * If a rule contains a term with a transitive relation, it will automatically + * substitute the parts of the term to find a fact that matches. The following + * examples illustrate how transitivity is resolved: + * + * Query: + * LocatedIn(Bob, SanFrancisco) + * + * Expands to: + * LocatedIn(Bob, SanFrancisco:self|subset) + * + * Explanation: + * "Is Bob located in San Francisco" - This term is true if Bob is either + * located in San Francisco, or is located in anything that is itself located + * in (a subset of) San Francisco. + * + * + * Query: + * LocatedIn(Bob, X) + * + * Expands to: + * LocatedIn(Bob, X:self|superset) + * + * Explanation: + * "Where is Bob located?" - This term recursively returns all places that + * Bob is located in, which includes his location and the supersets of his + * location. When Bob is located in San Francisco, he is also located in + * the United States, North America etc. + * + * + * Query: + * LocatedIn(X, NorthAmerica) + * + * Expands to: + * LocatedIn(X, NorthAmerica:self|subset) + * + * Explanation: + * "What is located in North America?" - This term returns everything located + * in North America and its subsets, as something located in San Francisco is + * located in UnitedStates, which is located in NorthAmerica. + * + * + * Query: + * LocatedIn(X, Y) + * + * Expands to: + * LocatedIn(X, Y) + * + * Explanation: + * "Where is everything located" - This term returns everything that is + * located somewhere. No substitution is performed as this would explode the + * results while not yielding new information. + * + * + * In the above terms, the variable indicates the part of the term that is + * unknown at evaluation time. In an actual rule the picked strategy depends on + * whether the variable is known when the term is evaluated. For example, if + * variable X has been resolved by the time Located(X, Y) is evaluated, the + * strategy from the LocatedIn(Bob, X) example will be used. + */ - ecs_trace("table store deinitialized"); +#define ECS_RULE_MAX_VAR_COUNT (32) - fini_stages(world); +#define RULE_PAIR_PREDICATE (1) +#define RULE_PAIR_OBJECT (2) - fini_component_lifecycle(world); +/* A rule pair contains a predicate and object that can be stored in a register. */ +typedef struct ecs_rule_pair_t { + union { + int32_t reg; + ecs_entity_t ent; + } pred; + union { + int32_t reg; + ecs_entity_t ent; + } obj; + int32_t reg_mask; /* bit 1 = predicate, bit 2 = object */ - fini_queries(world); + bool transitive; /* Is predicate transitive */ + bool final; /* Is predicate final */ + bool reflexive; /* Is predicate reflexive */ + bool acyclic; /* Is predicate acyclic */ + bool obj_0; +} ecs_rule_pair_t; - fini_observers(world); +/* Filter for evaluating & reifing types and variables. Filters are created ad- + * hoc from pairs, and take into account all variables that had been resolved + * up to that point. */ +typedef struct ecs_rule_filter_t { + ecs_id_t mask; /* Mask with wildcard in place of variables */ - fini_id_index(world); + bool wildcard; /* Does the filter contain wildcards */ + bool pred_wildcard; /* Is predicate a wildcard */ + bool obj_wildcard; /* Is object a wildcard */ + bool same_var; /* True if pred & obj are both the same variable */ - flecs_observable_fini(&world->observable); + int32_t hi_var; /* If hi part should be stored in var, this is the var id */ + int32_t lo_var; /* If lo part should be stored in var, this is the var id */ +} ecs_rule_filter_t; - flecs_sparse_free(world->triggers); +/* A rule register stores temporary values for rule variables */ +typedef enum ecs_rule_var_kind_t { + EcsRuleVarKindTable, /* Used for sorting, must be smallest */ + EcsRuleVarKindEntity, + EcsRuleVarKindUnknown +} ecs_rule_var_kind_t; - flecs_name_index_fini(&world->aliases); - flecs_name_index_fini(&world->symbols); - - fini_misc(world); +typedef struct ecs_table_slice_t { + ecs_table_t *table; + int32_t offset; + int32_t count; +} ecs_table_slice_t; - ecs_os_enable_high_timer_resolution(false); +typedef struct ecs_rule_reg_t { + /* Used for table variable */ + ecs_table_slice_t table; - /* End of the world */ - ecs_poly_free(world, ecs_world_t); + /* Used for entity variable. May also be set for table variable if it needs + * to store an empty entity. */ + ecs_entity_t entity; +} ecs_rule_reg_t; + +/* Operations describe how the rule should be evaluated */ +typedef enum ecs_rule_op_kind_t { + EcsRuleInput, /* Input placeholder, first instruction in every rule */ + EcsRuleSelect, /* Selects all ables for a given predicate */ + EcsRuleWith, /* Applies a filter to a table or entity */ + EcsRuleSubSet, /* Finds all subsets for transitive relationship */ + EcsRuleSuperSet, /* Finds all supersets for a transitive relationship */ + EcsRuleStore, /* Store entity in table or entity variable */ + EcsRuleEach, /* Forwards each entity in a table */ + EcsRuleSetJmp, /* Set label for jump operation to one of two values */ + EcsRuleJump, /* Jump to an operation label */ + EcsRuleNot, /* Invert result of an operation */ + EcsRuleInTable, /* Test if entity (subject) is in table (r_in) */ + EcsRuleEq, /* Test if entity in (subject) and (r_in) are equal */ + EcsRuleYield /* Yield result */ +} ecs_rule_op_kind_t; - ecs_os_fini(); +/* Single operation */ +typedef struct ecs_rule_op_t { + ecs_rule_op_kind_t kind; /* What kind of operation is it */ + ecs_rule_pair_t filter; /* Parameter that contains optional filter */ + ecs_entity_t subject; /* If set, operation has a constant subject */ - ecs_trace("world destroyed, bye!"); - ecs_log_pop(); + int32_t on_pass; /* Jump location when match succeeds */ + int32_t on_fail; /* Jump location when match fails */ + int32_t frame; /* Register frame */ - return 0; -} + int32_t term; /* Corresponding term index in signature */ + int32_t r_in; /* Optional In/Out registers */ + int32_t r_out; -bool ecs_is_fini( - const ecs_world_t *world) -{ - ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL); - world = ecs_get_world(world); - return world->is_fini; -} + bool has_in, has_out; /* Keep track of whether operation uses input + * and/or output registers. This helps with + * debugging rule programs. */ +} ecs_rule_op_t; -void ecs_dim( - ecs_world_t *world, - int32_t entity_count) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_eis_set_size(world, entity_count + ECS_HI_COMPONENT_ID); -} +/* With context. Shared with select. */ +typedef struct ecs_rule_with_ctx_t { + ecs_id_record_t *idr; /* Currently evaluated table set */ + ecs_table_cache_iter_t it; + int32_t column; +} ecs_rule_with_ctx_t; -void flecs_eval_component_monitors( - ecs_world_t *world) -{ - ecs_poly_assert(world, ecs_world_t); - flecs_process_pending_tables(world); - eval_component_monitor(world); -} +/* Subset context */ +typedef struct ecs_rule_subset_frame_t { + ecs_rule_with_ctx_t with_ctx; + ecs_table_t *table; + int32_t row; + int32_t column; +} ecs_rule_subset_frame_t; -void ecs_measure_frame_time( - ecs_world_t *world, - bool enable) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); +typedef struct ecs_rule_subset_ctx_t { + ecs_rule_subset_frame_t storage[16]; /* Alloc-free array for small trees */ + ecs_rule_subset_frame_t *stack; + int32_t sp; +} ecs_rule_subset_ctx_t; - if (world->stats.target_fps == 0.0f || enable) { - world->measure_frame_time = enable; - } -error: - return; -} +/* Superset context */ +typedef struct ecs_rule_superset_frame_t { + ecs_table_t *table; + int32_t column; +} ecs_rule_superset_frame_t; -void ecs_measure_system_time( - ecs_world_t *world, - bool enable) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); - world->measure_system_time = enable; -error: - return; -} +typedef struct ecs_rule_superset_ctx_t { + ecs_rule_superset_frame_t storage[16]; /* Alloc-free array for small trees */ + ecs_rule_superset_frame_t *stack; + ecs_id_record_t *idr; + int32_t sp; +} ecs_rule_superset_ctx_t; -void ecs_set_target_fps( - ecs_world_t *world, - FLECS_FLOAT fps) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_check(ecs_os_has_time(), ECS_MISSING_OS_API, NULL); +/* Each context */ +typedef struct ecs_rule_each_ctx_t { + int32_t row; /* Currently evaluated row in evaluated table */ +} ecs_rule_each_ctx_t; - ecs_measure_frame_time(world, true); - world->stats.target_fps = fps; - ecs_os_enable_high_timer_resolution(fps >= 60.0f); -error: - return; -} +/* Jump context */ +typedef struct ecs_rule_setjmp_ctx_t { + int32_t label; /* Operation label to jump to */ +} ecs_rule_setjmp_ctx_t; -void* ecs_get_context( - const ecs_world_t *world) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - world = ecs_get_world(world); - return world->context; -error: - return NULL; -} +/* Operation context. This is a per-operation, per-iterator structure that + * stores information for stateful operations. */ +typedef struct ecs_rule_op_ctx_t { + union { + ecs_rule_subset_ctx_t subset; + ecs_rule_superset_ctx_t superset; + ecs_rule_with_ctx_t with; + ecs_rule_each_ctx_t each; + ecs_rule_setjmp_ctx_t setjmp; + } is; +} ecs_rule_op_ctx_t; -void ecs_set_context( - ecs_world_t *world, - void *context) -{ - ecs_poly_assert(world, ecs_world_t); - world->context = context; -} +/* Rule variables allow for the rule to be parameterized */ +typedef struct ecs_rule_var_t { + ecs_rule_var_kind_t kind; + char *name; /* Variable name */ + int32_t id; /* Unique variable id */ + int32_t other; /* Id to table variable (-1 if none exists) */ + int32_t occurs; /* Number of occurrences (used for operation ordering) */ + int32_t depth; /* Depth in dependency tree (used for operation ordering) */ + bool marked; /* Used for cycle detection */ +} ecs_rule_var_t; -void ecs_set_entity_range( - ecs_world_t *world, - ecs_entity_t id_start, - ecs_entity_t id_end) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_check(!id_end || id_end > id_start, ECS_INVALID_PARAMETER, NULL); - ecs_check(!id_end || id_end > world->stats.last_id, - ECS_INVALID_PARAMETER, NULL); +/* Variable ids per term */ +typedef struct ecs_rule_term_vars_t { + int32_t pred; + int32_t subj; + int32_t obj; +} ecs_rule_term_vars_t; - if (world->stats.last_id < id_start) { - world->stats.last_id = id_start - 1; - } +/* Top-level rule datastructure */ +struct ecs_rule_t { + ecs_header_t hdr; + + ecs_world_t *world; /* Ref to world so rule can be used by itself */ + ecs_rule_op_t *operations; /* Operations array */ + ecs_filter_t filter; /* Filter of rule */ - world->stats.min_id = id_start; - world->stats.max_id = id_end; -error: - return; -} + /* Passed to iterator */ + char *var_names[ECS_RULE_MAX_VAR_COUNT]; -bool ecs_enable_range_check( - ecs_world_t *world, - bool enable) -{ - ecs_poly_assert(world, ecs_world_t); - bool old_value = world->range_check_enabled; - world->range_check_enabled = enable; - return old_value; -} + /* Variable ids used in terms */ + ecs_rule_term_vars_t term_vars[ECS_RULE_MAX_VAR_COUNT]; -void ecs_set_entity_generation( - ecs_world_t *world, - ecs_entity_t entity_with_generation) -{ - flecs_sparse_set_generation( - &world->store.entity_index, entity_with_generation); -} + /* Variable array */ + ecs_rule_var_t vars[ECS_RULE_MAX_VAR_COUNT]; -int32_t ecs_get_threads( - ecs_world_t *world) -{ - return ecs_vector_count(world->worker_stages); -} + int32_t var_count; /* Number of variables in signature */ + int32_t subj_var_count; + int32_t frame_count; /* Number of register frames */ + int32_t operation_count; /* Number of operations in rule */ -bool ecs_enable_locking( - ecs_world_t *world, - bool enable) -{ - ecs_poly_assert(world, ecs_world_t); + ecs_iterable_t iterable; /* Iterable mixin */ +}; - if (enable) { - if (!world->locking_enabled) { - world->mutex = ecs_os_mutex_new(); - world->thr_sync = ecs_os_mutex_new(); - world->thr_cond = ecs_os_cond_new(); - } - } else { - if (world->locking_enabled) { - ecs_os_mutex_free(world->mutex); - ecs_os_mutex_free(world->thr_sync); - ecs_os_cond_free(world->thr_cond); - } +/* ecs_rule_t mixins */ +ecs_mixins_t ecs_rule_t_mixins = { + .type_name = "ecs_rule_t", + .elems = { + [EcsMixinWorld] = offsetof(ecs_rule_t, world), + [EcsMixinIterable] = offsetof(ecs_rule_t, iterable) } +}; - bool old = world->locking_enabled; - world->locking_enabled = enable; - return old; -} - -void ecs_lock( - ecs_world_t *world) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); - ecs_os_mutex_lock(world->mutex); -} - -void ecs_unlock( - ecs_world_t *world) +static +void rule_error( + const ecs_rule_t *rule, + const char *fmt, + ...) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); - ecs_os_mutex_unlock(world->mutex); + va_list valist; + va_start(valist, fmt); + ecs_parser_errorv(rule->filter.name, rule->filter.expr, -1, fmt, valist); + va_end(valist); } -void ecs_begin_wait( - ecs_world_t *world) +static +bool subj_is_set( + ecs_term_t *term) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); - ecs_os_mutex_lock(world->thr_sync); - ecs_os_cond_wait(world->thr_cond, world->thr_sync); + return ecs_term_id_is_set(&term->subj); } -void ecs_end_wait( - ecs_world_t *world) +static +bool obj_is_set( + ecs_term_t *term) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(world->locking_enabled, ECS_INVALID_PARAMETER, NULL); - ecs_os_mutex_unlock(world->thr_sync); + return ecs_term_id_is_set(&term->obj) || term->role == ECS_PAIR; } -const ecs_type_info_t* flecs_get_type_info( - const ecs_world_t *world, - ecs_entity_t component) +static +ecs_rule_op_t* create_operation( + ecs_rule_t *rule) { - ecs_poly_assert(world, ecs_world_t); + int32_t cur = rule->operation_count ++; + rule->operations = ecs_os_realloc( + rule->operations, (cur + 1) * ECS_SIZEOF(ecs_rule_op_t)); - ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!(component & ECS_ROLE_MASK), ECS_INTERNAL_ERROR, NULL); + ecs_rule_op_t *result = &rule->operations[cur]; + ecs_os_memset_t(result, 0, ecs_rule_op_t); - return flecs_sparse_get(world->type_info, ecs_type_info_t, component); + return result; } -ecs_type_info_t* flecs_ensure_type_info( - ecs_world_t *world, - ecs_entity_t component) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_assert(component != 0, ECS_INTERNAL_ERROR, NULL); - - const ecs_type_info_t *ti = flecs_get_type_info(world, component); - ecs_type_info_t *ti_mut = NULL; - if (!ti) { - ti_mut = flecs_sparse_ensure( - world->type_info, ecs_type_info_t, component); - ecs_assert(ti_mut != NULL, ECS_INTERNAL_ERROR, NULL); - } else { - ti_mut = (ecs_type_info_t*)ti; +static +const char* get_var_name(const char *name) { + if (name && !ecs_os_strcmp(name, "This")) { + /* Make sure that both This and . resolve to the same variable */ + name = "."; } - return ti_mut; -} - -void flecs_init_type_info( - ecs_world_t *world, - ecs_entity_t component, - ecs_size_t size, - ecs_size_t alignment) -{ - ecs_type_info_t *ti = flecs_ensure_type_info(world, component); - ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ti->size == 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ti->alignment == 0, ECS_INTERNAL_ERROR, NULL); - ti->size = size; - ti->alignment = alignment; + return name; } static -FLECS_FLOAT insert_sleep( - ecs_world_t *world, - ecs_time_t *stop) +ecs_rule_var_t* create_variable( + ecs_rule_t *rule, + ecs_rule_var_kind_t kind, + const char *name) { - ecs_poly_assert(world, ecs_world_t); - - ecs_time_t start = *stop; - FLECS_FLOAT delta_time = (FLECS_FLOAT)ecs_time_measure(stop); - - if (world->stats.target_fps == (FLECS_FLOAT)0.0) { - return delta_time; + int32_t cur = ++ rule->var_count; + + name = get_var_name(name); + if (name && !ecs_os_strcmp(name, "*")) { + /* Wildcards are treated as anonymous variables */ + name = NULL; } - FLECS_FLOAT target_delta_time = - ((FLECS_FLOAT)1.0 / (FLECS_FLOAT)world->stats.target_fps); - - /* Calculate the time we need to sleep by taking the measured delta from the - * previous frame, and subtracting it from target_delta_time. */ - FLECS_FLOAT sleep = target_delta_time - delta_time; - - /* Pick a sleep interval that is 4 times smaller than the time one frame - * should take. */ - FLECS_FLOAT sleep_time = sleep / (FLECS_FLOAT)4.0; + ecs_rule_var_t *var = &rule->vars[cur - 1]; + if (name) { + var->name = ecs_os_strdup(name); + } else { + /* Anonymous register */ + char name_buff[32]; + ecs_os_sprintf(name_buff, "_%u", cur - 1); + var->name = ecs_os_strdup(name_buff); + } - do { - /* Only call sleep when sleep_time is not 0. On some platforms, even - * a sleep with a timeout of 0 can cause stutter. */ - if (sleep_time != 0) { - ecs_sleepf((double)sleep_time); - } + var->kind = kind; - ecs_time_t now = start; - delta_time = (FLECS_FLOAT)ecs_time_measure(&now); - } while ((target_delta_time - delta_time) > - (sleep_time / (FLECS_FLOAT)2.0)); + /* The variable id is the location in the variable array and also points to + * the register element that corresponds with the variable. */ + var->id = cur - 1; - return delta_time; + /* Depth is used to calculate how far the variable is from the root, where + * the root is the variable with 0 dependencies. */ + var->depth = UINT8_MAX; + var->marked = false; + var->occurs = 0; + + return var; } static -FLECS_FLOAT start_measure_frame( - ecs_world_t *world, - FLECS_FLOAT user_delta_time) +ecs_rule_var_t* create_anonymous_variable( + ecs_rule_t *rule, + ecs_rule_var_kind_t kind) { - ecs_poly_assert(world, ecs_world_t); + return create_variable(rule, kind, NULL); +} - FLECS_FLOAT delta_time = 0; +/* Find variable with specified name and type. If Unknown is provided as type, + * the function will return any variable with the provided name. The root + * variable can occur both as a table and entity variable, as some rules + * require that each entity in a table is iterated. In this case, there are two + * variables, one for the table and one for the entities in the table, that both + * have the same name. */ +static +ecs_rule_var_t* find_variable( + const ecs_rule_t *rule, + ecs_rule_var_kind_t kind, + const char *name) +{ + ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL); - if (world->measure_frame_time || (user_delta_time == 0)) { - ecs_time_t t = world->frame_start_time; - do { - if (world->frame_start_time.nanosec || world->frame_start_time.sec){ - delta_time = insert_sleep(world, &t); + name = get_var_name(name); - ecs_time_measure(&t); - } else { - ecs_time_measure(&t); - if (world->stats.target_fps != 0) { - delta_time = (FLECS_FLOAT)1.0 / world->stats.target_fps; - } else { - /* Best guess */ - delta_time = (FLECS_FLOAT)1.0 / (FLECS_FLOAT)60.0; - } + const ecs_rule_var_t *variables = rule->vars; + int32_t i, count = rule->var_count; + + for (i = 0; i < count; i ++) { + const ecs_rule_var_t *variable = &variables[i]; + if (!ecs_os_strcmp(name, variable->name)) { + if (kind == EcsRuleVarKindUnknown || kind == variable->kind) { + return (ecs_rule_var_t*)variable; } - - /* Keep trying while delta_time is zero */ - } while (delta_time == 0); - - world->frame_start_time = t; - - /* Keep track of total time passed in world */ - world->stats.world_time_total_raw += (FLECS_FLOAT)delta_time; + } } - return (FLECS_FLOAT)delta_time; + return NULL; } +/* Ensure variable with specified name and type exists. If an existing variable + * is found with an unknown type, its type will be overwritten with the + * specified type. During the variable ordering phase it is not yet clear which + * variable is the root. Which variable is the root determines its type, which + * is why during this phase variables are still untyped. */ static -void stop_measure_frame( - ecs_world_t* world) +ecs_rule_var_t* ensure_variable( + ecs_rule_t *rule, + ecs_rule_var_kind_t kind, + const char *name) { - ecs_poly_assert(world, ecs_world_t); - - if (world->measure_frame_time) { - ecs_time_t t = world->frame_start_time; - world->stats.frame_time_total += (FLECS_FLOAT)ecs_time_measure(&t); + ecs_rule_var_t *var = find_variable(rule, kind, name); + if (!var) { + var = create_variable(rule, kind, name); + } else { + if (var->kind == EcsRuleVarKindUnknown) { + var->kind = kind; + } } + + return var; } -FLECS_FLOAT ecs_frame_begin( - ecs_world_t *world, - FLECS_FLOAT user_delta_time) +static +const char *term_id_var_name( + ecs_term_id_t *term_id) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(world->is_readonly == false, ECS_INVALID_OPERATION, NULL); - ecs_check(user_delta_time != 0 || ecs_os_has_time(), - ECS_MISSING_OS_API, "get_time"); - - if (world->locking_enabled) { - ecs_lock(world); + if (term_id->var == EcsVarIsVariable) { + if (term_id->name) { + return term_id->name; + } else if (term_id->entity == EcsThis) { + return "."; + } else if (term_id->entity == EcsWildcard) { + return "*"; + } else if (term_id->entity == EcsAny) { + return "_"; + } else { + ecs_check(term_id->name != NULL, ECS_INVALID_PARAMETER, NULL); + } } - - /* Start measuring total frame time */ - FLECS_FLOAT delta_time = start_measure_frame(world, user_delta_time); - if (user_delta_time == 0) { - user_delta_time = delta_time; - } - - world->stats.delta_time_raw = user_delta_time; - world->stats.delta_time = user_delta_time * world->stats.time_scale; - - /* Keep track of total scaled time passed in world */ - world->stats.world_time_total += world->stats.delta_time; - - ecs_force_aperiodic(world); - - return world->stats.delta_time; + error: - return (FLECS_FLOAT)0; + return NULL; } -void ecs_frame_end( - ecs_world_t *world) +static +ecs_rule_var_t* ensure_term_id_variable( + ecs_rule_t *rule, + ecs_term_id_t *term_id) { - ecs_poly_assert(world, ecs_world_t); - ecs_check(world->is_readonly == false, ECS_INVALID_OPERATION, NULL); - - world->stats.frame_count_total ++; - - ecs_vector_each(world->worker_stages, ecs_stage_t, stage, { - flecs_stage_merge_post_frame(world, stage); - }); - - if (world->locking_enabled) { - ecs_unlock(world); + if (term_id->var == EcsVarIsVariable) { + if (term_id->entity == EcsAny) { + /* Any variables aren't translated to rule variables since their + * result isn't stored. */ + return NULL; + } - ecs_os_mutex_lock(world->thr_sync); - ecs_os_cond_broadcast(world->thr_cond); - ecs_os_mutex_unlock(world->thr_sync); + const char *name = term_id_var_name(term_id); + ecs_rule_var_t *var = ensure_variable(rule, EcsRuleVarKindEntity, name); + ecs_os_strset(&term_id->name, var->name); + return var; } - - stop_measure_frame(world); -error: - return; + return NULL; } -const ecs_world_info_t* ecs_get_world_info( - const ecs_world_t *world) +static +bool term_id_is_variable( + ecs_term_id_t *term_id) { - world = ecs_get_world(world); - return &world->stats; + return term_id->var == EcsVarIsVariable; } -void flecs_notify_queries( - ecs_world_t *world, - ecs_query_event_t *event) +/* Get variable from a term identifier */ +static +ecs_rule_var_t* term_id_to_var( + ecs_rule_t *rule, + ecs_term_id_t *id) { - ecs_poly_assert(world, ecs_world_t); - - int32_t i, count = flecs_sparse_count(world->queries); - for (i = 0; i < count; i ++) { - ecs_query_t *query = flecs_sparse_get_dense( - world->queries, ecs_query_t, i); - if (query->flags & EcsQueryIsSubquery) { - continue; - } - - flecs_query_notify(world, query, event); - } + if (id->var == EcsVarIsVariable) {; + return find_variable(rule, EcsRuleVarKindUnknown, term_id_var_name(id)); + } + return NULL; } -void flecs_delete_table( - ecs_world_t *world, - ecs_table_t *table) +/* Get variable from a term predicate */ +static +ecs_rule_var_t* term_pred( + ecs_rule_t *rule, + ecs_term_t *term) { - ecs_poly_assert(world, ecs_world_t); - flecs_table_release(world, table); + return term_id_to_var(rule, &term->pred); } -/** Walk over tables that had a state change which requires bookkeeping */ -void flecs_process_pending_tables( - const ecs_world_t *world_r) +/* Get variable from a term subject */ +static +ecs_rule_var_t* term_subj( + ecs_rule_t *rule, + ecs_term_t *term) { - ecs_poly_assert(world_r, ecs_world_t); + return term_id_to_var(rule, &term->subj); +} - /* We can't update the administration while in readonly mode, but we can - * ensure that when this function is called there are no pending events. */ - if (world_r->is_readonly) { - ecs_assert(flecs_sparse_count(world_r->pending_tables) == 0, - ECS_INTERNAL_ERROR, NULL); - return; +/* Get variable from a term object */ +static +ecs_rule_var_t* term_obj( + ecs_rule_t *rule, + ecs_term_t *term) +{ + if (obj_is_set(term)) { + return term_id_to_var(rule, &term->obj); + } else { + return NULL; } +} - /* Safe to cast, world is not readonly */ - ecs_world_t *world = (ecs_world_t*)world_r; - - /* If pending buffer is NULL there already is a stackframe that's iterating - * the table list. This can happen when a trigger for a table event results - * in a mutation that causes another table to change state. A typical - * example of this is a system that becomes active/inactive as the result of - * a query (and as a result, its matched tables) becoming empty/non empty */ - if (!world->pending_buffer) { - return; +/* Return predicate variable from pair */ +static +ecs_rule_var_t* pair_pred( + ecs_rule_t *rule, + const ecs_rule_pair_t *pair) +{ + if (pair->reg_mask & RULE_PAIR_PREDICATE) { + return &rule->vars[pair->pred.reg]; + } else { + return NULL; } +} - /* Swap buffer. The logic could in theory have been implemented with a - * single sparse set, but that would've complicated (and slowed down) the - * iteration. Additionally, by using a double buffer approach we can still - * keep most of the original ordering of events intact, which is desirable - * as it means that the ordering of tables in the internal datastructures is - * more predictable. */ - int32_t i, count = flecs_sparse_count(world->pending_tables); - if (!count) { - return; +/* Return object variable from pair */ +static +ecs_rule_var_t* pair_obj( + ecs_rule_t *rule, + const ecs_rule_pair_t *pair) +{ + if (pair->reg_mask & RULE_PAIR_OBJECT) { + return &rule->vars[pair->obj.reg]; + } else { + return NULL; } - - do { - ecs_sparse_t *pending_tables = world->pending_tables; - world->pending_tables = world->pending_buffer; - world->pending_buffer = NULL; - - for (i = 0; i < count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense( - pending_tables, ecs_table_t*, i)[0]; - if (!table->id) { - /* Table is being deleted, ignore empty events */ - continue; - } - - /* For each id in the table, add it to the empty/non empty list - * based on its current state */ - if (flecs_table_records_update_empty(table)) { - /* Only emit an event when there was a change in the - * administration. It is possible that a table ended up in the - * pending_tables list by going from empty->non-empty, but then - * became empty again. By the time we run this code, no changes - * in the administration would actually be made. */ - ecs_ids_t ids = { - .array = ecs_vector_first(table->type, ecs_id_t), - .count = ecs_vector_count(table->type) - }; - - ecs_emit(world, &(ecs_event_desc_t) { - .event = ecs_table_count(table) - ? EcsOnTableFill - : EcsOnTableEmpty - , - .table = table, - .ids = &ids, - .observable = world, - .table_event = true - }); - } - } - flecs_sparse_clear(pending_tables); - - world->pending_buffer = pending_tables; - } while ((count = flecs_sparse_count(world->pending_tables))); } -void flecs_table_set_empty( - ecs_world_t *world, - ecs_table_t *table) +/* Create new frame for storing register values. Each operation that yields data + * gets its own register frame, which contains all variables reified up to that + * point. The preceding frame always contains the reified variables from the + * previous operation. Operations that do not yield data (such as control flow) + * do not have their own frames. */ +static +int32_t push_frame( + ecs_rule_t *rule) { - ecs_poly_assert(world, ecs_world_t); - ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); - - flecs_sparse_set_generation(world->pending_tables, (uint32_t)table->id); - flecs_sparse_ensure(world->pending_tables, ecs_table_t*, - (uint32_t)table->id)[0] = table; + return rule->frame_count ++; } -ecs_id_record_t* flecs_ensure_id_record( - ecs_world_t *world, - ecs_id_t id) +/* Get register array for current stack frame. The stack frame is determined by + * the current operation that is evaluated. The register array contains the + * values for the reified variables. If a variable hasn't been reified yet, its + * register will store a wildcard. */ +static +ecs_rule_reg_t* get_register_frame( + const ecs_rule_iter_t *it, + int32_t frame) { - ecs_id_record_t **idr_ptr = ecs_map_ensure(&world->id_index, - ecs_id_record_t*, ecs_strip_generation(id)); - ecs_id_record_t *idr = idr_ptr[0]; - if (!idr) { - idr_ptr[0] = idr = new_id_record(world, id); + if (it->registers) { + return &it->registers[frame * it->rule->var_count]; + } else { + return NULL; } - - return idr; } -ecs_id_record_t* flecs_get_id_record( - const ecs_world_t *world, - ecs_id_t id) +/* Get register array for current stack frame. The stack frame is determined by + * the current operation that is evaluated. The register array contains the + * values for the reified variables. If a variable hasn't been reified yet, its + * register will store a wildcard. */ +static +ecs_rule_reg_t* get_registers( + const ecs_rule_iter_t *it, + ecs_rule_op_t *op) { - return ecs_map_get_ptr(&world->id_index, ecs_id_record_t*, - ecs_strip_generation(id)); + return get_register_frame(it, op->frame); } -ecs_hashmap_t* flecs_ensure_id_name_index( - ecs_world_t *world, - ecs_id_t id) +/* Get columns array. Columns store, for each matched column in a table, the + * index at which it occurs. This reduces the amount of searching that + * operations need to do in a type, since select/with already provide it. */ +static +int32_t* rule_get_columns_frame( + ecs_rule_iter_t *it, + int32_t frame) { - ecs_id_record_t *idr = flecs_get_id_record(world, id); - ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); + return &it->columns[frame * it->rule->filter.term_count]; +} - ecs_hashmap_t *map = idr->name_index; - if (!map) { - map = idr->name_index = flecs_name_index_new(); - } +static +int32_t* rule_get_columns( + ecs_rule_iter_t *it, + ecs_rule_op_t *op) +{ + return rule_get_columns_frame(it, op->frame); +} - return map; +static +void entity_reg_set( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r, + ecs_entity_t entity) +{ + (void)rule; + ecs_assert(rule->vars[r].kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + ecs_check(ecs_is_valid(rule->world, entity), ECS_INVALID_PARAMETER, NULL); + regs[r].entity = entity; +error: + return; } -ecs_hashmap_t* flecs_get_id_name_index( - const ecs_world_t *world, - ecs_id_t id) +static +ecs_entity_t entity_reg_get( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r) { - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return NULL; + (void)rule; + ecs_entity_t e = regs[r].entity; + if (!e) { + return EcsWildcard; } - - return idr->name_index; + + ecs_check(ecs_is_valid(rule->world, e), ECS_INVALID_PARAMETER, NULL); + return e; +error: + return 0; } -ecs_table_record_t* flecs_get_table_record( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_id_t id) +static +void table_reg_set( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r, + ecs_table_t *table) { - ecs_id_record_t* idr = flecs_get_id_record(world, id); - if (!idr) { - return NULL; - } + (void)rule; + ecs_assert(rule->vars[r].kind == EcsRuleVarKindTable, + ECS_INTERNAL_ERROR, NULL); - return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table); + regs[r].table.table = table; + regs[r].table.offset = 0; + regs[r].table.count = 0; + regs[r].entity = 0; } -void flecs_remove_id_record( - ecs_world_t *world, - ecs_id_t id, - ecs_id_record_t *idr) +static +ecs_table_slice_t table_reg_get( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r) { - /* Free id record resources */ - if (free_id_record(world, id, idr)) { - /* Remove record from world index */ - ecs_map_remove(&world->id_index, ecs_strip_generation(id)); - } + (void)rule; + ecs_assert(rule->vars[r].kind == EcsRuleVarKindTable, + ECS_INTERNAL_ERROR, NULL); + + return regs[r].table; } -void flecs_clear_id_record( - ecs_world_t *world, - ecs_id_t id, - ecs_id_record_t *idr) +static +ecs_entity_t reg_get_entity( + const ecs_rule_t *rule, + ecs_rule_op_t *op, + ecs_rule_reg_t *regs, + int32_t r) { - if (world->is_fini) { - return; - } - - ecs_table_cache_fini_delete_all(world, &idr->cache); + if (r == UINT8_MAX) { + ecs_assert(op->subject != 0, ECS_INTERNAL_ERROR, NULL); - flecs_remove_id_record(world, id, idr); -} + /* The subject is referenced from the query string by string identifier. + * If subject entity is not valid, it could have been deletd by the + * application after the rule was created */ + ecs_check(ecs_is_valid(rule->world, op->subject), + ECS_INVALID_PARAMETER, NULL); -bool flecs_id_existst( - ecs_world_t *world, - ecs_id_t id) -{ - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return false; + return op->subject; } - return (ecs_table_cache_count(&idr->cache) != 0) || - (ecs_table_cache_empty_count(&idr->cache) != 0); -} + if (rule->vars[r].kind == EcsRuleVarKindTable) { + int32_t offset = regs[r].table.offset; -const ecs_table_record_t* flecs_id_record_table( - ecs_id_record_t *idr, - ecs_table_t *table) -{ - if (!idr) { - return NULL; + ecs_assert(regs[r].table.count == 1, ECS_INTERNAL_ERROR, NULL); + ecs_data_t *data = &table_reg_get(rule, regs, r).table->storage; + ecs_assert(data != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(offset < ecs_vector_count(data->entities), + ECS_INTERNAL_ERROR, NULL); + ecs_check(ecs_is_valid(rule->world, entities[offset]), + ECS_INVALID_PARAMETER, NULL); + + return entities[offset]; } - return (ecs_table_record_t*)ecs_table_cache_get(&idr->cache, table); -} - -ecs_id_record_t* flecs_table_iter( - ecs_world_t *world, - ecs_id_t id, - ecs_table_cache_iter_t *out) -{ - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return NULL; + if (rule->vars[r].kind == EcsRuleVarKindEntity) { + return entity_reg_get(rule, regs, r); } - flecs_process_pending_tables(world); - ecs_assert( flecs_sparse_count(world->pending_tables) == 0, - ECS_INTERNAL_ERROR, NULL); + /* Must return an entity */ + ecs_assert(false, ECS_INTERNAL_ERROR, NULL); - flecs_table_cache_iter(&idr->cache, out); - return idr; +error: + return 0; } -ecs_id_record_t* flecs_empty_table_iter( - ecs_world_t *world, - ecs_id_t id, - ecs_table_cache_iter_t *out) +static +ecs_table_slice_t table_from_entity( + const ecs_world_t *world, + ecs_entity_t entity) { - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return NULL; + ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); + + ecs_table_slice_t slice = {0}; + ecs_record_t *record = ecs_eis_get(world, entity); + if (record) { + slice.table = record->table; + slice.offset = ECS_RECORD_TO_ROW(record->row); + slice.count = 1; } - flecs_process_pending_tables(world); - ecs_assert( flecs_sparse_count(world->pending_tables) == 0, - ECS_INTERNAL_ERROR, NULL); - - flecs_table_cache_empty_iter(&idr->cache, out); - return idr; + return slice; } -void ecs_force_aperiodic( - ecs_world_t *world) +static +ecs_table_slice_t reg_get_table( + const ecs_rule_t *rule, + ecs_rule_op_t *op, + ecs_rule_reg_t *regs, + int32_t r) { - flecs_process_pending_tables(world); - flecs_eval_component_monitors(world); + if (r == UINT8_MAX) { + ecs_check(ecs_is_valid(rule->world, op->subject), + ECS_INVALID_PARAMETER, NULL); + return table_from_entity(rule->world, op->subject); + } + if (rule->vars[r].kind == EcsRuleVarKindTable) { + return table_reg_get(rule, regs, r); + } + if (rule->vars[r].kind == EcsRuleVarKindEntity) { + return table_from_entity(rule->world, entity_reg_get(rule, regs, r)); + } +error: + return (ecs_table_slice_t){0}; } - -void flecs_observable_init( - ecs_observable_t *observable) +static +void reg_set_entity( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r, + ecs_entity_t entity) { - observable->events = ecs_sparse_new(ecs_event_record_t); + if (rule->vars[r].kind == EcsRuleVarKindTable) { + ecs_world_t *world = rule->world; + ecs_check(ecs_is_valid(world, entity), ECS_INVALID_PARAMETER, NULL); + regs[r].table = table_from_entity(world, entity); + regs[r].entity = entity; + } else { + entity_reg_set(rule, regs, r, entity); + } +error: + return; } -void flecs_observable_fini( - ecs_observable_t *observable) +static +void reg_set_table( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t r, + ecs_table_slice_t table) { - ecs_sparse_t *triggers = observable->events; - int32_t i, count = flecs_sparse_count(triggers); - - for (i = 0; i < count; i ++) { - ecs_event_record_t *et = - ecs_sparse_get_dense(triggers, ecs_event_record_t, i); - ecs_assert(et != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_map_iter_t it = ecs_map_iter(&et->event_ids); - ecs_event_id_record_t *idt; - while ((idt = ecs_map_next(&it, ecs_event_id_record_t, NULL))) { - ecs_map_fini(&idt->triggers); - ecs_map_fini(&idt->set_triggers); - } - ecs_map_fini(&et->event_ids); + if (rule->vars[r].kind == EcsRuleVarKindEntity) { + ecs_check(table.count == 1, ECS_INTERNAL_ERROR, NULL); + regs[r].table = table; + regs[r].entity = ecs_vector_get(table.table->storage.entities, + ecs_entity_t, table.offset)[0]; + } else { + regs[r].table = table; + regs[r].entity = 0; } - - flecs_sparse_free(observable->events); +error: + return; } +/* This encodes a column expression into a pair. A pair stores information about + * the variable(s) associated with the column. Pairs are used by operations to + * apply filters, and when there is a match, to reify variables. */ static -void notify_subset( - ecs_world_t *world, - ecs_iter_t *it, - ecs_observable_t *observable, - ecs_entity_t entity, - ecs_entity_t event, - ecs_ids_t *ids) +ecs_rule_pair_t term_to_pair( + ecs_rule_t *rule, + ecs_term_t *term) { - ecs_id_t pair = ecs_pair(EcsWildcard, entity); - ecs_table_cache_iter_t idt; - ecs_id_record_t *idr = flecs_table_iter(world, pair, &idt); - if (!idr) { - return; - } - - const ecs_table_record_t *tr; - while ((tr = flecs_table_cache_next(&idt, ecs_table_record_t))) { - ecs_table_t *table = tr->hdr.table; - ecs_id_t id = ecs_vector_get(table->type, ecs_id_t, tr->column)[0]; - ecs_entity_t rel = ECS_PAIR_FIRST(id); - - if (ecs_is_valid(world, rel) && !ecs_has_id(world, rel, EcsAcyclic)) { - /* Only notify for acyclic relations */ - continue; - } + ecs_rule_pair_t result = {0}; - int32_t e, entity_count = ecs_table_count(table); - it->table = table; - it->type = table->type; - it->other_table = NULL; - it->offset = 0; - it->count = entity_count; + /* Terms must always have at least one argument (the subject) */ + ecs_assert(subj_is_set(term), ECS_INTERNAL_ERROR, NULL); - /* Treat as new event as this could trigger observers again for - * different tables. */ - world->event_id ++; + /* If the predicate id is a variable, find the variable and encode its id + * in the pair so the operation can find it later. */ + if (term->pred.var == EcsVarIsVariable) { + if (term->pred.entity != EcsAny) { + /* Always lookup var as an entity, as pairs never refer to tables */ + const ecs_rule_var_t *var = find_variable( + rule, EcsRuleVarKindEntity, term_id_var_name(&term->pred)); - flecs_set_triggers_notify(it, observable, ids, event, - ecs_pair(rel, EcsWildcard)); + /* Variables should have been declared */ + ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(var->kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + result.pred.reg = var->id; - ecs_entity_t *entities = ecs_vector_first( - table->storage.entities, ecs_entity_t); - ecs_record_t **records = ecs_vector_first( - table->storage.record_ptrs, ecs_record_t*); + /* Set flag so the operation can see the predicate is a variable */ + result.reg_mask |= RULE_PAIR_PREDICATE; + result.final = true; + } else { + result.pred.ent = EcsWildcard; + result.final = true; + } + } else { + /* If the predicate is not a variable, simply store its id. */ + ecs_entity_t pred_id = term->pred.entity; + result.pred.ent = pred_id; - for (e = 0; e < entity_count; e ++) { - uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(records[e]->row); - if (flags & ECS_FLAG_OBSERVED_ACYCLIC) { - /* Only notify for entities that are used in pairs with - * acyclic relations */ - notify_subset(world, it, observable, entities[e], event, ids); + /* Test if predicate is transitive. When evaluating the predicate, this + * will also take into account transitive relationships */ + if (ecs_has_id(rule->world, pred_id, EcsTransitive)) { + /* Transitive queries must have an object */ + if (obj_is_set(term)) { + result.transitive = true; } } - } -} -void ecs_emit( - ecs_world_t *world, - ecs_event_desc_t *desc) -{ - ecs_poly_assert(world, ecs_world_t); - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->event != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->event != EcsWildcard, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->ids != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->ids->count != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->table != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->observable != NULL, ECS_INVALID_PARAMETER, NULL); + if (ecs_has_id(rule->world, pred_id, EcsFinal)) { + result.final = true; + } - ecs_ids_t *ids = desc->ids; - ecs_entity_t event = desc->event; - ecs_table_t *table = desc->table; - int32_t row = desc->offset; - int32_t i, count = desc->count; - ecs_entity_t relation = desc->relation; + if (ecs_has_id(rule->world, pred_id, EcsReflexive)) { + result.reflexive = true; + } - if (!count) { - count = ecs_table_count(table) - row; + if (ecs_has_id(rule->world, pred_id, EcsAcyclic)) { + result.acyclic = true; + } } - ecs_iter_t it = { - .world = world, - .real_world = world, - .table = table, - .type = table->type, - .term_count = 1, - .other_table = desc->other_table, - .offset = row, - .count = count, - .param = (void*)desc->param, - .table_only = desc->table_event - }; - - world->event_id ++; - - ecs_observable_t *observable = ecs_get_observable(desc->observable); - ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL); - - if (!desc->relation) { - flecs_triggers_notify(&it, observable, ids, event); - } else { - flecs_set_triggers_notify(&it, observable, ids, event, - ecs_pair(relation, EcsWildcard)); + /* The pair doesn't do anything with the subject (subjects are the things that + * are matched against pairs) so if the column does not have a object, + * there is nothing left to do. */ + if (!obj_is_set(term)) { + return result; } - if (count && !desc->table_event) { - ecs_record_t **recs = ecs_vector_get( - table->storage.record_ptrs, ecs_record_t*, row); + /* If arguments is higher than 2 this is not a pair but a nested rule */ + ecs_assert(obj_is_set(term), ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < count; i ++) { - ecs_record_t *r = recs[i]; - if (!r) { - /* If the event is emitted after a bulk operation, it's possible - * that it hasn't been populate with entities yet. */ - continue; - } + /* Same as above, if the object is a variable, store it and flag it */ + if (term->obj.var == EcsVarIsVariable) { + if (term->obj.entity != EcsAny) { + const ecs_rule_var_t *var = find_variable( + rule, EcsRuleVarKindEntity, term_id_var_name(&term->obj)); - uint32_t flags = ECS_RECORD_TO_ROW_FLAGS(recs[i]->row); - if (flags & ECS_FLAG_OBSERVED_ACYCLIC) { - notify_subset(world, &it, observable, ecs_vector_first( - table->storage.entities, ecs_entity_t)[row + i], - event, ids); - } + /* Variables should have been declared */ + ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(var->kind == EcsRuleVarKindEntity, ECS_INTERNAL_ERROR, + NULL); + + result.obj.reg = var->id; + result.reg_mask |= RULE_PAIR_OBJECT; + } else { + result.obj.ent = EcsWildcard; + } + } else { + /* If the object is not a variable, simply store its id */ + result.obj.ent = term->obj.entity; + if (!result.obj.ent) { + result.obj_0 = true; } } - -error: - return; -} - -#include + return result; +} +/* When an operation has a pair, it is used to filter its input. This function + * translates a pair back into an entity id, and in the process substitutes the + * variables that have already been filled out. It's one of the most important + * functions, as a lot of the filtering logic depends on having an entity that + * has all of the reified variables correctly filled out. */ static -void term_error( - const ecs_world_t *world, - const ecs_term_t *term, - const char *name, - const char *fmt, - ...) +ecs_rule_filter_t pair_to_filter( + ecs_rule_iter_t *it, + ecs_rule_op_t *op, + ecs_rule_pair_t pair) { - va_list args; - va_start(args, fmt); + ecs_entity_t pred = pair.pred.ent; + ecs_entity_t obj = pair.obj.ent; + ecs_rule_filter_t result = { + .lo_var = -1, + .hi_var = -1 + }; - char *expr = ecs_term_str(world, term); - ecs_parser_errorv(name, expr, 0, fmt, args); - ecs_os_free(expr); + /* Get registers in case we need to resolve ids from registers. Get them + * from the previous, not the current stack frame as the current operation + * hasn't reified its variables yet. */ + ecs_rule_reg_t *regs = get_register_frame(it, op->frame - 1); - va_end(args); -} + if (pair.reg_mask & RULE_PAIR_OBJECT) { + obj = entity_reg_get(it->rule, regs, pair.obj.reg); + obj = ecs_entity_t_lo(obj); /* Filters don't have generations */ -static -int finalize_term_set( - const ecs_world_t *world, - ecs_term_t *term, - ecs_term_id_t *identifier, - const char *name) -{ - if (identifier->set.mask & EcsParent) { - identifier->set.mask |= EcsSuperSet; - identifier->set.relation = EcsChildOf; + if (obj == EcsWildcard) { + result.wildcard = true; + result.obj_wildcard = true; + result.lo_var = pair.obj.reg; + } } - /* Default relation for superset/subset is EcsIsA */ - if (identifier->set.mask & (EcsSuperSet|EcsSubSet)) { - if (!identifier->set.relation) { - identifier->set.relation = EcsIsA; - } + if (pair.reg_mask & RULE_PAIR_PREDICATE) { + pred = entity_reg_get(it->rule, regs, pair.pred.reg); + pred = ecs_entity_t_lo(pred); /* Filters don't have generations */ - if (!(identifier->set.mask & EcsSelf)) { - if (!identifier->set.min_depth) { - identifier->set.min_depth = 1; + if (pred == EcsWildcard) { + if (result.wildcard) { + result.same_var = pair.pred.reg == pair.obj.reg; } - } - } else { - if (identifier->set.min_depth > 0) { - term_error(world, term, name, - "min depth cannnot be non-zero for Self term"); - return -1; - } - if (identifier->set.max_depth > 1) { - term_error(world, term, name, - "max depth cannnot be larger than 1 for Self term"); - return -1; - } - identifier->set.max_depth = 1; + result.wildcard = true; + result.pred_wildcard = true; + + if (obj) { + result.hi_var = pair.pred.reg; + } else { + result.lo_var = pair.pred.reg; + } + } } - if ((identifier->set.mask != EcsNothing) && - (identifier->set.mask & EcsNothing)) - { - term_error(world, term, name, "invalid Nothing in set mask"); - return -1; + if (!obj && !pair.obj_0) { + result.mask = pred; + } else { + result.mask = ecs_pair(pred, obj); } - return 0; + return result; } +/* This function is responsible for reifying the variables (filling them out + * with their actual values as soon as they are known). It uses the pair + * expression returned by pair_get_most_specific_var, and attempts to fill out each of the + * wildcards in the pair. If a variable isn't reified yet, the pair expression + * will still contain one or more wildcards, which is harmless as the respective + * registers will also point to a wildcard. */ static -int finalize_term_var( - const ecs_world_t *world, - ecs_term_t *term, - ecs_term_id_t *identifier, - const char *name) +void reify_variables( + ecs_rule_iter_t *it, + ecs_rule_op_t *op, + ecs_rule_filter_t *filter, + ecs_type_t type, + int32_t column) { - if (identifier->var == EcsVarDefault) { - const char *var = ecs_identifier_is_var(identifier->name); - if (var) { - char *var_dup = ecs_os_strdup(var); - ecs_os_free(identifier->name); - identifier->name = var_dup; - identifier->var = EcsVarIsVariable; - } - } - - if (identifier->var == EcsVarDefault && identifier->set.mask != EcsNothing){ - identifier->var = EcsVarIsEntity; - } - - if (!identifier->name) { - return 0; - } - - if (identifier->var != EcsVarIsVariable) { - if (ecs_identifier_is_0(identifier->name)) { - identifier->entity = 0; - } else { - ecs_entity_t e = ecs_lookup_symbol(world, identifier->name, true); - if (!e) { - term_error(world, term, name, - "unresolved identifier '%s'", identifier->name); - return -1; - } + const ecs_rule_t *rule = it->rule; + const ecs_rule_var_t *vars = rule->vars; + (void)vars; - identifier->entity = e; - } - } + ecs_rule_reg_t *regs = get_registers(it, op); + ecs_entity_t *elem = ecs_vector_get(type, ecs_entity_t, column); + ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - if ((identifier->set.mask == EcsNothing) && - (identifier->var != EcsVarDefault)) - { - term_error(world, term, name, "Invalid Nothing with entity"); - return -1; - } + int32_t obj_var = filter->lo_var; + int32_t pred_var = filter->hi_var; - if (identifier->var == EcsVarIsEntity) { - if (identifier->entity && !ecs_is_alive(world, identifier->entity)) { - term_error(world, term, name, - "cannot use not alive entity %u in query", - (uint32_t)identifier->entity); - return -1; - } + if (obj_var != -1) { + ecs_assert(vars[obj_var].kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + + entity_reg_set(rule, regs, obj_var, + ecs_get_alive(rule->world, ECS_PAIR_SECOND(*elem))); } - return 0; -} + if (pred_var != -1) { + ecs_assert(vars[pred_var].kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); -static -int finalize_term_identifier( - const ecs_world_t *world, - ecs_term_t *term, - ecs_term_id_t *identifier, - const char *name) -{ - if (finalize_term_set(world, term, identifier, name)) { - return -1; - } - if (finalize_term_var(world, term, identifier, name)) { - return -1; + entity_reg_set(rule, regs, pred_var, + ecs_get_alive(rule->world, + ECS_PAIR_FIRST(*elem))); } - return 0; } +/* Returns whether variable is a subject */ static -bool term_can_inherit( - ecs_term_t *term) +bool is_subject( + ecs_rule_t *rule, + ecs_rule_var_t *var) { - /* Hardcoded components that can't be inherited. TODO: replace with - * relationship property. */ - if (term->pred.entity == EcsChildOf || - (term->id == ecs_pair(ecs_id(EcsIdentifier), EcsName)) || - (term->id == EcsPrefab) || - (term->id == EcsDisabled)) - { + ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); + + if (!var) { return false; } - return true; -} -static -ecs_entity_t term_id_entity( - const ecs_world_t *world, - ecs_term_id_t *term_id) -{ - if (term_id->entity && term_id->entity != EcsThis && - term_id->entity != EcsWildcard && term_id->entity != EcsAny) - { - if (!(term_id->entity & ECS_ROLE_MASK)) { - return term_id->entity; - } else { - return 0; - } - } else if (term_id->name) { - if (term_id->var == EcsVarIsEntity || - (term_id->var == EcsVarDefault && - !ecs_identifier_is_var(term_id->name))) - { - ecs_entity_t e = ecs_lookup_fullpath(world, term_id->name); - if (e != EcsWildcard && e != EcsThis && e != EcsAny) { - return e; - } - return 0; - } else { - return 0; - } - } else { - return 0; + if (var->id < rule->subj_var_count) { + return true; } -} -static -int finalize_term_vars( - const ecs_world_t *world, - ecs_term_t *term, - const char *name) -{ - if (finalize_term_var(world, term, &term->pred, name)) { - return -1; - } - if (finalize_term_var(world, term, &term->subj, name)) { - return -1; - } - if (finalize_term_var(world, term, &term->obj, name)) { - return -1; - } - return 0; + return false; } static -bool entity_is_var( - ecs_entity_t e) -{ - if (e == EcsThis || e == EcsWildcard || e == EcsAny) { +bool skip_term(ecs_term_t *term) { + if (term->subj.set.mask & EcsNothing) { + return true; + } + if (term->oper == EcsNot) { return true; } + return false; } static -int finalize_term_identifiers( - const ecs_world_t *world, - ecs_term_t *term, - const char *name) +int32_t get_variable_depth( + ecs_rule_t *rule, + ecs_rule_var_t *var, + ecs_rule_var_t *root, + int recur); + +static +int32_t crawl_variable( + ecs_rule_t *rule, + ecs_rule_var_t *var, + ecs_rule_var_t *root, + int recur) { - /* By default select subsets for predicates. For example, when the term - * matches "Tree", also include "Oak", "Pine", "Elm". */ - if (term->pred.set.mask == EcsDefaultSet) { - ecs_entity_t e = term_id_entity(world, &term->pred); + ecs_term_t *terms = rule->filter.terms; + int32_t i, count = rule->filter.term_count; - if (e && !ecs_has_id(world, e, EcsFinal)) { - term->pred.set.mask = EcsSelf|EcsSubSet; - } else { - /* If predicate is final, don't search subsets */ - term->pred.set.mask = EcsSelf; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + if (skip_term(term)) { + continue; } - } - - /* By default select supersets for subjects. For example, when an entity has - * (IsA, SpaceShip), also search the components of SpaceShip. */ - if (term->subj.set.mask == EcsDefaultSet) { - ecs_entity_t e = term_id_entity(world, &term->pred); + + ecs_rule_var_t + *pred = term_pred(rule, term), + *subj = term_subj(rule, term), + *obj = term_obj(rule, term); - /* If the component has the DontInherit tag, use EcsSelf */ - if (!e || !ecs_has_id(world, e, EcsDontInherit)) { - term->subj.set.mask = EcsSelf|EcsSuperSet; - } else { - term->subj.set.mask = EcsSelf; + /* Variable must at least appear once in term */ + if (var != pred && var != subj && var != obj) { + continue; } - } - - /* By default select self for objects. */ - if (term->obj.set.mask == EcsDefaultSet) { - term->obj.set.mask = EcsSelf; - } - - if (finalize_term_set(world, term, &term->pred, name)) { - return -1; - } - if (finalize_term_set(world, term, &term->subj, name)) { - return -1; - } - if (finalize_term_set(world, term, &term->obj, name)) { - return -1; - } - if (term->pred.set.mask & EcsNothing) { - term_error(world, term, name, - "invalid Nothing value for predicate set mask"); - return -1; - } + if (pred && pred != var && !pred->marked) { + get_variable_depth(rule, pred, root, recur + 1); + } - if (term->obj.set.mask & EcsNothing) { - term_error(world, term, name, - "invalid Nothing value for object set mask"); - return -1; - } + if (subj && subj != var && !subj->marked) { + get_variable_depth(rule, subj, root, recur + 1); + } - if (!(term->subj.set.mask & EcsNothing) && - !term->subj.entity && - term->subj.var == EcsVarIsEntity) - { - term->subj.entity = EcsThis; - } - - if (entity_is_var(term->pred.entity)) { - term->pred.var = EcsVarIsVariable; - } - if (entity_is_var(term->subj.entity)) { - term->subj.var = EcsVarIsVariable; - } - if (entity_is_var(term->obj.entity)) { - term->obj.var = EcsVarIsVariable; + if (obj && obj != var && !obj->marked) { + get_variable_depth(rule, obj, root, recur + 1); + } } return 0; } static -ecs_entity_t entity_from_identifier( - const ecs_term_id_t *identifier) +int32_t get_depth_from_var( + ecs_rule_t *rule, + ecs_rule_var_t *var, + ecs_rule_var_t *root, + int recur) { - if (identifier->var == EcsVarDefault) { + /* If variable is the root or if depth has been set, return depth + 1 */ + if (var == root || var->depth != UINT8_MAX) { + return var->depth + 1; + } + + /* Variable is already being evaluated, so this indicates a cycle. Stop */ + if (var->marked) { return 0; - } else if (identifier->var == EcsVarIsEntity) { - return identifier->entity; - } else if (identifier->var == EcsVarIsVariable) { - return EcsWildcard; + } + + /* Variable is not yet being evaluated and depth has not yet been set. + * Calculate depth. */ + int32_t depth = get_variable_depth(rule, var, root, recur + 1); + if (depth == UINT8_MAX) { + return depth; } else { - /* This should've been caught earlier */ - ecs_abort(ECS_INTERNAL_ERROR, NULL); + return depth + 1; } } static -int finalize_term_id( - const ecs_world_t *world, - ecs_term_t *term, - const char *name) +int32_t get_depth_from_term( + ecs_rule_t *rule, + ecs_rule_var_t *cur, + ecs_rule_var_t *pred, + ecs_rule_var_t *obj, + ecs_rule_var_t *root, + int recur) { - ecs_entity_t pred = entity_from_identifier(&term->pred); - ecs_entity_t obj = entity_from_identifier(&term->obj); - ecs_id_t role = term->role; - - if (ECS_HAS_ROLE(pred, PAIR)) { - if (obj) { - term_error(world, term, name, - "cannot set term.pred to a pair and term.obj at the same time"); - return -1; - } - - obj = ECS_PAIR_SECOND(pred); - pred = ECS_PAIR_FIRST(pred); + int32_t result = UINT8_MAX; - term->pred.entity = pred; - term->obj.entity = obj; + /* If neither of the other parts of the terms are variables, this + * variable is guaranteed to have no dependencies. */ + if (!pred && !obj) { + result = 0; + } else { + /* If this is a variable that is not the same as the current, + * we can use it to determine dependency depth. */ + if (pred && cur != pred) { + int32_t depth = get_depth_from_var(rule, pred, root, recur); + if (depth == UINT8_MAX) { + return UINT8_MAX; + } - if (finalize_term_identifier(world, term, &term->obj, name)) { - return -1; + /* If the found depth is lower than the depth found, overwrite it */ + if (depth < result) { + result = depth; + } } - } - if (!obj && role != ECS_PAIR) { - term->id = pred | role; - } else { - if (role) { - if (role && role != ECS_PAIR && role != ECS_CASE) { - term_error(world, term, name, "invalid role for pair"); - return -1; + /* Same for obj */ + if (obj && cur != obj) { + int32_t depth = get_depth_from_var(rule, obj, root, recur); + if (depth == UINT8_MAX) { + return UINT8_MAX; } - term->role = role; - } else { - term->role = ECS_PAIR; + if (depth < result) { + result = depth; + } } - - term->id = term->role | ecs_entity_t_comb(obj, pred); } - return 0; + return result; } +/* Find the depth of the dependency tree from the variable to the root */ static -int populate_from_term_id( - const ecs_world_t *world, - ecs_term_t *term, - const char *name) +int32_t get_variable_depth( + ecs_rule_t *rule, + ecs_rule_var_t *var, + ecs_rule_var_t *root, + int recur) { - ecs_entity_t pred = 0; - ecs_entity_t obj = 0; - ecs_id_t role = term->id & ECS_ROLE_MASK; + var->marked = true; - if (!role && term->role) { - role = term->role; - term->id |= role; - } + /* Iterate columns, find all instances where 'var' is not used as subject. + * If the subject of that column is either the root or a variable for which + * the depth is known, the depth for this variable can be determined. */ + ecs_term_t *terms = rule->filter.terms; - if (term->role && term->role != role) { - term_error(world, term, name, "mismatch between term.id & term.role"); - return -1; - } + int32_t i, count = rule->filter.term_count; + int32_t result = UINT8_MAX; - term->role = role; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + if (skip_term(term)) { + continue; + } - if (ECS_HAS_ROLE(term->id, PAIR) || ECS_HAS_ROLE(term->id, CASE)) { - pred = ECS_PAIR_FIRST(term->id); - obj = ECS_PAIR_SECOND(term->id); + ecs_rule_var_t + *pred = term_pred(rule, term), + *subj = term_subj(rule, term), + *obj = term_obj(rule, term); - if (!pred) { - term_error(world, term, name, "missing predicate in term.id pair"); - return -1; - } - if (!obj) { - if (pred != EcsChildOf) { - term_error(world, term, name, "missing object in term.id pair"); - return -1; - } + if (subj != var) { + continue; } - } else { - pred = term->id & ECS_COMPONENT_MASK; - if (!pred) { - term_error(world, term, name, "missing predicate in term.id"); - return -1; + + if (!is_subject(rule, pred)) { + pred = NULL; } - } - ecs_entity_t term_pred = entity_from_identifier(&term->pred); - if (term_pred) { - if (term_pred != pred) { - term_error(world, term, name, - "mismatch between term.id and term.pred"); - return -1; + if (!is_subject(rule, obj)) { + obj = NULL; } - } else { - term->pred.entity = pred; - if (finalize_term_identifier(world, term, &term->pred, name)) { - return -1; + + int32_t depth = get_depth_from_term(rule, var, pred, obj, root, recur); + if (depth < result) { + result = depth; } } - ecs_entity_t term_obj = entity_from_identifier(&term->obj); - if (term_obj) { - if (ecs_entity_t_lo(term_obj) != obj) { - term_error(world, term, name, - "mismatch between term.id and term.obj"); - return -1; + if (result == UINT8_MAX) { + result = 0; + } + + var->depth = result; + + /* Dependencies are calculated from subject to (pred, obj). If there were + * subjects that are only related by object (like (X, Y), (Z, Y)) it is + * possible that those have not yet been found yet. To make sure those + * variables are found, loop again & follow predicate & object links */ + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + if (skip_term(term)) { + continue; } - } else { - term->obj.entity = obj; - if (finalize_term_identifier(world, term, &term->obj, name)) { - return -1; + + ecs_rule_var_t + *subj = term_subj(rule, term), + *pred = term_pred(rule, term), + *obj = term_obj(rule, term); + + /* Only evaluate pred & obj for current subject. This ensures that we + * won't evaluate variables that are unreachable from the root. This + * must be detected as unconstrained variables are not allowed. */ + if (subj != var) { + continue; + } + + crawl_variable(rule, subj, root, recur); + + if (pred && pred != var) { + crawl_variable(rule, pred, root, recur); } + + if (obj && obj != var) { + crawl_variable(rule, obj, root, recur); + } } - return 0; + return var->depth; } +/* Compare function used for qsort. It ensures that variables are first ordered + * by depth, followed by how often they occur. */ static -int verify_term_consistency( - const ecs_world_t *world, - const ecs_term_t *term, - const char *name) +int compare_variable( + const void* ptr1, + const void *ptr2) { - ecs_entity_t pred = entity_from_identifier(&term->pred); - ecs_entity_t obj = entity_from_identifier(&term->obj); - ecs_id_t role = term->role; - ecs_id_t id = term->id; - bool wildcard = pred == EcsWildcard || obj == EcsWildcard; - - if (obj && (!role || (role != ECS_PAIR && role != ECS_CASE))) { - term_error(world, term, name, - "invalid role for term with pair (expected ECS_PAIR)"); - return -1; - } - - if (role == ECS_CASE && !obj) { - term_error(world, term, name, - "missing object for term with ECS_CASE role"); - return -1; - } + const ecs_rule_var_t *v1 = ptr1; + const ecs_rule_var_t *v2 = ptr2; - if (!pred) { - term_error(world, term, name, "missing predicate for term"); + if (v1->kind < v2->kind) { return -1; + } else if (v1->kind > v2->kind) { + return 1; } - if (role != (id & ECS_ROLE_MASK)) { - term_error(world, term, name, "mismatch between term.role & term.id"); + if (v1->depth < v2->depth) { return -1; + } else if (v1->depth > v2->depth) { + return 1; } - if (obj && !ECS_HAS_ROLE(id, PAIR) && !ECS_HAS_ROLE(id, CASE)) { - term_error(world, term, name, "term has object but id is not a pair"); + if (v1->occurs < v2->occurs) { + return 1; + } else { return -1; } - if (ECS_HAS_ROLE(id, PAIR) || ECS_HAS_ROLE(id, CASE)) { - if (!wildcard) { - role = ECS_ROLE_MASK & id; - if (id != (role | ecs_entity_t_comb( - term->obj.entity, term->pred.entity))) - { - char *id_str = ecs_id_str(world, ecs_pair(pred, obj)); - term_error(world, term, name, - "term id does not match pred/obj (%s)", id_str); - ecs_os_free(id_str); - return -1; - } - } - } else if (term->pred.entity != (id & ECS_COMPONENT_MASK)) { - if (!wildcard) { - char *pred_str = ecs_get_fullpath(world, term->pred.entity); - term_error(world, term, name, "term id does not match pred '%s'", - pred_str); - ecs_os_free(pred_str); - return -1; - } - } + return (v1->id < v2->id) - (v1->id > v2->id); +} - if (term->pred.var == EcsVarIsEntity) { - const ecs_term_id_t *tsubj = &term->subj; - const ecs_term_id_t *tobj = &term->obj; +/* After all subject variables have been found, inserted and sorted, the + * remaining variables (predicate & object) still need to be inserted. This + * function serves two purposes. The first purpose is to ensure that all + * variables are known before operations are emitted. This ensures that the + * variables array won't be reallocated while emitting, which simplifies code. + * The second purpose of the function is to ensure that if the root variable + * (which, if it exists has now been created with a table type) is also inserted + * with an entity type if required. This is used later to decide whether the + * rule needs to insert an each instruction. */ +static +void ensure_all_variables( + ecs_rule_t *rule) +{ + ecs_term_t *terms = rule->filter.terms; + int32_t i, count = rule->filter.term_count; - if (ecs_term_id_is_set(tsubj) && ecs_term_id_is_set(tobj)) { - if (tsubj->var == tobj->var) { - bool is_same = false; + for (i = 0; i < count; i ++) { + ecs_term_t *term = &terms[i]; + if (skip_term(term)) { + continue; + } - if (tsubj->var == EcsVarIsEntity) { - is_same = tsubj->entity == tobj->entity; - } else if (tsubj->name && tobj->name) { - is_same = !ecs_os_strcmp(tsubj->name, tobj->name); - } + /* If predicate is a variable, make sure it has been registered */ + if (term->pred.var == EcsVarIsVariable) { + ensure_term_id_variable(rule, &term->pred); + } - if (is_same && ecs_has_id(world, term->pred.entity, EcsAcyclic) - && !ecs_has_id(world, term->pred.entity, EcsReflexive)) - { - char *pred_str = ecs_get_fullpath(world, term->pred.entity); - term_error(world, term, name, "term with acyclic relation" - " '%s' cannot have same subject and object", - pred_str); - ecs_os_free(pred_str); - return -1; - } + /* If subject is a variable and it is not This, make sure it is + * registered as an entity variable. This ensures that the program will + * correctly return all permutations */ + if (term->subj.var == EcsVarIsVariable) { + if (term->subj.entity != EcsThis) { + ensure_term_id_variable(rule, &term->subj); } } - } - if (term->subj.set.relation && !term->subj.set.max_depth) { - if (!ecs_has_id(world, term->subj.set.relation, EcsAcyclic)) { - char *r_str = ecs_get_fullpath(world, term->subj.set.relation); - term_error(world, term, name, - "relation '%s' is used with SuperSet/SubSet but is not acyclic", - r_str); - ecs_os_free(r_str); - return -1; + /* If object is a variable, make sure it has been registered */ + if (obj_is_set(term) && (term->obj.var == EcsVarIsVariable)) { + ensure_term_id_variable(rule, &term->obj); } - } - - return 0; + } } -bool ecs_identifier_is_0( - const char *id) +/* Scan for variables, put them in optimal dependency order. */ +static +int scan_variables( + ecs_rule_t *rule) { - return id[0] == '0' && !id[1]; -} + /* Objects found in rule. One will be elected root */ + int32_t subject_count = 0; -const char* ecs_identifier_is_var( - const char *id) -{ - if (!id) { - return NULL; - } + /* If this (.) is found, it always takes precedence in root election */ + int32_t this_var = UINT8_MAX; - /* Variable identifiers cannot start with a number */ - if (isdigit(id[0])) { - return NULL; - } + /* Keep track of the subject variable that occurs the most. In the absence of + * this (.) the variable with the most occurrences will be elected root. */ + int32_t max_occur = 0; + int32_t max_occur_var = UINT8_MAX; - /* Identifiers that start with _ are variables */ - if (id[0] == '_' && id[1] != 0) { - return &id[1]; - } + /* Step 1: find all possible roots */ + ecs_term_t *terms = rule->filter.terms; + int32_t i, term_count = rule->filter.term_count; - return NULL; -} + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; -bool ecs_id_match( - ecs_id_t id, - ecs_id_t pattern) -{ - if (id == pattern) { - return true; - } + /* Evaluate the subject. The predicate and object are not evaluated, + * since they never can be elected as root. */ + if (term_id_is_variable(&term->subj)) { + const char *subj_name = term_id_var_name(&term->subj); + + ecs_rule_var_t *subj = find_variable( + rule, EcsRuleVarKindTable, subj_name); + if (!subj) { + subj = create_variable(rule, EcsRuleVarKindTable, subj_name); + if (subject_count >= ECS_RULE_MAX_VAR_COUNT) { + rule_error(rule, "too many variables in rule"); + goto error; + } - if (ECS_HAS_ROLE(pattern, PAIR)) { - if (!ECS_HAS_ROLE(id, PAIR)) { - return false; + /* Make sure that variable name in term array matches with the + * rule name. */ + ecs_os_strset(&term->subj.name, subj->name); + } + + if (++ subj->occurs > max_occur) { + max_occur = subj->occurs; + max_occur_var = subj->id; + } } + } - ecs_entity_t id_rel = ECS_PAIR_FIRST(id); - ecs_entity_t id_obj = ECS_PAIR_SECOND(id); - ecs_entity_t pattern_rel = ECS_PAIR_FIRST(pattern); - ecs_entity_t pattern_obj = ECS_PAIR_SECOND(pattern); + rule->subj_var_count = rule->var_count; - ecs_check(id_rel != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(id_obj != 0, ECS_INVALID_PARAMETER, NULL); + ensure_all_variables(rule); - ecs_check(pattern_rel != 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(pattern_obj != 0, ECS_INVALID_PARAMETER, NULL); - - if (pattern_rel == EcsWildcard) { - if (pattern_obj == EcsWildcard || pattern_obj == id_obj) { - return true; + /* Variables in a term with a literal subject have depth 0 */ + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; + + if (term->subj.var == EcsVarIsEntity) { + ecs_rule_var_t + *pred = term_pred(rule, term), + *obj = term_obj(rule, term); + + if (pred) { + pred->depth = 0; } - } else if (pattern_obj == EcsWildcard) { - if (pattern_rel == id_rel) { - return true; + if (obj) { + obj->depth = 0; } } - } else { - if ((id & ECS_ROLE_MASK) != (pattern & ECS_ROLE_MASK)) { - return false; - } + } - if ((ECS_COMPONENT_MASK & pattern) == EcsWildcard) { - return true; + /* Elect a root. This is either this (.) or the variable with the most + * occurrences. */ + int32_t root_var = this_var; + if (root_var == UINT8_MAX) { + root_var = max_occur_var; + if (root_var == UINT8_MAX) { + /* If no subject variables have been found, the rule expression only + * operates on a fixed set of entities, in which case no root + * election is required. */ + goto done; } } -error: - return false; -} - -bool ecs_id_is_pair( - ecs_id_t id) -{ - return ECS_HAS_ROLE(id, PAIR); -} + ecs_rule_var_t *root = &rule->vars[root_var]; + root->depth = get_variable_depth(rule, root, root, 0); -bool ecs_id_is_wildcard( - ecs_id_t id) -{ - return - (id == EcsWildcard) || (ECS_HAS_ROLE(id, PAIR) && ( - (ECS_PAIR_FIRST(id) == EcsWildcard) || - (ECS_PAIR_SECOND(id) == EcsWildcard) - )); -} + /* Verify that there are no unconstrained variables. Unconstrained variables + * are variables that are unreachable from the root. */ + for (i = 0; i < rule->subj_var_count; i ++) { + if (rule->vars[i].depth == UINT8_MAX) { + rule_error(rule, "unconstrained variable '%s'", + rule->vars[i].name); + goto error; + } + } -bool ecs_term_id_is_set( - const ecs_term_id_t *id) -{ - return id->entity != 0 || id->name != NULL; -} + /* For each Not term, verify that variables are known */ + for (i = 0; i < term_count; i ++) { + ecs_term_t *term = &terms[i]; + if (term->oper != EcsNot) { + continue; + } -bool ecs_term_is_initialized( - const ecs_term_t *term) -{ - return term->id != 0 || ecs_term_id_is_set(&term->pred); -} + ecs_rule_var_t + *pred = term_pred(rule, term), + *obj = term_obj(rule, term); -bool ecs_term_is_trivial( - const ecs_term_t *term) -{ - if (term->inout != EcsInOutDefault) { - return false; + if (!pred && term_id_is_variable(&term->pred)) { + rule_error(rule, "missing predicate variable '%s'", + term_id_var_name(&term->pred)); + goto error; + } + if (!obj && term_id_is_variable(&term->obj)) { + rule_error(rule, "missing object variable '%s'", + term_id_var_name(&term->obj)); + goto error; + } } - if (term->subj.entity != EcsThis) { - return false; - } + /* Order variables by depth, followed by occurrence. The variable + * array will later be used to lead the iteration over the terms, and + * determine which operations get inserted first. */ + int32_t var_count = rule->var_count; + ecs_qsort_t(rule->vars, var_count, ecs_rule_var_t, compare_variable); - if (term->subj.set.mask && (term->subj.set.mask != EcsSelf)) { - return false; + /* Iterate variables to correct ids after sort */ + for (i = 0; i < rule->var_count; i ++) { + rule->vars[i].id = i; } + +done: + return 0; +error: + return -1; +} - if (term->oper != EcsAnd && term->oper != EcsAndFrom) { - return false; +/* Get entity variable from table variable */ +static +ecs_rule_var_t* to_entity( + ecs_rule_t *rule, + ecs_rule_var_t *var) +{ + if (!var) { + return NULL; } - if (term->name != NULL) { - return false; + ecs_rule_var_t *evar = NULL; + if (var->kind == EcsRuleVarKindTable) { + evar = find_variable(rule, EcsRuleVarKindEntity, var->name); + } else { + evar = var; } - return true; + return evar; } -int ecs_term_finalize( - const ecs_world_t *world, - const char *name, - ecs_term_t *term) +/* Ensure that if a table variable has been written, the corresponding entity + * variable is populated. The function will return the most specific, populated + * variable. */ +static +ecs_rule_var_t* most_specific_var( + ecs_rule_t *rule, + ecs_rule_var_t *var, + bool *written, + bool create) { - if (finalize_term_vars(world, term, name)) { - return -1; - } - - if (!term->id) { - if (finalize_term_id(world, term, name)) { - return -1; - } - } else { - if (populate_from_term_id(world, term, name)) { - return -1; - } + if (!var) { + return NULL; } - if (finalize_term_identifiers(world, term, name)) { - return -1; + ecs_rule_var_t *tvar, *evar = to_entity(rule, var); + if (!evar) { + return var; } - if (!term_can_inherit(term)) { - if (term->subj.set.relation == EcsIsA) { - term->subj.set.relation = 0; - term->subj.set.mask = EcsSelf; - } + if (var->kind == EcsRuleVarKindTable) { + tvar = var; + } else { + tvar = find_variable(rule, EcsRuleVarKindTable, var->name); } - if (term->role == ECS_AND || term->role == ECS_OR || term->role == ECS_NOT){ - /* AND/OR terms match >1 component, which is only valid as filter */ - if (term->inout != EcsInOutDefault && term->inout != EcsInOutFilter) { - term_error(world, term, name, "AND/OR terms must be filters"); - return -1; - } + /* If variable is used as predicate or object, it should have been + * registered as an entity. */ + ecs_assert(evar != NULL, ECS_INTERNAL_ERROR, NULL); - term->inout = EcsInOutFilter; + /* Usually table variables are resolved before they are used as a predicate + * or object, but in the case of cyclic dependencies this is not guaranteed. + * Only insert an each instruction of the table variable has been written */ + if (tvar && written[tvar->id]) { + /* If the variable has been written as a table but not yet + * as an entity, insert an each operation that yields each + * entity in the table. */ + if (evar) { + if (written[evar->id]) { + return evar; + } else if (create) { + ecs_rule_op_t *op = create_operation(rule); + op->kind = EcsRuleEach; + op->on_pass = rule->operation_count; + op->on_fail = rule->operation_count - 2; + op->frame = rule->frame_count; + op->has_in = true; + op->has_out = true; + op->r_in = tvar->id; + op->r_out = evar->id; - /* Translate role to operator */ - if (term->role == ECS_AND) { - term->oper = EcsAndFrom; - } else - if (term->role == ECS_OR) { - term->oper = EcsOrFrom; - } else - if (term->role == ECS_NOT) { - term->oper = EcsNotFrom; - } + /* Entity will either be written or has been written */ + written[evar->id] = true; - /* Zero out role & strip from id */ - term->id &= ECS_COMPONENT_MASK; - term->role = 0; - } + push_frame(rule); - if (verify_term_consistency(world, term, name)) { - return -1; + return evar; + } else { + return tvar; + } + } + } else if (evar && written[evar->id]) { + return evar; } - return 0; + return var; } -ecs_term_t ecs_term_copy( - const ecs_term_t *src) +/* Get most specific known variable */ +static +ecs_rule_var_t *get_most_specific_var( + ecs_rule_t *rule, + ecs_rule_var_t *var, + bool *written) { - ecs_term_t dst = *src; - dst.name = ecs_os_strdup(src->name); - dst.pred.name = ecs_os_strdup(src->pred.name); - dst.subj.name = ecs_os_strdup(src->subj.name); - dst.obj.name = ecs_os_strdup(src->obj.name); - return dst; + return most_specific_var(rule, var, written, false); } -ecs_term_t ecs_term_move( - ecs_term_t *src) +/* Get or create most specific known variable. This will populate an entity + * variable if a table variable is known but the entity variable isn't. */ +static +ecs_rule_var_t *ensure_most_specific_var( + ecs_rule_t *rule, + ecs_rule_var_t *var, + bool *written) { - if (src->move) { - ecs_term_t dst = *src; - src->name = NULL; - src->pred.name = NULL; - src->subj.name = NULL; - src->obj.name = NULL; - dst.move = false; - return dst; - } else { - ecs_term_t dst = ecs_term_copy(src); - dst.move = false; - return dst; - } + return most_specific_var(rule, var, written, true); } -void ecs_term_fini( - ecs_term_t *term) + +/* Ensure that an entity variable is written before using it */ +static +ecs_rule_var_t* ensure_entity_written( + ecs_rule_t *rule, + ecs_rule_var_t *var, + bool *written) { - ecs_os_free(term->pred.name); - ecs_os_free(term->subj.name); - ecs_os_free(term->obj.name); - ecs_os_free(term->name); + if (!var) { + return NULL; + } - term->pred.name = NULL; - term->subj.name = NULL; - term->obj.name = NULL; - term->name = NULL; + /* Ensure we're working with the most specific version of subj we can get */ + ecs_rule_var_t *evar = ensure_most_specific_var(rule, var, written); + + /* The post condition of this function is that there is an entity variable, + * and that it is written. Make sure that the result is an entity */ + ecs_assert(evar != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(evar->kind == EcsRuleVarKindEntity, ECS_INTERNAL_ERROR, NULL); + + /* Make sure the variable has been written */ + ecs_assert(written[evar->id] == true, ECS_INTERNAL_ERROR, NULL); + + return evar; } -int ecs_filter_finalize( - const ecs_world_t *world, - ecs_filter_t *f) +static +ecs_rule_op_t* insert_operation( + ecs_rule_t *rule, + int32_t term_index, + bool *written) { - int32_t i, term_count = f->term_count, actual_count = 0; - ecs_term_t *terms = f->terms; - bool is_or = false, prev_or = false; - int32_t filter_terms = 0; - - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; + ecs_rule_pair_t pair = {0}; - if (ecs_term_finalize(world, f->name, term)) { - return -1; - } + /* Parse the term's type into a pair. A pair extracts the ids from + * the term, and replaces variables with wildcards which can then + * be matched against actual relationships. A pair retains the + * information about the variables, so that when a match happens, + * the pair can be used to reify the variable. */ + if (term_index != -1) { + ecs_term_t *term = &rule->filter.terms[term_index]; - is_or = term->oper == EcsOr; - actual_count += !(is_or && prev_or); - term->index = actual_count - 1; - prev_or = is_or; + pair = term_to_pair(rule, term); - if (term->subj.entity == EcsThis) { - f->match_this = true; - if (term->subj.set.mask != EcsSelf) { - f->match_only_this = false; - } - } else { - f->match_only_this = false; + /* If the pair contains entity variables that have not yet been written, + * insert each instructions in case their tables are known. Variables in + * a pair that are truly unknown will be populated by the operation, + * but an operation should never overwrite an entity variable if the + * corresponding table variable has already been resolved. */ + if (pair.reg_mask & RULE_PAIR_PREDICATE) { + ecs_rule_var_t *pred = &rule->vars[pair.pred.reg]; + pred = get_most_specific_var(rule, pred, written); + pair.pred.reg = pred->id; } - if (term->id == EcsPrefab) { - f->match_prefab = true; - } - if (term->id == EcsDisabled) { - f->match_disabled = true; + if (pair.reg_mask & RULE_PAIR_OBJECT) { + ecs_rule_var_t *obj = &rule->vars[pair.obj.reg]; + obj = get_most_specific_var(rule, obj, written); + pair.obj.reg = obj->id; } + } else { + /* Not all operations have a filter (like Each) */ + } - if (f->filter) { - term->inout = EcsInOutFilter; - } + ecs_rule_op_t *op = create_operation(rule); + op->on_pass = rule->operation_count; + op->on_fail = rule->operation_count - 2; + op->frame = rule->frame_count; + op->filter = pair; - if (term->inout == EcsInOutFilter) { - filter_terms ++; - } + /* Store corresponding signature term so we can correlate and + * store the table columns with signature columns. */ + op->term = term_index; - if (term->oper != EcsNot || term->subj.entity != EcsThis) { - f->match_anything = false; - } - } + return op; +} + +/* Insert first operation, which is always Input. This creates an entry in + * the register stack for the initial state. */ +static +void insert_input( + ecs_rule_t *rule) +{ + ecs_rule_op_t *op = create_operation(rule); + op->kind = EcsRuleInput; - f->term_count_actual = actual_count; + /* The first time Input is evaluated it goes to the next/first operation */ + op->on_pass = 1; - if (filter_terms == term_count) { - f->filter = true; - } + /* When Input is evaluated with redo = true it will return false, which will + * finish the program as op becomes -1. */ + op->on_fail = -1; - return 0; + push_frame(rule); } -/* Implementation for iterable mixin */ +/* Insert last operation, which is always Yield. When the program hits Yield, + * data is returned to the application. */ static -void filter_iter_init( - const ecs_world_t *world, - const ecs_poly_t *poly, - ecs_iter_t *iter, - ecs_term_t *filter) +void insert_yield( + ecs_rule_t *rule) { - ecs_poly_assert(poly, ecs_filter_t); + ecs_rule_op_t *op = create_operation(rule); + op->kind = EcsRuleYield; + op->has_in = true; + op->on_fail = rule->operation_count - 2; + /* Yield can only "fail" since it is the end of the program */ - if (filter) { - iter[1] = ecs_filter_iter(world, (ecs_filter_t*)poly); - iter[0] = ecs_term_chain_iter(&iter[1], filter); + /* Find variable associated with this. It is possible that the variable + * exists both as a table and as an entity. This can happen when a rule + * first selects a table for this, but then subsequently needs to evaluate + * each entity in that table. In that case the yield instruction should + * return the entity, so look for that first. */ + ecs_rule_var_t *var = find_variable(rule, EcsRuleVarKindEntity, "."); + if (!var) { + var = find_variable(rule, EcsRuleVarKindTable, "."); + } + + /* If there is no this, there is nothing to yield. In that case the rule + * simply returns true or false. */ + if (!var) { + op->r_in = UINT8_MAX; } else { - iter[0] = ecs_filter_iter(world, (ecs_filter_t*)poly); + op->r_in = var->id; } + + op->frame = push_frame(rule); } -int ecs_filter_init( - const ecs_world_t *stage, - ecs_filter_t *filter_out, - const ecs_filter_desc_t *desc) +/* Return superset/subset including the root */ +static +void insert_reflexive_set( + ecs_rule_t *rule, + ecs_rule_op_kind_t op_kind, + ecs_rule_var_t *out, + const ecs_rule_pair_t pair, + int32_t c, + bool *written, + bool reflexive) { - ecs_filter_t f; - ecs_poly_init(&f, ecs_filter_t); - - ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(filter_out != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); + ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); - const ecs_world_t *world = ecs_get_world(stage); + ecs_rule_var_t *pred = pair_pred(rule, &pair); + ecs_rule_var_t *obj = pair_obj(rule, &pair); - int i, term_count = 0; - ecs_term_t *terms = desc->terms_buffer; - const char *name = desc->name; - const char *expr = desc->expr; + int32_t setjmp_lbl = rule->operation_count; + int32_t store_lbl = setjmp_lbl + 1; + int32_t set_lbl = setjmp_lbl + 2; + int32_t next_op = setjmp_lbl + 4; + int32_t prev_op = setjmp_lbl - 1; - /* Temporarily set the fields to the values provided in desc, until the - * filter has been validated. */ - f.name = (char*)name; - f.expr = (char*)expr; - f.filter = desc->filter; - f.instanced = desc->instanced; - f.match_empty_tables = desc->match_empty_tables; - f.match_anything = true; + /* Insert 4 operations at once, so we don't have to worry about how + * the instruction array reallocs. If operation is not reflexive, we only + * need to insert the set operation. */ + if (reflexive) { + insert_operation(rule, -1, written); + insert_operation(rule, -1, written); + insert_operation(rule, -1, written); + } - if (terms) { - term_count = desc->terms_buffer_count; - } else { - terms = (ecs_term_t*)desc->terms; - for (i = 0; i < ECS_TERM_DESC_CACHE_SIZE; i ++) { - if (!ecs_term_is_initialized(&terms[i])) { - break; - } + ecs_rule_op_t *op = insert_operation(rule, -1, written); + ecs_rule_op_t *setjmp = &rule->operations[setjmp_lbl]; + ecs_rule_op_t *store = &rule->operations[store_lbl]; + ecs_rule_op_t *set = &rule->operations[set_lbl]; + ecs_rule_op_t *jump = op; - term_count ++; - } + if (!reflexive) { + set_lbl = setjmp_lbl; + set = op; + setjmp = NULL; + store = NULL; + jump = NULL; + next_op = set_lbl + 1; + prev_op = set_lbl - 1; } - /* Temporarily set array from desc to filter, until the filter has been - * validated. */ - f.terms = terms; - f.term_count = term_count; + /* The SetJmp operation stores a conditional jump label that either + * points to the Store or *Set operation */ + if (reflexive) { + setjmp->kind = EcsRuleSetJmp; + setjmp->on_pass = store_lbl; + setjmp->on_fail = set_lbl; + } - if (expr) { -#ifdef FLECS_PARSER - int32_t buffer_count = 0; + /* The Store operation yields the root of the subtree. After yielding, + * this operation will fail and return to SetJmp, which will cause it + * to switch to the *Set operation. */ + if (reflexive) { + store->kind = EcsRuleStore; + store->on_pass = next_op; + store->on_fail = setjmp_lbl; + store->has_in = true; + store->has_out = true; + store->r_out = out->id; + store->term = c; - /* If terms have already been set, copy buffer to allocated one */ - if (terms && term_count) { - terms = ecs_os_memdup(terms, term_count * ECS_SIZEOF(ecs_term_t)); - buffer_count = term_count; + if (!pred) { + store->filter.pred = pair.pred; } else { - terms = NULL; - } - - /* Parse expression into array of terms */ - const char *ptr = desc->expr; - ecs_term_t term = {0}; - while (ptr[0] && (ptr = ecs_parse_term(world, name, expr, ptr, &term))){ - if (!ecs_term_is_initialized(&term)) { - break; - } - - if (term_count == buffer_count) { - buffer_count = buffer_count ? buffer_count * 2 : 8; - terms = ecs_os_realloc(terms, - buffer_count * ECS_SIZEOF(ecs_term_t)); - } - - /* Check for identifiers that have a name that starts with _. If the - * variable kind is left to Default, the kind should be set to - * variable and the _ prefix should be removed. */ - finalize_term_vars(world, &term, name); - - terms[term_count] = term; - term_count ++; - - if (ptr[0] == '\n') { - break; - } + store->filter.pred.reg = pred->id; + store->filter.reg_mask |= RULE_PAIR_PREDICATE; } - f.terms = terms; - f.term_count = term_count; - - if (!ptr) { - goto error; + /* If the object of the filter is not a variable, store literal */ + if (!obj) { + store->r_in = UINT8_MAX; + store->subject = ecs_get_alive(rule->world, pair.obj.ent); + store->filter.obj = pair.obj; + } else { + store->r_in = obj->id; + store->filter.obj.reg = obj->id; + store->filter.reg_mask |= RULE_PAIR_OBJECT; } -#else - ecs_abort(ECS_UNSUPPORTED, "parser addon is not available"); -#endif } - /* Copy term resources. */ - if (term_count) { - ecs_term_t *dst_terms = terms; - if (!f.expr) { - if (term_count <= ECS_TERM_CACHE_SIZE) { - dst_terms = f.term_cache; - f.term_cache_used = true; - } else { - dst_terms = ecs_os_malloc_n(ecs_term_t, term_count); - } - } + /* This is either a SubSet or SuperSet operation */ + set->kind = op_kind; + set->on_pass = next_op; + set->on_fail = prev_op; + set->has_out = true; + set->r_out = out->id; + set->term = c; - for (i = 0; i < term_count; i ++) { - dst_terms[i] = ecs_term_move(&terms[i]); - } - f.terms = dst_terms; + /* Predicate can be a variable if it's non-final */ + if (!pred) { + set->filter.pred = pair.pred; } else { - f.terms = NULL; + set->filter.pred.reg = pred->id; + set->filter.reg_mask |= RULE_PAIR_PREDICATE; } - /* Ensure all fields are consistent and properly filled out */ - if (ecs_filter_finalize(world, &f)) { - goto error; + if (!obj) { + set->filter.obj = pair.obj; + } else { + set->filter.obj.reg = obj->id; + set->filter.reg_mask |= RULE_PAIR_OBJECT; } - *filter_out = f; - if (f.term_cache_used) { - filter_out->terms = filter_out->term_cache; + if (reflexive) { + /* The jump operation jumps to either the store or subset operation, + * depending on whether the store operation already yielded. The + * operation is inserted last, so that the on_fail label of the next + * operation will point to it */ + jump->kind = EcsRuleJump; + + /* The pass/fail labels of the Jump operation are not used, since it + * jumps to a variable location. Instead, the pass label is (ab)used to + * store the label of the SetJmp operation, so that the jump can access + * the label it needs to jump to from the setjmp op_ctx. */ + jump->on_pass = setjmp_lbl; + jump->on_fail = -1; } - filter_out->name = ecs_os_strdup(desc->name); - filter_out->expr = ecs_os_strdup(desc->expr); - - ecs_assert(!filter_out->term_cache_used || - filter_out->terms == filter_out->term_cache, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(filter_out->term_count == f.term_count, - ECS_INTERNAL_ERROR, NULL); - filter_out->iterable.init = filter_iter_init; + written[out->id] = true; +} - return 0; -error: - /* NULL members that point to non-owned resources */ - if (!f.expr) { - f.terms = NULL; +static +ecs_rule_var_t* store_reflexive_set( + ecs_rule_t *rule, + ecs_rule_op_kind_t op_kind, + ecs_rule_pair_t *pair, + bool *written, + bool reflexive, + bool as_entity) +{ + /* Ensure we're using the most specific version of obj */ + ecs_rule_var_t *obj = pair_obj(rule, pair); + if (obj) { + pair->obj.reg = obj->id; } - f.name = NULL; - f.expr = NULL; - - ecs_filter_fini(&f); - - return -1; -} + /* The subset operation returns tables */ + ecs_rule_var_kind_t var_kind = EcsRuleVarKindTable; + if (op_kind == EcsSuperSet) { + var_kind = EcsRuleVarKindEntity; + } -void ecs_filter_copy( - ecs_filter_t *dst, - const ecs_filter_t *src) -{ - if (src) { - *dst = *src; + /* Create anonymous variable for storing the set */ + ecs_rule_var_t *av = create_anonymous_variable(rule, var_kind); + int32_t ave_id = 0, av_id = av->id; - int32_t term_count = src->term_count; + /* If the variable kind is a table, also create an entity variable as the + * result of the set operation should be returned as an entity */ + if (var_kind == EcsRuleVarKindTable && as_entity) { + create_variable(rule, EcsRuleVarKindEntity, av->name); + av = &rule->vars[av_id]; + ave_id = av_id + 1; + } - if (src->term_cache_used) { - dst->terms = dst->term_cache; - } else { - dst->terms = ecs_os_memdup_n(src->terms, ecs_term_t, term_count); - } + /* Generate the operations */ + insert_reflexive_set(rule, op_kind, av, *pair, -1, written, reflexive); - int i; - for (i = 0; i < term_count; i ++) { - dst->terms[i] = ecs_term_copy(&src->terms[i]); - } + /* Make sure to return entity variable, and that it is populated */ + if (as_entity) { + return ensure_entity_written(rule, &rule->vars[ave_id], written); } else { - ecs_os_memset_t(dst, 0, ecs_filter_t); + return &rule->vars[av_id]; } } -void ecs_filter_move( - ecs_filter_t *dst, - ecs_filter_t *src) +static +bool is_known( + ecs_rule_var_t *var, + bool *written) { - if (src) { - *dst = *src; - - if (src->term_cache_used) { - dst->terms = dst->term_cache; - } - - if (dst != src) { - src->terms = NULL; - src->term_count = 0; - } + if (!var) { + return true; } else { - ecs_os_memset_t(dst, 0, ecs_filter_t); + return written[var->id]; } } -void ecs_filter_fini( - ecs_filter_t *filter) +static +bool is_pair_known( + ecs_rule_t *rule, + ecs_rule_pair_t *pair, + bool *written) { - if (filter->terms) { - int i, count = filter->term_count; - for (i = 0; i < count; i ++) { - ecs_term_fini(&filter->terms[i]); - } - - if (!filter->term_cache_used) { - ecs_os_free(filter->terms); - } + ecs_rule_var_t *pred_var = pair_pred(rule, pair); + if (!is_known(pred_var, written) || pair->pred.ent == EcsWildcard) { + return false; } - ecs_os_free(filter->name); - ecs_os_free(filter->expr); + ecs_rule_var_t *obj_var = pair_obj(rule, pair); + if (!is_known(obj_var, written) || pair->obj.ent == EcsWildcard) { + return false; + } - filter->terms = NULL; - filter->name = NULL; - filter->expr = NULL; + return true; } static -void filter_str_add_id( - const ecs_world_t *world, - ecs_strbuf_t *buf, - const ecs_term_id_t *id, - bool is_subject, - uint8_t default_set_mask) +void set_input_to_subj( + ecs_rule_t *rule, + ecs_rule_op_t *op, + ecs_term_t *term, + ecs_rule_var_t *var) { - if (id->name) { - ecs_strbuf_appendstr(buf, id->name); - } else if (id->entity) { - bool id_added = false; - if (!is_subject || id->entity != EcsThis) { - char *path = ecs_get_fullpath(world, id->entity); - ecs_strbuf_appendstr(buf, path); - ecs_os_free(path); - id_added = true; - } - - if (id->set.mask != default_set_mask) { - if (id_added) { - ecs_strbuf_list_push(buf, ":", "|"); - } else { - ecs_strbuf_list_push(buf, "", "|"); - } - if (id->set.mask & EcsSelf) { - ecs_strbuf_list_appendstr(buf, "self"); - } - if (id->set.mask & EcsSuperSet) { - ecs_strbuf_list_appendstr(buf, "superset"); - } - if (id->set.mask & EcsSubSet) { - ecs_strbuf_list_appendstr(buf, "subset"); - } - - if (id->set.relation != EcsIsA) { - ecs_strbuf_list_push(buf, "(", ""); - - char *rel_path = ecs_get_fullpath(world, id->set.relation); - ecs_strbuf_appendstr(buf, rel_path); - ecs_os_free(rel_path); - - ecs_strbuf_list_pop(buf, ")"); - } + (void)rule; + + op->has_in = true; + if (!var) { + op->r_in = UINT8_MAX; + op->subject = term->subj.entity; - ecs_strbuf_list_pop(buf, ""); - } + /* Invalid entities should have been caught during parsing */ + ecs_assert(ecs_is_valid(rule->world, op->subject), + ECS_INTERNAL_ERROR, NULL); } else { - ecs_strbuf_appendstr(buf, "0"); + op->r_in = var->id; } } static -void term_str_w_strbuf( - const ecs_world_t *world, - const ecs_term_t *term, - ecs_strbuf_t *buf) +void set_output_to_subj( + ecs_rule_t *rule, + ecs_rule_op_t *op, + ecs_term_t *term, + ecs_rule_var_t *var) { - const ecs_term_id_t *subj = &term->subj; - const ecs_term_id_t *obj = &term->obj; - - const uint8_t def_pred_mask = EcsSelf|EcsSubSet; - const uint8_t def_subj_mask = EcsSelf|EcsSuperSet; - const uint8_t def_obj_mask = EcsSelf; - - bool pred_set = ecs_term_id_is_set(&term->pred); - bool subj_set = ecs_term_id_is_set(subj); - bool obj_set = ecs_term_id_is_set(obj); + (void)rule; - if (term->role && term->role != ECS_PAIR) { - ecs_strbuf_appendstr(buf, ecs_role_str(term->role)); - ecs_strbuf_appendstr(buf, " "); - } + op->has_out = true; + if (!var) { + op->r_out = UINT8_MAX; + op->subject = term->subj.entity; - if (term->oper == EcsNot) { - ecs_strbuf_appendstr(buf, "!"); - } else if (term->oper == EcsOptional) { - ecs_strbuf_appendstr(buf, "?"); + /* Invalid entities should have been caught during parsing */ + ecs_assert(ecs_is_valid(rule->world, op->subject), + ECS_INTERNAL_ERROR, NULL); + } else { + op->r_out = var->id; } +} - if (!subj_set) { - filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); - ecs_strbuf_appendstr(buf, "()"); - } else if (subj_set && subj->entity == EcsThis && subj->set.mask == def_subj_mask) - { - if (term->id) { - char *str = ecs_id_str(world, term->id); - ecs_strbuf_appendstr(buf, str); - ecs_os_free(str); - } else if (pred_set) { - filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); - } - } else { - filter_str_add_id(world, buf, &term->pred, false, def_pred_mask); - ecs_strbuf_appendstr(buf, "("); - filter_str_add_id(world, buf, &term->subj, true, def_subj_mask); - if (obj_set) { - ecs_strbuf_appendstr(buf, ","); - filter_str_add_id(world, buf, &term->obj, false, def_obj_mask); +static +void insert_select_or_with( + ecs_rule_t *rule, + int32_t c, + ecs_term_t *term, + ecs_rule_var_t *subj, + ecs_rule_pair_t *pair, + bool *written) +{ + ecs_rule_op_t *op; + bool eval_subject_supersets = false; + + /* Find any entity and/or table variables for subject */ + ecs_rule_var_t *tvar = NULL, *evar = to_entity(rule, subj), *var = evar; + if (subj && subj->kind == EcsRuleVarKindTable) { + tvar = subj; + if (!evar) { + var = tvar; } - ecs_strbuf_appendstr(buf, ")"); } -} -char* ecs_term_str( - const ecs_world_t *world, - const ecs_term_t *term) -{ - ecs_strbuf_t buf = ECS_STRBUF_INIT; - term_str_w_strbuf(world, term, &buf); - return ecs_strbuf_get(&buf); -} + int32_t lbl_start = rule->operation_count; + ecs_rule_pair_t filter; + if (pair) { + filter = *pair; + } else { + filter = term_to_pair(rule, term); + } -char* ecs_filter_str( - const ecs_world_t *world, - const ecs_filter_t *filter) -{ - ecs_strbuf_t buf = ECS_STRBUF_INIT; + /* Only insert implicit IsA if filter isn't already an IsA */ + if (!filter.transitive || filter.pred.ent != EcsIsA) { + if (!var) { + ecs_rule_pair_t isa_pair = { + .pred.ent = EcsIsA, + .obj.ent = term->subj.entity + }; - ecs_check(!filter->term_cache_used || filter->terms == filter->term_cache, - ECS_INVALID_PARAMETER, NULL); + evar = subj = store_reflexive_set(rule, EcsRuleSuperSet, &isa_pair, + written, true, true); + tvar = NULL; + eval_subject_supersets = true; - ecs_term_t *terms = filter->terms; - int32_t i, count = filter->term_count; - int32_t or_count = 0; + } else if (ecs_id_is_wildcard(term->id)) { + ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; + op = insert_operation(rule, -1, written); - if (i) { - if (terms[i - 1].oper == EcsOr && term->oper == EcsOr) { - ecs_strbuf_appendstr(&buf, " || "); + if (!is_known(subj, written)) { + op->kind = EcsRuleSelect; + set_output_to_subj(rule, op, term, subj); + written[subj->id] = true; } else { - ecs_strbuf_appendstr(&buf, ", "); + op->kind = EcsRuleWith; + set_input_to_subj(rule, op, term, subj); } - } - if (term->oper != EcsOr) { - or_count = 0; - } + ecs_rule_pair_t isa_pair = { + .pred.ent = EcsIsA, + .obj.reg = subj->id, + .reg_mask = RULE_PAIR_OBJECT + }; - if (or_count < 1) { - if (term->inout == EcsIn) { - ecs_strbuf_appendstr(&buf, "[in] "); - } else if (term->inout == EcsInOut) { - ecs_strbuf_appendstr(&buf, "[inout] "); - } else if (term->inout == EcsOut) { - ecs_strbuf_appendstr(&buf, "[out] "); - } else if (term->inout == EcsInOutFilter) { - ecs_strbuf_appendstr(&buf, "[filter] "); + op->filter = filter; + if (op->filter.reg_mask & RULE_PAIR_PREDICATE) { + op->filter.pred.ent = EcsWildcard; } - } + if (op->filter.reg_mask & RULE_PAIR_OBJECT) { + op->filter.obj.ent = EcsWildcard; + } + op->filter.reg_mask = 0; - if (term->oper == EcsOr) { - or_count ++; - } + push_frame(rule); - term_str_w_strbuf(world, term, &buf); + tvar = subj = store_reflexive_set(rule, EcsRuleSuperSet, &isa_pair, + written, true, false); + + evar = NULL; + } } - return ecs_strbuf_get(&buf); -error: - return NULL; -} + /* If no pair is provided, create operation from specified term */ + if (!pair) { + op = insert_operation(rule, c, written); -static -ecs_id_t actual_match_id( - ecs_id_t id) -{ - /* Table types don't store CASE, so replace it with corresponding SWITCH */ - if (ECS_HAS_ROLE(id, CASE)) { - return ECS_SWITCH | ECS_PAIR_FIRST(id); + /* If an explicit pair is provided, override the default one from the + * term. This allows for using a predicate or object variable different + * from what is in the term. One application of this is to substitute a + * predicate with its subsets, if it is non final */ + } else { + op = insert_operation(rule, -1, written); + op->filter = *pair; + + /* Assign the term id, so that the operation will still be correctly + * associated with the correct expression term. */ + op->term = c; } - return id; -} + /* If entity variable is known and resolved, create with for it */ + if (evar && is_known(evar, written)) { + op->kind = EcsRuleWith; + op->r_in = evar->id; + set_input_to_subj(rule, op, term, subj); -static -bool flecs_n_term_match_table( - ecs_world_t *world, - const ecs_term_t *term, - const ecs_table_t *table, - ecs_type_t type, - ecs_id_t *id_out, - int32_t *column_out, - ecs_entity_t *subject_out, - int32_t *match_index_out, - bool first) -{ - (void)column_out; - - ecs_entity_t type_id = term->id; - ecs_oper_kind_t oper = term->oper; + /* If table variable is known and resolved, create with for it */ + } else if (tvar && is_known(tvar, written)) { + op->kind = EcsRuleWith; + op->r_in = tvar->id; + set_input_to_subj(rule, op, term, subj); - const EcsType *term_type = ecs_get(world, type_id, EcsType); - ecs_check(term_type != NULL, ECS_INVALID_PARAMETER, NULL); + /* If subject is neither table nor entitiy, with operates on literal */ + } else if (!tvar && !evar) { + op->kind = EcsRuleWith; + set_input_to_subj(rule, op, term, subj); - ecs_id_t *ids = ecs_vector_first(term_type->normalized->type, ecs_id_t); - int32_t i, count = ecs_vector_count(term_type->normalized->type); - ecs_term_t temp = *term; - temp.oper = EcsAnd; + /* If subject is table or entity but not known, use select */ + } else { + ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); + op->kind = EcsRuleSelect; + set_output_to_subj(rule, op, term, subj); + written[subj->id] = true; + } - for (i = 0; i < count; i ++) { - temp.id = ids[i]; - bool result = flecs_term_match_table(world, &temp, table, type, id_out, - 0, subject_out, match_index_out, first); - if (!result && oper == EcsAndFrom) { - return false; - } else - if (result && oper == EcsOrFrom) { - return true; - } + /* If supersets of subject are being evaluated, and we're looking for a + * specific filter, stop as soon as the filter has been matched. */ + if (eval_subject_supersets && is_pair_known(rule, &op->filter, written)) { + op = insert_operation(rule, -1, written); + + /* When the next operation returns, it will first hit SetJmp with a redo + * which will switch the jump label to the previous operation */ + op->kind = EcsRuleSetJmp; + op->on_pass = rule->operation_count; + op->on_fail = lbl_start - 1; } - if (oper == EcsAndFrom) { - return true; - } else - if (oper == EcsOrFrom) { - return false; + if (op->filter.reg_mask & RULE_PAIR_PREDICATE) { + written[op->filter.pred.reg] = true; } -error: - return false; + if (op->filter.reg_mask & RULE_PAIR_OBJECT) { + written[op->filter.obj.reg] = true; + } } -bool flecs_term_match_table( - ecs_world_t *world, - const ecs_term_t *term, - const ecs_table_t *table, - ecs_type_t type, - ecs_id_t *id_out, - int32_t *column_out, - ecs_entity_t *subject_out, - int32_t *match_index_out, - bool first) +static +void prepare_predicate( + ecs_rule_t *rule, + ecs_rule_pair_t *pair, + int32_t term, + bool *written) { - const ecs_term_id_t *subj = &term->subj; - ecs_oper_kind_t oper = term->oper; - const ecs_table_t *match_table = table; - ecs_type_t match_type = type; - ecs_id_t id = term->id; + /* If pair is not final, resolve term for all IsA relationships of the + * predicate. Note that if the pair has final set to true, it is guaranteed + * that the predicate can be used in an IsA query */ + if (!pair->final) { + ecs_rule_pair_t isa_pair = { + .pred.ent = EcsIsA, + .obj.ent = pair->pred.ent + }; - ecs_entity_t subj_entity = subj->entity; - if (!subj_entity) { - id_out[0] = id; /* no source corresponds with Nothing set mask */ - return true; + ecs_rule_var_t *pred = store_reflexive_set(rule, EcsRuleSubSet, + &isa_pair, written, true, true); + + pair->pred.reg = pred->id; + pair->reg_mask |= RULE_PAIR_PREDICATE; + + if (term != -1) { + rule->term_vars[term].pred = pred->id; + } } +} - if (oper == EcsAndFrom || oper == EcsOrFrom) { - return flecs_n_term_match_table(world, term, table, type, id_out, column_out, - subject_out, match_index_out, first); +static +void insert_term_2( + ecs_rule_t *rule, + ecs_term_t *term, + ecs_rule_pair_t *filter, + int32_t c, + bool *written) +{ + int32_t subj_id = -1, obj_id = -1; + ecs_rule_var_t *subj = term_subj(rule, term); + if ((subj = get_most_specific_var(rule, subj, written))) { + subj_id = subj->id; } - /* If source is not This, search in table of source */ - if (subj_entity != EcsThis) { - match_table = ecs_get_table(world, subj_entity); - if (match_table) { - match_type = match_table->type; - } else { - return false; - } - } else { - /* If filter contains This terms, a table must be provided */ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_rule_var_t *obj = term_obj(rule, term); + if ((obj = get_most_specific_var(rule, obj, written))) { + obj_id = obj->id; } - if (!match_type) { - return false; + bool subj_known = is_known(subj, written); + bool same_obj_subj = false; + if (subj && obj) { + same_obj_subj = !ecs_os_strcmp(subj->name, obj->name); } - ecs_entity_t source = 0; + if (!filter->transitive) { + insert_select_or_with(rule, c, term, subj, filter, written); + if (subj) subj = &rule->vars[subj_id]; + if (obj) obj = &rule->vars[obj_id]; - /* If first = false, we're searching from an offset. This supports returning - * multiple results when using wildcard filters. */ - int32_t column = 0; - if (!first && column_out && column_out[0] != 0) { - column = column_out[0]; - if (column < 0) { - /* In case column is not from This, flip sign */ - column = -column; - } + } else if (filter->transitive) { + if (subj_known) { + if (is_known(obj, written)) { + if (filter->obj.ent != EcsWildcard) { + ecs_rule_var_t *obj_subsets = store_reflexive_set( + rule, EcsRuleSubSet, filter, written, true, true); - /* Remove base 1 offset */ - column --; - } + if (subj) { + subj = &rule->vars[subj_id]; + } - /* Find location, source and id of match in table type */ - ecs_table_record_t *tr = 0; - column = ecs_search_relation(world, match_table, - column, actual_match_id(id), subj->set.relation, subj->set.min_depth, - subj->set.max_depth, &source, id_out, &tr); + rule->term_vars[c].obj = obj_subsets->id; - if (tr && match_index_out) { - match_index_out[0] = tr->count; - } + ecs_rule_pair_t pair = *filter; + pair.obj.reg = obj_subsets->id; + pair.reg_mask |= RULE_PAIR_OBJECT; - bool result = column != -1; + insert_select_or_with(rule, c, term, subj, &pair, written); + } else { + insert_select_or_with(rule, c, term, subj, filter, written); + } + } else { + ecs_assert(obj != NULL, ECS_INTERNAL_ERROR, NULL); - if (oper == EcsNot) { - if (match_index_out) { - match_index_out[0] = 1; - } - result = !result; - } + /* If subject is literal, find supersets for subject */ + if (subj == NULL || subj->kind == EcsRuleVarKindEntity) { + obj = to_entity(rule, obj); - if (oper == EcsOptional) { - result = true; - } + ecs_rule_pair_t set_pair = *filter; + set_pair.reg_mask &= RULE_PAIR_PREDICATE; - if (!result) { - return false; - } + if (subj) { + set_pair.obj.reg = subj->id; + set_pair.reg_mask |= RULE_PAIR_OBJECT; + } else { + set_pair.obj.ent = term->subj.entity; + } - if (subj_entity != EcsThis) { - if (!source) { - source = subj_entity; - } - } + insert_reflexive_set(rule, EcsRuleSuperSet, obj, set_pair, + c, written, filter->reflexive); - if (id_out && column < 0) { - id_out[0] = id; - } + /* If subject is variable, first find matching pair for the + * evaluated entity(s) and return supersets */ + } else { + ecs_rule_var_t *av = create_anonymous_variable( + rule, EcsRuleVarKindEntity); - if (column_out) { - if (column >= 0) { - column ++; - if (source != 0) { - column *= -1; + subj = &rule->vars[subj_id]; + obj = &rule->vars[obj_id]; + obj = to_entity(rule, obj); + + ecs_rule_pair_t set_pair = *filter; + set_pair.obj.reg = av->id; + set_pair.reg_mask |= RULE_PAIR_OBJECT; + + /* Insert with to find initial object for relation */ + insert_select_or_with( + rule, c, term, subj, &set_pair, written); + + push_frame(rule); + + /* Find supersets for returned initial object. Make sure + * this is always reflexive since it needs to return the + * object from the pair that the entity has itself. */ + insert_reflexive_set(rule, EcsRuleSuperSet, obj, set_pair, + c, written, true); + } } - column_out[0] = column; + + /* subj is not known */ } else { - column_out[0] = 0; - } - } + ecs_assert(subj != NULL, ECS_INTERNAL_ERROR, NULL); - if (subject_out) { - subject_out[0] = source; - } + if (is_known(obj, written)) { + ecs_rule_pair_t set_pair = *filter; + set_pair.reg_mask &= RULE_PAIR_PREDICATE; /* clear object mask */ - return result; -} + if (obj) { + set_pair.obj.reg = obj->id; + set_pair.reg_mask |= RULE_PAIR_OBJECT; + } else { + set_pair.obj.ent = term->obj.entity; + } -bool flecs_filter_match_table( - ecs_world_t *world, - const ecs_filter_t *filter, - const ecs_table_t *table, - ecs_id_t *ids, - int32_t *columns, - ecs_entity_t *subjects, - int32_t *match_indices, - int32_t *matches_left, - bool first, - int32_t skip_term) -{ - ecs_assert(!filter->term_cache_used || filter->terms == filter->term_cache, - ECS_INTERNAL_ERROR, NULL); + if (obj) { + rule->term_vars[c].obj = obj->id; + } else { + ecs_rule_var_t *av = create_anonymous_variable(rule, + EcsRuleVarKindEntity); + rule->term_vars[c].obj = av->id; + written[av->id] = true; + } - ecs_type_t type = NULL; - if (table) { - type = table->type; - } + insert_reflexive_set(rule, EcsRuleSubSet, subj, set_pair, c, + written, filter->reflexive); + } else if (subj == obj) { + insert_select_or_with(rule, c, term, subj, filter, written); + } else { + ecs_assert(obj != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_term_t *terms = filter->terms; - int32_t i, count = filter->term_count; + ecs_rule_var_t *av = NULL; + if (!filter->reflexive) { + av = create_anonymous_variable(rule, EcsRuleVarKindEntity); + } - bool is_or = false; - bool or_result = false; - int32_t match_count = 1; - if (matches_left) { - match_count = *matches_left; - } + subj = &rule->vars[subj_id]; + obj = &rule->vars[obj_id]; + obj = to_entity(rule, obj); - for (i = 0; i < count; i ++) { - if (i == skip_term) { - continue; - } + /* Insert instruction to find all subjects and objects */ + ecs_rule_op_t *op = insert_operation(rule, -1, written); + op->kind = EcsRuleSelect; + set_output_to_subj(rule, op, term, subj); + op->filter.pred = filter->pred; - ecs_term_t *term = &terms[i]; - ecs_term_id_t *subj = &term->subj; - ecs_oper_kind_t oper = term->oper; - const ecs_table_t *match_table = table; - ecs_type_t match_type = type; - int32_t t_i = term->index; + if (filter->reflexive) { + op->filter.obj.ent = EcsWildcard; + op->filter.reg_mask = filter->reg_mask & RULE_PAIR_PREDICATE; + } else { + op->filter.obj.reg = av->id; + op->filter.reg_mask = filter->reg_mask | RULE_PAIR_OBJECT; + written[av->id] = true; + } - if (!is_or && oper == EcsOr) { - is_or = true; - or_result = false; - } else if (is_or && oper != EcsOr) { - if (!or_result) { - return false; - } + written[subj->id] = true; - is_or = false; - } + /* Create new frame for operations that create reflexive set */ + push_frame(rule); - ecs_entity_t subj_entity = subj->entity; - if (!subj_entity) { - if (ids) { - ids[t_i] = term->id; - } - continue; - } + /* Insert superset instruction to find all supersets */ + if (filter->reflexive) { + subj = ensure_most_specific_var(rule, subj, written); + ecs_assert(subj->kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(written[subj->id] == true, + ECS_INTERNAL_ERROR, NULL); - if (subj_entity != EcsThis) { - match_table = ecs_get_table(world, subj_entity); - if (match_table) { - match_type = match_table->type; - } else { - match_type = NULL; + ecs_rule_pair_t super_filter = {0}; + super_filter.pred = filter->pred; + super_filter.obj.reg = subj->id; + super_filter.reg_mask = filter->reg_mask | RULE_PAIR_OBJECT; + + insert_reflexive_set(rule, EcsRuleSuperSet, obj, + super_filter, c, written, true); + } else { + insert_reflexive_set(rule, EcsRuleSuperSet, obj, + op->filter, c, written, true); + } } - } else { - /* If filter contains This terms, table must be provided */ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); } + } - int32_t match_index = 0; + if (same_obj_subj) { + /* Can't have relation with same variables that is acyclic and not + * reflexive, this should've been caught earlier. */ + ecs_assert(!filter->acyclic || filter->reflexive, + ECS_INTERNAL_ERROR, NULL); - bool result = flecs_term_match_table(world, term, match_table, - match_type, - ids ? &ids[t_i] : NULL, - columns ? &columns[t_i] : NULL, - subjects ? &subjects[t_i] : NULL, - &match_index, - first); + /* If relation is reflexive and entity has an instance of R, no checks + * are needed because R(X, X) is always true. */ + if (!filter->reflexive) { + push_frame(rule); - if (is_or) { - or_result |= result; - } else if (!result) { - return false; - } + /* Insert check if the (R, X) pair that was found matches with one + * of the entities in the table with the pair. */ + ecs_rule_op_t *op = insert_operation(rule, -1, written); + obj = get_most_specific_var(rule, obj, written); + ecs_assert(obj->kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(written[subj->id] == true, ECS_INTERNAL_ERROR, NULL); + ecs_assert(written[obj->id] == true, ECS_INTERNAL_ERROR, NULL); + + set_input_to_subj(rule, op, term, subj); + op->filter.obj.reg = obj->id; + op->filter.reg_mask = RULE_PAIR_OBJECT; - if (first && match_index) { - match_count *= match_index; - } - if (match_indices) { - match_indices[t_i] = match_index; + if (subj->kind == EcsRuleVarKindTable) { + op->kind = EcsRuleInTable; + } else { + op->kind = EcsRuleEq; + } } } - - if (matches_left) { - *matches_left = match_count; - } - - return !is_or || or_result; -} - -static -void term_iter_init_no_data( - ecs_term_iter_t *iter) -{ - iter->term = (ecs_term_t){ .index = -1 }; - iter->self_index = NULL; - iter->index = 0; } static -void term_iter_init_wildcard( - const ecs_world_t *world, - ecs_term_iter_t *iter) +void insert_term_1( + ecs_rule_t *rule, + ecs_term_t *term, + ecs_rule_pair_t *filter, + int32_t c, + bool *written) { - iter->term = (ecs_term_t){ .index = -1 }; - iter->self_index = flecs_get_id_record(world, EcsAny); - iter->cur = iter->self_index; - flecs_table_cache_iter(&iter->self_index->cache, &iter->it); - iter->index = 0; + ecs_rule_var_t *subj = term_subj(rule, term); + subj = get_most_specific_var(rule, subj, written); + insert_select_or_with(rule, c, term, subj, filter, written); } static -void term_iter_init( - const ecs_world_t *world, +void insert_term( + ecs_rule_t *rule, ecs_term_t *term, - ecs_term_iter_t *iter, - bool empty_tables) -{ - const ecs_term_id_t *subj = &term->subj; - - iter->term = *term; + int32_t c, + bool *written) +{ + bool obj_set = obj_is_set(term); - if (subj->set.mask == EcsDefaultSet || subj->set.mask & EcsSelf) { - iter->self_index = flecs_get_id_record(world, - actual_match_id(term->id)); + ensure_most_specific_var(rule, term_pred(rule, term), written); + if (obj_set) { + ensure_most_specific_var(rule, term_obj(rule, term), written); } - if (subj->set.mask & EcsSuperSet) { - iter->set_index = flecs_get_id_record(world, - ecs_pair(subj->set.relation, EcsWildcard)); + /* If term has Not operator, prepend Not which turns a fail into a pass */ + int32_t prev = rule->operation_count; + ecs_rule_op_t *not_pre; + if (term->oper == EcsNot) { + not_pre = insert_operation(rule, -1, written); + not_pre->kind = EcsRuleNot; + not_pre->has_in = false; + not_pre->has_out = false; } - iter->index = 0; + ecs_rule_pair_t filter = term_to_pair(rule, term); + prepare_predicate(rule, &filter, c, written); - ecs_id_record_t *idr; - if (iter->self_index) { - idr = iter->cur = iter->self_index; - } else { - idr = iter->cur = iter->set_index; + if (subj_is_set(term) && !obj_set) { + insert_term_1(rule, term, &filter, c, written); + } else if (obj_set) { + insert_term_2(rule, term, &filter, c, written); } - if (idr) { - if (empty_tables) { - if ((empty_tables = flecs_table_cache_empty_iter( - &idr->cache, &iter->it))) - { - iter->empty_tables = true; - } - } + /* If term has Not operator, append Not which turns a pass into a fail */ + if (term->oper == EcsNot) { + ecs_rule_op_t *not_post = insert_operation(rule, -1, written); + not_post->kind = EcsRuleNot; + not_post->has_in = false; + not_post->has_out = false; - if (!empty_tables) { - flecs_table_cache_iter(&idr->cache, &iter->it); - } - } else { - term_iter_init_no_data(iter); + not_post->on_pass = prev - 1; + not_post->on_fail = prev - 1; + not_pre = &rule->operations[prev]; + not_pre->on_fail = rule->operation_count; } -} - -ecs_iter_t ecs_term_iter( - const ecs_world_t *stage, - ecs_term_t *term) -{ - ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(term->id != 0, ECS_INVALID_PARAMETER, NULL); - const ecs_world_t *world = ecs_get_world(stage); + if (term->oper == EcsOptional) { + /* Insert Not instruction that ensures that the optional term is only + * executed once */ + ecs_rule_op_t *jump = insert_operation(rule, -1, written); + jump->kind = EcsRuleNot; + jump->has_in = false; + jump->has_out = false; + jump->on_pass = rule->operation_count; + jump->on_fail = prev - 1; - flecs_process_pending_tables(world); + /* Find exit instruction for optional term, and make the fail label + * point to the Not operation, so that even when the operation fails, + * it won't discard the result */ + int i, min_fail = -1, exit_op = -1; + for (i = prev; i < rule->operation_count; i ++) { + ecs_rule_op_t *op = &rule->operations[i]; + if (min_fail == -1 || (op->on_fail >= 0 && op->on_fail < min_fail)){ + min_fail = op->on_fail; + exit_op = i; + } + } - if (ecs_term_finalize(world, NULL, term)) { - ecs_throw(ECS_INVALID_PARAMETER, NULL); + ecs_assert(exit_op != -1, ECS_INTERNAL_ERROR, NULL); + ecs_rule_op_t *op = &rule->operations[exit_op]; + op->on_fail = rule->operation_count - 1; } - ecs_iter_t it = { - .real_world = (ecs_world_t*)world, - .world = (ecs_world_t*)stage, - .term_count = 1, - .next = ecs_term_next - }; - - term_iter_init(world, term, &it.priv.iter.term, false); - - return it; -error: - return (ecs_iter_t){ 0 }; + push_frame(rule); } -ecs_iter_t ecs_term_chain_iter( - const ecs_iter_t *chain_it, - ecs_term_t *term) +/* Create program from operations that will execute the query */ +static +void compile_program( + ecs_rule_t *rule) { - ecs_check(chain_it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_world_t *world = chain_it->real_world; - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - - if (ecs_term_finalize(world, NULL, term)) { - ecs_throw(ECS_INVALID_PARAMETER, NULL); - } - - ecs_iter_t it = { - .real_world = (ecs_world_t*)world, - .world = chain_it->world, - .terms = term, - .term_count = 1, - .chain_it = (ecs_iter_t*)chain_it, - .next = ecs_term_next - }; - - term_iter_init(world, term, &it.priv.iter.term, false); + /* Trace which variables have been written while inserting instructions. + * This determines which instruction needs to be inserted */ + bool written[ECS_RULE_MAX_VAR_COUNT] = { false }; - return it; -error: - return (ecs_iter_t){ 0 }; -} + ecs_term_t *terms = rule->filter.terms; + int32_t v, c, term_count = rule->filter.term_count; + ecs_rule_op_t *op; -static -const ecs_table_record_t *next_table( - ecs_term_iter_t *iter) -{ - ecs_id_record_t *idr = iter->cur; - if (!idr) { - return NULL; - } + /* Insert input, which is always the first instruction */ + insert_input(rule); - const ecs_table_record_t *tr; - if (!(tr = flecs_table_cache_next(&iter->it, ecs_table_record_t))) { - if (iter->empty_tables) { - iter->empty_tables = false; - flecs_table_cache_iter(&idr->cache, &iter->it); - tr = flecs_table_cache_next(&iter->it, ecs_table_record_t); + /* First insert all instructions that do not have a variable subject. Such + * instructions iterate the type of an entity literal and are usually good + * candidates for quickly narrowing down the set of potential results. */ + for (c = 0; c < term_count; c ++) { + ecs_term_t *term = &terms[c]; + if (skip_term(term)) { + continue; } - } - - return tr; -} -static -bool term_iter_next( - ecs_world_t *world, - ecs_term_iter_t *iter, - bool match_prefab, - bool match_disabled) -{ - ecs_table_t *table = iter->table; - ecs_entity_t source = 0; - const ecs_table_record_t *tr; - ecs_term_t *term = &iter->term; + if (term->oper == EcsOptional) { + continue; + } - do { - if (table) { - iter->cur_match ++; - if (iter->cur_match >= iter->match_count) { - table = NULL; - } else { - iter->last_column = ecs_search_offset( - world, table, iter->last_column + 1, term->id, 0); - iter->column = iter->last_column + 1; - if (iter->last_column >= 0) { - iter->id = ecs_vector_get( - table->type, ecs_id_t, iter->last_column)[0]; - } - } + ecs_rule_var_t* subj = term_subj(rule, term); + if (subj) { + continue; } - if (!table) { - if (!(tr = next_table(iter))) { - if (iter->cur != iter->set_index && iter->set_index != NULL) { - iter->cur = iter->set_index; - flecs_table_cache_iter(&iter->set_index->cache, &iter->it); - iter->index = 0; - tr = next_table(iter); - } + insert_term(rule, term, c, written); + } - if (!tr) { - return false; - } - } + /* Insert variables based on dependency order */ + for (v = 0; v < rule->subj_var_count; v ++) { + ecs_rule_var_t *var = &rule->vars[v]; - table = tr->hdr.table; + ecs_assert(var->kind == EcsRuleVarKindTable, ECS_INTERNAL_ERROR, NULL); - if (!match_prefab && (table->flags & EcsTableIsPrefab)) { + for (c = 0; c < term_count; c ++) { + ecs_term_t *term = &terms[c]; + if (skip_term(term)) { continue; } - if (!match_disabled && (table->flags & EcsTableIsDisabled)) { + if (term->oper == EcsOptional) { continue; } - iter->table = table; - iter->match_count = tr->count; - iter->cur_match = 0; - iter->last_column = tr->column; - iter->column = tr->column + 1; - iter->id = ecs_vector_get(table->type, ecs_id_t, tr->column)[0]; - } - - if (iter->cur == iter->set_index) { - const ecs_term_id_t *subj = &term->subj; - - if (iter->self_index) { - if (flecs_id_record_table(iter->self_index, table) != NULL) { - /* If the table has the id itself and this term matched Self - * we already matched it */ - continue; - } - } - - /* Test if following the relation finds the id */ - int32_t index = ecs_search_relation(world, table, 0, - term->id, subj->set.relation, subj->set.min_depth, - subj->set.max_depth, &source, &iter->id, NULL); - - if (index == -1) { - source = 0; + /* Only process columns for which variable is subject */ + ecs_rule_var_t* subj = term_subj(rule, term); + if (subj != var) { continue; } - ecs_assert(source != 0, ECS_INTERNAL_ERROR, NULL); + insert_term(rule, term, c, written); - iter->column = (index + 1) * -1; + var = &rule->vars[v]; } + } - break; - } while (true); - - iter->subject = source; + /* Insert terms with Not operators */ + for (c = 0; c < term_count; c ++) { + ecs_term_t *term = &terms[c]; + if (term->oper != EcsNot) { + continue; + } - return true; -} + insert_term(rule, term, c, written); + } -bool ecs_term_next( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_term_next, ECS_INVALID_PARAMETER, NULL); + /* Insert terms with Optional operators last, as optional terms cannot + * eliminate results, and would just add overhead to evaluation of + * non-matching entities. */ + for (c = 0; c < term_count; c ++) { + ecs_term_t *term = &terms[c]; + if (term->oper != EcsOptional) { + continue; + } + + insert_term(rule, term, c, written); + } - ecs_term_iter_t *iter = &it->priv.iter.term; - ecs_term_t *term = &iter->term; - ecs_world_t *world = it->real_world; - ecs_table_t *table; + /* Verify all subject variables have been written. Subject variables are of + * the table type, and a select/subset should have been inserted for each */ + for (v = 0; v < rule->subj_var_count; v ++) { + if (!written[v]) { + /* If the table variable hasn't been written, this can only happen + * if an instruction wrote the variable before a select/subset could + * have been inserted for it. Make sure that this is the case by + * testing if an entity variable exists and whether it has been + * written. */ + ecs_rule_var_t *var = find_variable( + rule, EcsRuleVarKindEntity, rule->vars[v].name); + ecs_assert(var != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(written[var->id], ECS_INTERNAL_ERROR, var->name); + (void)var; + } + } - it->ids = &iter->id; - it->subjects = &iter->subject; - it->columns = &iter->column; - it->terms = &iter->term; + /* Make sure that all entity variables are written. With the exception of + * the this variable, which can be returned as a table, other variables need + * to be available as entities. This ensures that all permutations for all + * variables are correctly returned by the iterator. When an entity variable + * hasn't been written yet at this point, it is because it only constrained + * through a common predicate or object. */ + for (; v < rule->var_count; v ++) { + if (!written[v]) { + ecs_rule_var_t *var = &rule->vars[v]; + ecs_assert(var->kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); - if (term->inout != EcsInOutFilter) { - it->sizes = &iter->size; - it->ptrs = &iter->ptr; - } else { - it->sizes = NULL; - it->ptrs = NULL; - } + ecs_rule_var_t *table_var = find_variable( + rule, EcsRuleVarKindTable, var->name); + + /* A table variable must exist if the variable hasn't been resolved + * yet. If there doesn't exist one, this could indicate an + * unconstrained variable which should have been caught earlier */ + ecs_assert(table_var != NULL, ECS_INTERNAL_ERROR, var->name); - ecs_iter_t *chain_it = it->chain_it; - if (chain_it) { - ecs_iter_next_action_t next = chain_it->next; - bool match; + /* Insert each operation that takes the table variable as input, and + * yields each entity in the table */ + op = insert_operation(rule, -1, written); + op->kind = EcsRuleEach; + op->r_in = table_var->id; + op->r_out = var->id; + op->frame = rule->frame_count; + op->has_in = true; + op->has_out = true; + written[var->id] = true; + + push_frame(rule); + } + } - do { - if (!next(chain_it)) { - goto done; - } + /* Insert yield, which is always the last operation */ + insert_yield(rule); +} - table = chain_it->table; - match = flecs_term_match_table(world, term, table, table->type, - it->ids, it->columns, it->subjects, it->match_indices, true); - } while (!match); - goto yield; +static +void create_variable_name_array( + ecs_rule_t *rule) +{ + if (rule->var_count) { + int i; + for (i = 0; i < rule->var_count; i ++) { + ecs_rule_var_t *var = &rule->vars[i]; - } else { - if (!term_iter_next(world, iter, false, false)) { - goto done; + if (var->kind != EcsRuleVarKindEntity) { + /* Table variables are hidden for applications. */ + rule->var_names[var->id] = NULL; + } else { + rule->var_names[var->id] = var->name; + } } + } +} - table = iter->table; - - /* Source must either be 0 (EcsThis) or nonzero in case of substitution */ - ecs_assert(iter->subject || iter->cur != iter->set_index, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(iter->table != NULL, ECS_INTERNAL_ERROR, NULL); +static +void create_variable_cross_references( + ecs_rule_t *rule) +{ + if (rule->var_count) { + int i; + for (i = 0; i < rule->var_count; i ++) { + ecs_rule_var_t *var = &rule->vars[i]; + if (var->kind == EcsRuleVarKindEntity) { + ecs_rule_var_t *tvar = find_variable( + rule, EcsRuleVarKindTable, var->name); + if (tvar) { + var->other = tvar->id; + } else { + var->other = -1; + } + } else { + ecs_rule_var_t *evar = find_variable( + rule, EcsRuleVarKindEntity, var->name); + if (evar) { + var->other = evar->id; + } else { + var->other = -1; + } + } + } } - -yield: - flecs_iter_populate_data(world, it, table, 0, 0, it->ptrs, it->sizes); - it->is_valid = true; - return true; -done: -error: - return false; } +/* Implementation for iterable mixin */ static -const ecs_filter_t* init_filter_iter( +void rule_iter_init( const ecs_world_t *world, - ecs_iter_t *it, - const ecs_filter_t *filter) + const ecs_poly_t *poly, + ecs_iter_t *iter, + ecs_term_t *filter) { - ecs_filter_iter_t *iter = &it->priv.iter.filter; + ecs_poly_assert(poly, ecs_rule_t); if (filter) { - iter->filter = *filter; + iter[1] = ecs_rule_iter(world, (ecs_rule_t*)poly); + iter[0] = ecs_term_chain_iter(&iter[1], filter); + } else { + iter[0] = ecs_rule_iter(world, (ecs_rule_t*)poly); + } +} - if (filter->term_cache_used) { - iter->filter.terms = iter->filter.term_cache; +static +int32_t find_term_var_id( + ecs_rule_t *rule, + ecs_term_id_t *term_id) +{ + if (term_id_is_variable(term_id)) { + const char *var_name = term_id_var_name(term_id); + ecs_rule_var_t *var = find_variable( + rule, EcsRuleVarKindEntity, var_name); + if (var) { + return var->id; + } else { + /* If this is Any look for table variable. Since Any is only + * required to return a single result, there is no need to + * insert an each instruction for a matching table. */ + if (term_id->entity == EcsAny) { + var = find_variable( + rule, EcsRuleVarKindTable, var_name); + if (var) { + return var->id; + } + } } + } + + return -1; +} - ecs_filter_finalize(world, &iter->filter); - - ecs_assert(!filter->term_cache_used || - filter->terms == filter->term_cache, ECS_INTERNAL_ERROR, NULL); - } else { - ecs_filter_init(world, &iter->filter, &(ecs_filter_desc_t) { - .terms = {{ .id = EcsAny }} - }); +ecs_rule_t* ecs_rule_init( + ecs_world_t *world, + const ecs_filter_desc_t *desc) +{ + ecs_rule_t *result = ecs_poly_new(ecs_rule_t); - filter = &iter->filter; + /* Parse the signature expression. This initializes the columns array which + * contains the information about which components/pairs are requested. */ + if (ecs_filter_init(world, &result->filter, desc)) { + goto error; } - it->term_count = filter->term_count_actual; + result->world = world; - return filter; -} + /* Rule has no terms */ + if (!result->filter.term_count) { + rule_error(result, "rule has no terms"); + goto error; + } -int32_t ecs_filter_pivot_term( - const ecs_world_t *world, - const ecs_filter_t *filter) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(filter != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_term_t *terms = result->filter.terms; + int32_t i, term_count = result->filter.term_count; - ecs_term_t *terms = filter->terms; - int32_t i, term_count = filter->term_count; - int32_t pivot_term = -1, min_count = -1; + /* Make sure rule doesn't just have Not terms */ + for (i = 0; i < term_count; i++) { + ecs_term_t *term = &terms[i]; + if (term->oper != EcsNot) { + break; + } + } + if (i == term_count) { + rule_error(result, "rule cannot only have terms with Not operator"); + goto error; + } + + /* Find all variables & resolve dependencies */ + if (scan_variables(result) != 0) { + goto error; + } + /* Create lookup array for subject variables */ for (i = 0; i < term_count; i ++) { ecs_term_t *term = &terms[i]; - ecs_id_t id = term->id; + ecs_rule_term_vars_t *vars = &result->term_vars[i]; + vars->pred = find_term_var_id(result, &term->pred); + vars->subj = find_term_var_id(result, &term->subj); + vars->obj = find_term_var_id(result, &term->obj); + } - if (term->oper != EcsAnd) { - continue; - } + /* Generate the opcode array */ + compile_program(result); - if (term->subj.entity != EcsThis) { - continue; - } + /* Create array with variable names so this can be easily accessed by + * iterators without requiring access to the ecs_rule_t */ + create_variable_name_array(result); - ecs_id_record_t *idr = flecs_get_id_record(world, - actual_match_id(id)); - if (!idr) { - /* If one of the terms does not match with any data, iterator - * should not return anything */ - return -2; /* -2 indicates filter doesn't match anything */ - } + /* Create cross-references between variables so it's easy to go from entity + * to table variable and vice versa */ + create_variable_cross_references(result); - int32_t table_count = ecs_table_cache_count(&idr->cache); - if (min_count == -1 || table_count < min_count) { - min_count = table_count; - pivot_term = i; - } - } + result->iterable.init = rule_iter_init; - return pivot_term; + return result; error: - return -2; + ecs_rule_fini(result); + return NULL; } -ecs_iter_t ecs_filter_iter( - const ecs_world_t *stage, - const ecs_filter_t *filter) +void ecs_rule_fini( + ecs_rule_t *rule) { - ecs_check(stage != NULL, ECS_INVALID_PARAMETER, NULL); + int32_t i; + for (i = 0; i < rule->var_count; i ++) { + ecs_os_free(rule->vars[i].name); + } - const ecs_world_t *world = ecs_get_world(stage); - - flecs_process_pending_tables(world); + ecs_filter_fini(&rule->filter); - ecs_iter_t it = { - .real_world = (ecs_world_t*)world, - .world = (ecs_world_t*)stage, - .terms = filter ? filter->terms : NULL, - .next = ecs_filter_next, - .is_instanced = filter ? filter->instanced : false - }; + ecs_os_free(rule->operations); + ecs_os_free(rule); +} - ecs_filter_iter_t *iter = &it.priv.iter.filter; +const ecs_filter_t* ecs_rule_get_filter( + const ecs_rule_t *rule) +{ + return &rule->filter; +} - filter = init_filter_iter(world, &it, filter); +/* Quick convenience function to get a variable from an id */ +static +ecs_rule_var_t* get_variable( + const ecs_rule_t *rule, + int32_t var_id) +{ + if (var_id == UINT8_MAX) { + return NULL; + } - /* Find term that represents smallest superset */ - if (filter->match_this) { - ecs_term_t *terms = filter->terms; - int32_t pivot_term = -1; - ecs_check(terms != NULL, ECS_INVALID_PARAMETER, NULL); + return (ecs_rule_var_t*)&rule->vars[var_id]; +} - iter->kind = EcsIterEvalIndex; +/* Convert the program to a string. This can be useful to analyze how a rule is + * being evaluated. */ +char* ecs_rule_str( + ecs_rule_t *rule) +{ + ecs_check(rule != NULL, ECS_INVALID_PARAMETER, NULL); + + ecs_world_t *world = rule->world; + ecs_strbuf_t buf = ECS_STRBUF_INIT; + char filter_expr[256]; - pivot_term = ecs_filter_pivot_term(world, filter); + int32_t i, count = rule->operation_count; + for (i = 1; i < count; i ++) { + ecs_rule_op_t *op = &rule->operations[i]; + ecs_rule_pair_t pair = op->filter; + ecs_entity_t pred = pair.pred.ent; + ecs_entity_t obj = pair.obj.ent; + const char *pred_name = NULL, *obj_name = NULL; + char *pred_name_alloc = NULL, *obj_name_alloc = NULL; - if (pivot_term == -2) { - /* One or more terms have no matching results */ - term_iter_init_no_data(&iter->term_iter); - return it; - } else if (pivot_term == -1) { - /* No terms meet the criteria to be a pivot term, evaluate filter - * against all tables */ - term_iter_init_wildcard(world, &iter->term_iter); - } else { - ecs_assert(pivot_term >= 0, ECS_INTERNAL_ERROR, NULL); - term_iter_init(world, &terms[pivot_term], &iter->term_iter, - filter->match_empty_tables); + if (pair.reg_mask & RULE_PAIR_PREDICATE) { + ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_rule_var_t *type_var = &rule->vars[pair.pred.reg]; + pred_name = type_var->name; + } else if (pred) { + pred_name_alloc = ecs_get_fullpath(world, ecs_get_alive(world, pred)); + pred_name = pred_name_alloc; } - iter->term_iter.empty_tables = filter->match_empty_tables; - } else { - if (!filter->match_anything) { - iter->kind = EcsIterEvalCondition; - term_iter_init_no_data(&iter->term_iter); - } else { - iter->kind = EcsIterEvalNone; + if (pair.reg_mask & RULE_PAIR_OBJECT) { + ecs_assert(rule->vars != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_rule_var_t *obj_var = &rule->vars[pair.obj.reg]; + obj_name = obj_var->name; + } else if (obj) { + obj_name_alloc = ecs_get_fullpath(world, ecs_get_alive(world, obj)); + obj_name = obj_name_alloc; + } else if (pair.obj_0) { + obj_name = "0"; } - } - - if (filter->terms == filter->term_cache) { - /* Because we're returning the iterator by value, the address of the - * term cache changes. The ecs_filter_next function will set the correct - * address when it detects that terms is set to NULL */ - iter->filter.terms = NULL; - } - it.is_filter = filter->filter; - - return it; -error: - return (ecs_iter_t){ 0 }; -} + ecs_strbuf_append(&buf, "%2d: [S:%2d, P:%2d, F:%2d, T:%2d] ", i, + op->frame, op->on_pass, op->on_fail, op->term); -ecs_iter_t ecs_filter_chain_iter( - const ecs_iter_t *chain_it, - const ecs_filter_t *filter) -{ - ecs_iter_t it = { - .terms = filter->terms, - .term_count = filter->term_count, - .world = chain_it->world, - .real_world = chain_it->real_world, - .chain_it = (ecs_iter_t*)chain_it, - .next = ecs_filter_next - }; + bool has_filter = false; - ecs_filter_iter_t *iter = &it.priv.iter.filter; - init_filter_iter(it.world, &it, filter); + switch(op->kind) { + case EcsRuleSelect: + ecs_strbuf_append(&buf, "select "); + has_filter = true; + break; + case EcsRuleWith: + ecs_strbuf_append(&buf, "with "); + has_filter = true; + break; + case EcsRuleStore: + ecs_strbuf_append(&buf, "store "); + break; + case EcsRuleSuperSet: + ecs_strbuf_append(&buf, "superset "); + has_filter = true; + break; + case EcsRuleSubSet: + ecs_strbuf_append(&buf, "subset "); + has_filter = true; + break; + case EcsRuleEach: + ecs_strbuf_append(&buf, "each "); + break; + case EcsRuleSetJmp: + ecs_strbuf_append(&buf, "setjmp "); + break; + case EcsRuleJump: + ecs_strbuf_append(&buf, "jump "); + break; + case EcsRuleNot: + ecs_strbuf_append(&buf, "not "); + break; + case EcsRuleInTable: + ecs_strbuf_append(&buf, "intable "); + has_filter = true; + break; + case EcsRuleEq: + ecs_strbuf_append(&buf, "eq "); + has_filter = true; + break; + case EcsRuleYield: + ecs_strbuf_append(&buf, "yield "); + break; + default: + continue; + } - iter->kind = EcsIterEvalChain; + if (op->has_out) { + ecs_rule_var_t *r_out = get_variable(rule, op->r_out); + if (r_out) { + ecs_strbuf_append(&buf, "O:%s%s ", + r_out->kind == EcsRuleVarKindTable ? "t" : "", + r_out->name); + } else if (op->subject) { + char *subj_path = ecs_get_fullpath(world, op->subject); + ecs_strbuf_append(&buf, "O:%s ", subj_path); + ecs_os_free(subj_path); + } + } - if (filter->terms == filter->term_cache) { - /* See ecs_filter_iter */ - iter->filter.terms = NULL; - } + if (op->has_in) { + ecs_rule_var_t *r_in = get_variable(rule, op->r_in); + if (r_in) { + ecs_strbuf_append(&buf, "I:%s%s ", + r_in->kind == EcsRuleVarKindTable ? "t" : "", + r_in->name); + } + if (op->subject) { + char *subj_path = ecs_get_fullpath(world, op->subject); + ecs_strbuf_append(&buf, "I:%s ", subj_path); + ecs_os_free(subj_path); + } + } - return it; -} + if (has_filter) { + if (!pred_name) { + pred_name = "-"; + } + if (!obj_name && !pair.obj_0) { + ecs_os_sprintf(filter_expr, "(%s)", pred_name); + } else { + ecs_os_sprintf(filter_expr, "(%s, %s)", pred_name, obj_name); + } + ecs_strbuf_append(&buf, "F:%s", filter_expr); + } -bool ecs_filter_next( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL); + ecs_strbuf_appendstr(&buf, "\n"); - if (flecs_iter_next_row(it)) { - return true; + ecs_os_free(pred_name_alloc); + ecs_os_free(obj_name_alloc); } - return flecs_iter_next_instanced(it, ecs_filter_next_instanced(it)); + return ecs_strbuf_get(&buf); error: - return false; + return NULL; } -bool ecs_filter_next_instanced( - ecs_iter_t *it) +/* Public function that returns number of variables. This enables an application + * to iterate the variables and obtain their values. */ +int32_t ecs_rule_var_count( + const ecs_rule_t *rule) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_filter_next, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->chain_it != it, ECS_INVALID_PARAMETER, NULL); - - ecs_filter_iter_t *iter = &it->priv.iter.filter; - ecs_filter_t *filter = &iter->filter; - ecs_world_t *world = it->real_world; - ecs_table_t *table = NULL; - bool match; + ecs_assert(rule != NULL, ECS_INTERNAL_ERROR, NULL); + return rule->var_count; +} - if (!filter->terms) { - filter->terms = filter->term_cache; +/* Public function to find a variable by name */ +int32_t ecs_rule_find_var( + const ecs_rule_t *rule, + const char *name) +{ + ecs_rule_var_t *v = find_variable(rule, EcsRuleVarKindEntity, name); + if (v) { + return v->id; + } else { + return -1; } +} - flecs_iter_init(it); - - ecs_iter_t *chain_it = it->chain_it; - ecs_iter_kind_t kind = iter->kind; - - if (chain_it) { - ecs_assert(kind == EcsIterEvalChain, ECS_INVALID_PARAMETER, NULL); - - ecs_iter_next_action_t next = chain_it->next; - do { - if (!next(chain_it)) { - goto done; - } +/* Public function to get the name of a variable. */ +const char* ecs_rule_var_name( + const ecs_rule_t *rule, + int32_t var_id) +{ + return rule->vars[var_id].name; +} - table = chain_it->table; - match = flecs_filter_match_table(world, filter, table, - it->ids, it->columns, it->subjects, it->match_indices, NULL, - true, -1); - } while (!match); +/* Public function to get the type of a variable. */ +bool ecs_rule_var_is_entity( + const ecs_rule_t *rule, + int32_t var_id) +{ + return rule->vars[var_id].kind == EcsRuleVarKindEntity; +} - goto yield; - } else if (kind == EcsIterEvalIndex || kind == EcsIterEvalCondition) { - ecs_term_iter_t *term_iter = &iter->term_iter; - ecs_term_t *term = &term_iter->term; - int32_t pivot_term = term->index; - bool first; +/* Public function to set the value of a variable before iterating. */ +void ecs_rule_set_var( + ecs_iter_t *it, + int32_t var_id, + ecs_entity_t value) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(var_id != -1, ECS_INVALID_PARAMETER, NULL); + ecs_check(value != 0, ECS_INVALID_PARAMETER, NULL); + /* Can't set variable while iterating */ + ecs_check(it->is_valid == false, ECS_INVALID_OPERATION, NULL); + ecs_check(it->next == ecs_rule_next, ECS_INVALID_OPERATION, NULL); - do { - first = iter->matches_left == 0; + ecs_rule_iter_t *iter = &it->priv.iter.rule; + ecs_check(iter->registers != NULL, ECS_INVALID_PARAMETER, NULL); - if (first) { - if (kind != EcsIterEvalCondition) { - /* Find new match, starting with the leading term */ - if (!term_iter_next(world, term_iter, - filter->match_prefab, filter->match_disabled)) - { - goto done; - } + const ecs_rule_t *r = iter->rule; + ecs_check(var_id < r->var_count, ECS_INVALID_PARAMETER, NULL); - ecs_assert(term_iter->match_count != 0, - ECS_INTERNAL_ERROR, NULL); + entity_reg_set(r, iter->registers, var_id, value); - if (pivot_term == -1) { - /* Without a pivot term, we're iterating all tables with - * a wildcard, so the match count is meaningless. */ - term_iter->match_count = 1; - } + /* Also set table variable if it exists */ + const ecs_rule_var_t *var = &r->vars[var_id]; + if (var->other != -1) { + const ecs_rule_var_t *tvar = &r->vars[var->other]; + ecs_assert(tvar->kind == EcsRuleVarKindTable, + ECS_INTERNAL_ERROR, NULL); + (void)tvar; + reg_set_entity(r, iter->registers, var->other, value); + } +error: + return; +} - iter->matches_left = term_iter->match_count; +static +void ecs_rule_iter_free( + ecs_iter_t *iter) +{ + ecs_rule_iter_t *it = &iter->priv.iter.rule; + ecs_os_free(it->registers); + ecs_os_free(it->columns); + ecs_os_free(it->op_ctx); + ecs_os_free(it->variables); + iter->columns = NULL; + it->registers = NULL; + it->columns = NULL; + it->op_ctx = NULL; +} - /* Filter iterator takes control over iterating all the - * permutations that match the wildcard. */ - term_iter->match_count = 1; +/* Create rule iterator */ +ecs_iter_t ecs_rule_iter( + const ecs_world_t *world, + const ecs_rule_t *rule) +{ + ecs_assert(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_assert(rule != NULL, ECS_INVALID_PARAMETER, NULL); - table = term_iter->table; - if (pivot_term != -1) { - it->ids[pivot_term] = term_iter->id; - it->subjects[pivot_term] = term_iter->subject; - it->columns[pivot_term] = term_iter->column; - } - } else { - /* Progress iterator to next match for table, if any */ - table = it->table; - if (term_iter->index == 0) { - iter->matches_left = 1; - term_iter->index = 1; /* prevents looping again */ - } else { - goto done; - } - } + ecs_iter_t result = {0}; + int i; - /* Match the remainder of the terms */ - match = flecs_filter_match_table(world, filter, table, - it->ids, it->columns, it->subjects, - it->match_indices, &iter->matches_left, first, - pivot_term); - if (!match) { - iter->matches_left = 0; - continue; - } - - ecs_assert(iter->matches_left != 0, ECS_INTERNAL_ERROR, NULL); - } + result.world = (ecs_world_t*)world; + result.real_world = (ecs_world_t*)ecs_get_world(rule->world); - /* If this is not the first result for the table, and the table - * is matched more than once, iterate remaining matches */ - if (!first && (iter->matches_left > 0)) { - table = it->table; - - /* Find first term that still has matches left */ - int32_t i, j, count = it->term_count; - for (i = count - 1; i >= 0; i --) { - int32_t mi = -- it->match_indices[i]; - if (mi) { - break; - } - } + flecs_process_pending_tables(result.real_world); - /* Progress first term to next match (must be at least one) */ - it->columns[i] ++; - flecs_term_match_table(world, &filter->terms[i], table, - table->type, &it->ids[i], &it->columns[i], &it->subjects[i], - &it->match_indices[i], false); + ecs_rule_iter_t *it = &result.priv.iter.rule; + it->rule = rule; - /* Reset remaining terms (if any) to first match */ - for (j = i + 1; j < count; j ++) { - flecs_term_match_table(world, &filter->terms[j], table, - table->type, &it->ids[j], &it->columns[j], - &it->subjects[j], &it->match_indices[j], true); - } - } + if (rule->operation_count) { + if (rule->var_count) { + it->registers = ecs_os_malloc_n(ecs_rule_reg_t, + rule->operation_count * rule->var_count); - match = iter->matches_left != 0; - iter->matches_left --; + it->variables = ecs_os_malloc_n(ecs_entity_t, rule->var_count); + } + + it->op_ctx = ecs_os_calloc_n(ecs_rule_op_ctx_t, rule->operation_count); - ecs_assert(iter->matches_left >= 0, ECS_INTERNAL_ERROR, NULL); - } while (!match); + if (rule->filter.term_count) { + it->columns = ecs_os_malloc_n(int32_t, + rule->operation_count * rule->filter.term_count); + } - goto yield; + for (i = 0; i < rule->filter.term_count; i ++) { + it->columns[i] = -1; + } } -done: -error: - ecs_iter_fini(it); - return false; - -yield: - it->offset = 0; - flecs_iter_populate_data(world, it, table, 0, 0, it->ptrs, it->sizes); - it->is_valid = true; - return true; -} - + it->op = 0; -static -int32_t type_search( - const ecs_table_t *table, - ecs_id_record_t *idr, - ecs_id_t *ids, - ecs_id_t *id_out, - ecs_table_record_t **tr_out) -{ - ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table); - if (tr) { - int32_t r = tr->column; - if (tr_out) tr_out[0] = tr; - if (id_out) id_out[0] = ids[r]; - return r; + for (i = 0; i < rule->var_count; i ++) { + if (rule->vars[i].kind == EcsRuleVarKindEntity) { + entity_reg_set(rule, it->registers, i, EcsWildcard); + } else { + table_reg_set(rule, it->registers, i, NULL); + } } - return -1; + result.variable_names = (char**)rule->var_names; + result.variable_count = rule->var_count; + result.term_count = rule->filter.term_count; + result.terms = rule->filter.terms; + result.next = ecs_rule_next; + result.fini = ecs_rule_iter_free; + result.is_filter = rule->filter.filter; + result.columns = it->columns; /* prevent alloc */ + + return result; } +/* Edge case: if the filter has the same variable for both predicate and + * object, they are both resolved at the same time but at the time of + * evaluating the filter they're still wildcards which would match columns + * that have different predicates/objects. Do an additional scan to make + * sure the column we're returning actually matches. */ static -int32_t type_offset_search( - int32_t offset, - ecs_id_t id, - ecs_id_t *ids, - int32_t count, - ecs_id_t *id_out) +int32_t find_next_same_var( + ecs_type_t type, + int32_t column, + ecs_id_t pattern) { - ecs_assert(ids != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(count > 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(offset > 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); - ecs_assert(!ECS_HAS_ROLE(id, CASE), ECS_INVALID_PARAMETER, NULL); + /* If same_var is true, this has to be a wildcard pair. We cannot have + * the same variable in a pair, and one part of a pair resolved with + * another part unresolved. */ + ecs_assert(pattern == ecs_pair(EcsWildcard, EcsWildcard), + ECS_INTERNAL_ERROR, NULL); + (void)pattern; + + /* Keep scanning for an id where rel and obj are the same */ + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); + int32_t i, count = ecs_vector_count(type); + for (i = column + 1; i < count; i ++) { + ecs_id_t id = ids[i]; + if (!ECS_HAS_ROLE(id, PAIR)) { + /* If id is not a pair, this will definitely not match, and we + * will find no further matches. */ + return -1; + } - while (offset < count) { - ecs_id_t type_id = ids[offset ++]; - if (ecs_id_match(type_id, id)) { - if (id_out) id_out[0] = type_id; - return offset - 1; + if (ECS_PAIR_FIRST(id) == ECS_PAIR_SECOND(id)) { + /* Found a match! */ + return i; } } + /* No pairs found with same rel/obj */ return -1; } static -bool type_can_inherit_id( +int32_t find_next_column( const ecs_world_t *world, const ecs_table_t *table, - const ecs_id_record_t *idr, - ecs_id_t id) + int32_t column, + ecs_rule_filter_t *filter) { - if (idr->flags & ECS_ID_DONT_INHERIT) { - return false; - } - if (idr->flags & ECS_ID_EXCLUSIVE) { - if (ECS_HAS_ROLE(id, PAIR)) { - ecs_entity_t er = ECS_PAIR_FIRST(id); - if (flecs_get_table_record( - world, table, ecs_pair(er, EcsWildcard))) - { - return false; - } + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_entity_t pattern = filter->mask; + ecs_type_t type = table->type; + + if (column == -1) { + ecs_table_record_t *tr = flecs_get_table_record(world, table, pattern); + if (!tr) { + return -1; + } + column = tr->column; + } else { + column = ecs_search_offset(world, table, column + 1, filter->mask, 0); + if (column == -1) { + return -1; } } - return true; + + if (filter->same_var) { + column = find_next_same_var(type, column - 1, filter->mask); + } + + return column; } +/* This function finds the next table in a table set, and is used by the select + * operation. The function automatically skips empty tables, so that subsequent + * operations don't waste a lot of processing for nothing. */ static -int32_t type_search_relation( - const ecs_world_t *world, - const ecs_table_t *table, - int32_t offset, - ecs_id_t id, - ecs_id_record_t *idr, - ecs_id_t rel, - ecs_id_record_t *idr_r, - int32_t min_depth, - int32_t max_depth, - ecs_entity_t *subject_out, - ecs_id_t *id_out, - ecs_table_record_t **tr_out) +ecs_table_record_t find_next_table( + ecs_rule_filter_t *filter, + ecs_rule_with_ctx_t *op_ctx) { - ecs_type_t type = table->type; - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t count = ecs_vector_count(type); + ecs_table_cache_iter_t *it = &op_ctx->it; + ecs_table_t *table = NULL; + int32_t column = -1; - if (min_depth <= 0) { - if (offset) { - int32_t r = type_offset_search(offset, id, ids, count, id_out); - if (r != -1) { - return r; - } - } else { - int32_t r = type_search(table, idr, ids, id_out, tr_out); - if (r != -1) { - return r; - } + const ecs_table_record_t *tr; + while ((column == -1) && (tr = flecs_table_cache_next(it, ecs_table_record_t))) { + table = tr->hdr.table; + + /* Should only iterate non-empty tables */ + ecs_assert(ecs_table_count(table) != 0, ECS_INTERNAL_ERROR, NULL); + + column = tr->column; + if (filter->same_var) { + column = find_next_same_var(table->type, column - 1, filter->mask); } } - ecs_flags32_t flags = table->flags; - if ((flags & EcsTableHasPairs) && max_depth && rel) { - bool is_a = rel == ecs_pair(EcsIsA, EcsWildcard); - if (is_a) { - if (!(flags & EcsTableHasIsA)) { - return -1; - } - if (!type_can_inherit_id(world, table, idr, id)) { - return -1; - } - idr_r = world->idr_isa_wildcard; - } + if (column == -1) { + table = NULL; + } - if (!idr_r) { - idr_r = flecs_get_id_record(world, rel); - if (!idr_r) { - return -1; - } - } + return (ecs_table_record_t){.hdr.table = table, .column = column}; +} - ecs_id_t id_r; - ecs_table_record_t *tr_r; - int32_t r, r_column = type_search(table, idr_r, ids, &id_r, &tr_r); - while (r_column != -1) { - ecs_entity_t obj = ECS_PAIR_SECOND(id_r); - ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); - ecs_record_t *rec = ecs_eis_get_any(world, obj); - ecs_assert(rec != NULL, ECS_INTERNAL_ERROR, NULL); +static +ecs_id_record_t* find_tables( + ecs_world_t *world, + ecs_id_t id) +{ + ecs_id_record_t *idr = flecs_get_id_record(world, id); + if (!idr || !ecs_table_cache_count(&idr->cache)) { + /* Skip ids that don't have (non-empty) tables */ + return NULL; + } + return idr; +} - ecs_table_t *obj_table = rec->table; - if (obj_table) { - r = type_search_relation(world, obj_table, offset, id, idr, - rel, idr_r, min_depth - 1, max_depth - 1, subject_out, - id_out, tr_out); - if (r != -1) { - if (subject_out && !subject_out[0]) { - subject_out[0] = ecs_get_alive(world, obj); - } - return r; - } +static +ecs_id_t rule_get_column( + ecs_type_t type, + int32_t column) +{ + ecs_id_t *comp = ecs_vector_get(type, ecs_id_t, column); + ecs_assert(comp != NULL, ECS_INTERNAL_ERROR, NULL); + return *comp; +} - if (!is_a) { - r = type_search_relation(world, obj_table, offset, id, idr, - ecs_pair(EcsIsA, EcsWildcard), world->idr_isa_wildcard, - 1, INT_MAX, subject_out, id_out, tr_out); - if (r != -1) { - if (subject_out && !subject_out[0]) { - subject_out[0] = ecs_get_alive(world, obj); - } - return r; - } - } - } +static +void set_source( + ecs_iter_t *it, + ecs_rule_op_t *op, + ecs_rule_reg_t *regs, + int32_t r) +{ + if (op->term == -1) { + /* If operation is not associated with a term, don't set anything */ + return; + } - r_column = type_offset_search(r_column + 1, rel, ids, count, &id_r); + ecs_assert(op->term >= 0, ECS_INTERNAL_ERROR, NULL); + + const ecs_rule_t *rule = it->priv.iter.rule.rule; + if ((r != UINT8_MAX) && rule->vars[r].kind == EcsRuleVarKindEntity) { + it->subjects[op->term] = reg_get_entity(rule, op, regs, r); + } else { + it->subjects[op->term] = 0; + } +} + +static +void set_term_vars( + const ecs_rule_t *rule, + ecs_rule_reg_t *regs, + int32_t term, + ecs_id_t id) +{ + if (term != -1) { + const ecs_rule_term_vars_t *vars = &rule->term_vars[term]; + if (vars->pred != -1) { + regs[vars->pred].entity = ECS_PAIR_FIRST(id); + } + if (vars->obj != -1) { + regs[vars->obj].entity = ECS_PAIR_SECOND(id); } } +} - return -1; +/* Input operation. The input operation acts as a placeholder for the start of + * the program, and creates an entry in the register array that can serve to + * store variables passed to an iterator. */ +static +bool eval_input( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) +{ + (void)it; + (void)op; + (void)op_index; + + if (!redo) { + /* First operation executed by the iterator. Always return true. */ + return true; + } else { + /* When Input is asked to redo, it means that all other operations have + * exhausted their results. Input itself does not yield anything, so + * return false. This will terminate rule execution. */ + return false; + } } -int32_t ecs_search_relation( - const ecs_world_t *world, - const ecs_table_t *table, - int32_t offset, - ecs_id_t id, - ecs_entity_t rel, - int32_t min_depth, - int32_t max_depth, - ecs_entity_t *subject_out, - ecs_id_t *id_out, - struct ecs_table_record_t **tr_out) +static +bool eval_superset( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - if (!table) return -1; + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_world_t *world = rule->world; + ecs_rule_superset_ctx_t *op_ctx = &iter->op_ctx[op_index].is.superset; + ecs_rule_superset_frame_t *frame = NULL; + ecs_rule_reg_t *regs = get_registers(iter, op); - ecs_poly_assert(world, ecs_world_t); - ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); + /* Get register indices for output */ + int32_t sp; + int32_t r = op->r_out; - bool is_case = ECS_HAS_ROLE(id, CASE); - id = is_case * (ECS_SWITCH | ECS_PAIR_FIRST(id)) + !is_case * id; + /* Register cannot be a literal, since we need to store things in it */ + ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return -1; + /* Get queried for id, fill out potential variables */ + ecs_rule_pair_t pair = op->filter; + + ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); + ecs_entity_t rel = ECS_PAIR_FIRST(filter.mask); + ecs_rule_filter_t super_filter = { + .mask = ecs_pair(rel, EcsWildcard) + }; + ecs_table_t *table = NULL; + + /* If the input register is not NULL, this is a variable that's been set by + * the application. */ + ecs_entity_t result = iter->registers[r].entity; + bool output_is_input = result && result != EcsWildcard; + + if (output_is_input && !redo) { + ecs_assert(regs[r].entity == iter->registers[r].entity, + ECS_INTERNAL_ERROR, NULL); } - max_depth = INT_MAX * !max_depth + max_depth * !!max_depth; + if (!redo) { + op_ctx->stack = op_ctx->storage; + sp = op_ctx->sp = 0; + frame = &op_ctx->stack[sp]; - int32_t result = type_search_relation(world, table, offset, id, idr, - ecs_pair(rel, EcsWildcard), NULL, min_depth, max_depth, subject_out, - id_out, tr_out); + /* Get table of object for which to get supersets */ + ecs_entity_t obj = ECS_PAIR_SECOND(filter.mask); + if (obj == EcsWildcard) { + ecs_assert(pair.reg_mask & RULE_PAIR_OBJECT, + ECS_INTERNAL_ERROR, NULL); + table = regs[pair.obj.reg].table.table; + } else { + table = table_from_entity(world, obj).table; + } - return result; -} + int32_t column; -int32_t ecs_search( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_id_t id, - ecs_id_t *id_out) -{ - if (!table) return -1; + /* If output variable is already set, check if it matches */ + if (output_is_input) { + ecs_id_t id = ecs_pair(rel, result); + ecs_entity_t subj = 0; + column = ecs_search_relation(world, table, 0, id, rel, + 0, 0, &subj, 0, NULL); + if (column != -1) { + if (subj != 0) { + table = ecs_get_table(world, subj); + } + } + } else { + column = find_next_column(world, table, -1, &super_filter); + } - ecs_poly_assert(world, ecs_world_t); - ecs_assert(id != 0, ECS_INVALID_PARAMETER, NULL); + /* If no matching column was found, there are no supersets */ + if (column == -1) { + return false; + } - ecs_id_record_t *idr = flecs_get_id_record(world, id); - if (!idr) { - return -1; - } + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_entity_t col_entity = rule_get_column(table->type, column); + ecs_entity_t col_obj = ecs_entity_t_lo(col_entity); - ecs_type_t type = table->type; - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - return type_search(table, idr, ids, id_out, NULL); -} + reg_set_entity(rule, regs, r, col_obj); -int32_t ecs_search_offset( - const ecs_world_t *world, - const ecs_table_t *table, - int32_t offset, - ecs_id_t id, - ecs_id_t *id_out) -{ - if (!offset) { - return ecs_search(world, table, id, id_out); + frame->table = table; + frame->column = column; + + return true; + } else if (output_is_input) { + return false; } - if (!table) return -1; + sp = op_ctx->sp; + frame = &op_ctx->stack[sp]; + table = frame->table; + int32_t column = frame->column; - ecs_poly_assert(world, ecs_world_t); + ecs_entity_t col_entity = rule_get_column(table->type, column); + ecs_entity_t col_obj = ecs_entity_t_lo(col_entity); + ecs_table_t *next_table = table_from_entity(world, col_obj).table; - ecs_type_t type = table->type; - ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); - int32_t count = ecs_vector_count(type); - return type_offset_search(offset, id, ids, count, id_out); -} + if (next_table) { + sp ++; + frame = &op_ctx->stack[sp]; + frame->table = next_table; + frame->column = -1; + } + do { + frame = &op_ctx->stack[sp]; + table = frame->table; + column = frame->column; -static -bool observer_run(ecs_iter_t *it) { - ecs_observer_t *o = it->ctx; - ecs_world_t *world = it->world; + column = find_next_column(world, table, column, &super_filter); + if (column != -1) { + op_ctx->sp = sp; + frame->column = column; + col_entity = rule_get_column(table->type, column); + col_obj = ecs_entity_t_lo(col_entity); + reg_set_entity(rule, regs, r, col_obj); + return true; + } - ecs_assert(o->callback != NULL, ECS_INVALID_PARAMETER, NULL); + sp --; + } while (sp >= 0); - if (o->last_event_id == world->event_id) { - /* Already handled this event */ - return false; - } + return false; +} - o->last_event_id = world->event_id; +static +bool eval_subset( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) +{ + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_world_t *world = rule->world; + ecs_rule_subset_ctx_t *op_ctx = &iter->op_ctx[op_index].is.subset; + ecs_rule_subset_frame_t *frame = NULL; + ecs_table_record_t table_record; + ecs_rule_reg_t *regs = get_registers(iter, op); - ecs_iter_t user_it = *it; - user_it.term_count = o->filter.term_count_actual; - user_it.terms = o->filter.terms; - user_it.is_filter = o->filter.filter; - user_it.ids = NULL; - user_it.columns = NULL; - user_it.subjects = NULL; - user_it.sizes = NULL; - user_it.ptrs = NULL; + /* Get register indices for output */ + int32_t sp, row; + int32_t r = op->r_out; + ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); - flecs_iter_init(&user_it); + /* Get queried for id, fill out potential variables */ + ecs_rule_pair_t pair = op->filter; + ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); + ecs_id_record_t *idr; + ecs_table_t *table = NULL; - ecs_table_t *table = it->table; - ecs_table_t *prev_table = it->other_table; - int32_t pivot_term = it->term_index; - ecs_term_t *term = &o->filter.terms[pivot_term]; + if (!redo) { + op_ctx->stack = op_ctx->storage; + sp = op_ctx->sp = 0; + frame = &op_ctx->stack[sp]; + idr = frame->with_ctx.idr = find_tables(world, filter.mask); + if (!idr) { + return false; + } - if (term->oper == EcsNot) { - table = it->other_table; - prev_table = it->table; - } + flecs_table_cache_iter(&idr->cache, &frame->with_ctx.it); + table_record = find_next_table(&filter, &frame->with_ctx); + + /* If first table set has no non-empty table, yield nothing */ + if (!table_record.hdr.table) { + return false; + } - if (!table) { - table = &world->store.root; - } - if (!prev_table) { - prev_table = &world->store.root; + frame->row = 0; + frame->column = table_record.column; + table_reg_set(rule, regs, r, (frame->table = table_record.hdr.table)); + goto yield; } - static int obs_count = 0; - obs_count ++; - - /* Populate the column for the term that triggered. This will allow the - * matching algorithm to pick the right column in case the term is a - * wildcard matching multiple columns. */ - user_it.columns[0] = 0; - user_it.columns[pivot_term] = it->columns[0]; + do { + sp = op_ctx->sp; + frame = &op_ctx->stack[sp]; + table = frame->table; + row = frame->row; - if (flecs_filter_match_table(world, &o->filter, table, - user_it.ids, user_it.columns, user_it.subjects, NULL, NULL, false, -1)) - { - /* Monitor observers only trigger when the filter matches for the first - * time with an entity */ - if (o->is_monitor) { - if (flecs_filter_match_table(world, &o->filter, prev_table, - NULL, NULL, NULL, NULL, NULL, true, -1)) - { - goto done; - } + /* If row exceeds number of elements in table, find next table in frame that + * still has entities */ + while ((sp >= 0) && (row >= ecs_table_count(table))) { + table_record = find_next_table(&filter, &frame->with_ctx); - if (term->oper == EcsNot) { - /* Flip event if this is a Not, so OnAdd and OnRemove can be - * reliably used to check if we're entering or leaving the - * monitor */ - if (it->event == EcsOnAdd) { - user_it.event = EcsOnRemove; - } else if (it->event == EcsOnRemove) { - user_it.event = EcsOnAdd; + if (table_record.hdr.table) { + table = frame->table = table_record.hdr.table; + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + frame->row = 0; + frame->column = table_record.column; + table_reg_set(rule, regs, r, table); + goto yield; + } else { + sp = -- op_ctx->sp; + if (sp < 0) { + /* If none of the frames yielded anything, no more data */ + return false; } + frame = &op_ctx->stack[sp]; + table = frame->table; + idr = frame->with_ctx.idr; + row = ++ frame->row; + + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(idr != NULL, ECS_INTERNAL_ERROR, NULL); } } - flecs_iter_populate_data(world, &user_it, - it->table, it->offset, it->count, user_it.ptrs, user_it.sizes); + int32_t row_count = ecs_table_count(table); - user_it.ids[it->term_index] = it->event_id; - user_it.system = o->entity; - user_it.term_index = it->term_index; - user_it.self = o->self; - user_it.ctx = o->ctx; - user_it.term_count = o->filter.term_count_actual; + /* Table must have at least row elements */ + ecs_assert(row_count > row, ECS_INTERNAL_ERROR, NULL); - o->callback(&user_it); + ecs_entity_t *entities = ecs_vector_first( + table->storage.entities, ecs_entity_t); + ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_iter_fini(&user_it); - return true; - } + /* The entity used to find the next table set */ + do { + ecs_entity_t e = entities[row]; -done: - ecs_iter_fini(&user_it); - return false; -} + /* Create look_for expression with the resolved entity as object */ + pair.reg_mask &= ~RULE_PAIR_OBJECT; /* turn of bit because it's not a reg */ + pair.obj.ent = e; + filter = pair_to_filter(iter, op, pair); -bool ecs_observer_default_run_action(ecs_iter_t *it) { - return observer_run(it); -} + /* Find table set for expression */ + table = NULL; + idr = find_tables(world, filter.mask); -static -void default_observer_run_callback(ecs_iter_t *it) { - observer_run(it); -} + /* If table set is found, find first non-empty table */ + if (idr) { + ecs_rule_subset_frame_t *new_frame = &op_ctx->stack[sp + 1]; + new_frame->with_ctx.idr = idr; + flecs_table_cache_iter(&idr->cache, &new_frame->with_ctx.it); + table_record = find_next_table(&filter, &new_frame->with_ctx); -/* For convenience, so applications can (in theory) use a single run callback - * that uses ecs_iter_next to iterate results */ -static -bool default_observer_next_callback(ecs_iter_t *it) { - if (it->interrupted_by) { - return false; - } else { - it->interrupted_by = it->system; - return true; - } -} + /* If set contains non-empty table, push it to stack */ + if (table_record.hdr.table) { + table = table_record.hdr.table; + op_ctx->sp ++; + new_frame->table = table; + new_frame->row = 0; + new_frame->column = table_record.column; + frame = new_frame; + } + } -static -void observer_run_callback(ecs_iter_t *it) { - ecs_observer_t *o = it->ctx; - ecs_run_action_t run = o->run; + /* If no table was found for the current entity, advance row */ + if (!table) { + row = ++ frame->row; + } + } while (!table && row < row_count); + } while (!table); - if (run) { - it->next = default_observer_next_callback; - it->callback = default_observer_run_callback; - it->interrupted_by = 0; - run(it); - } else { - observer_run(it); - } + table_reg_set(rule, regs, r, table); + +yield: + set_term_vars(rule, regs, op->term, ecs_vector_get(frame->table->type, + ecs_id_t, frame->column)[0]); + + return true; } +/* Select operation. The select operation finds and iterates a table set that + * corresponds to its pair expression. */ static -void observer_yield_existing( - ecs_world_t *world, - ecs_observer_t *observer) +bool eval_select( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - ecs_run_action_t run = observer->run; - if (!run) { - run = default_observer_run_callback; - } + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_world_t *world = rule->world; + ecs_rule_with_ctx_t *op_ctx = &iter->op_ctx[op_index].is.with; + ecs_table_record_t table_record; + ecs_rule_reg_t *regs = get_registers(iter, op); - int32_t pivot_term = ecs_filter_pivot_term(world, &observer->filter); - if (pivot_term < 0) { - return; - } + /* Get register indices for output */ + int32_t r = op->r_out; + ecs_assert(r != UINT8_MAX, ECS_INTERNAL_ERROR, NULL); - /* If yield existing is enabled, trigger for each thing that matches - * the event, if the event is iterable. */ - int i, count = observer->event_count; - for (i = 0; i < count; i ++) { - ecs_entity_t evt = observer->events[i]; - const EcsIterable *iterable = ecs_get(world, evt, EcsIterable); - if (!iterable) { - continue; - } + /* Get queried for id, fill out potential variables */ + ecs_rule_pair_t pair = op->filter; + ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); + ecs_entity_t pattern = filter.mask; + int32_t *columns = rule_get_columns(iter, op); - ecs_iter_t it; - iterable->init(world, world, &it, &observer->filter.terms[pivot_term]); - it.terms = observer->filter.terms; - it.term_count = 1; - it.term_index = pivot_term; - it.system = observer->entity; - it.ctx = observer; - it.binding_ctx = observer->binding_ctx; - it.event = evt; + int32_t column = -1; + ecs_table_t *table = NULL; + ecs_id_record_t *idr; - ecs_iter_next_action_t next = it.next; - ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL); - while (next(&it)) { - run(&it); - world->event_id ++; - } + if (!redo && op->term != -1) { + columns[op->term] = -1; } -} -ecs_entity_t ecs_observer_init( - ecs_world_t *world, - const ecs_observer_desc_t *desc) -{ - ecs_entity_t entity = 0; - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); - ecs_check(desc->callback != NULL || desc->run != NULL, - ECS_INVALID_OPERATION, NULL); + /* If this is a redo, we already looked up the table set */ + if (redo) { + idr = op_ctx->idr; + + /* If this is not a redo lookup the table set. Even though this may not be + * the first time the operation is evaluated, variables may have changed + * since last time, which could change the table set to lookup. */ + } else { + /* A table set is a set of tables that all contain at least the + * requested look_for expression. What is returned is a table record, + * which in addition to the table also stores the first occurrance at + * which the requested expression occurs in the table. This reduces (and + * in most cases eliminates) any searching that needs to occur in a + * table type. Tables are also registered under wildcards, which is why + * this operation can simply use the look_for variable directly */ - /* If entity is provided, create it */ - ecs_entity_t existing = desc->entity.entity; - entity = ecs_entity_init(world, &desc->entity); - if (!existing && !desc->entity.name) { - ecs_add_pair(world, entity, EcsChildOf, EcsFlecsHidden); + idr = op_ctx->idr = find_tables(world, pattern); } - bool added = false; - EcsObserver *comp = ecs_get_mut(world, entity, EcsObserver, &added); - if (added) { - ecs_observer_t *observer = flecs_sparse_add( - world->observers, ecs_observer_t); - ecs_assert(observer != NULL, ECS_INTERNAL_ERROR, NULL); - observer->id = flecs_sparse_last_id(world->observers); - comp->observer = observer; - - /* Make writeable copy of filter desc so that we can set name. This will - * make debugging easier, as any error messages related to creating the - * filter will have the name of the observer. */ - ecs_filter_desc_t filter_desc = desc->filter; - filter_desc.name = desc->entity.name; - - /* Parse filter */ - ecs_filter_t *filter = &observer->filter; - if (ecs_filter_init(world, filter, &filter_desc)) { - flecs_observer_fini(world, observer); - return 0; - } - - /* Creating an observer with no terms has no effect */ - ecs_assert(observer->filter.term_count != 0, - ECS_INVALID_PARAMETER, NULL); + /* If no table set was found for queried for entity, there are no results */ + if (!idr) { + return false; + } - int i, e; - for (i = 0; i < ECS_TRIGGER_DESC_EVENT_COUNT_MAX; i ++) { - ecs_entity_t event = desc->events[i]; - if (!event) { - break; - } + /* If the input register is not NULL, this is a variable that's been set by + * the application. */ + table = iter->registers[r].table.table; + bool output_is_input = table != NULL; - if (event == EcsMonitor) { - /* Monitor event must be first and last event */ - ecs_check(i == 0, ECS_INVALID_PARAMETER, NULL); + if (output_is_input && !redo) { + ecs_assert(regs[r].table.table == iter->registers[r].table.table, + ECS_INTERNAL_ERROR, NULL); - observer->events[0] = EcsOnAdd; - observer->events[1] = EcsOnRemove; - observer->event_count ++; - observer->is_monitor = true; - } else { - observer->events[i] = event; - } + table = iter->registers[r].table.table; - observer->event_count ++; + /* Check if table can be found in the id record. If not, the provided + * table does not match with the query. */ + ecs_table_record_t *tr = ecs_table_cache_get(&idr->cache, table); + if (!tr) { + return false; } - /* Observer must have at least one event */ - ecs_check(observer->event_count != 0, ECS_INVALID_PARAMETER, NULL); + column = op_ctx->column = tr->column; + } - observer->callback = desc->callback; - observer->run = desc->run; - observer->self = desc->self; - observer->ctx = desc->ctx; - observer->binding_ctx = desc->binding_ctx; - observer->ctx_free = desc->ctx_free; - observer->binding_ctx_free = desc->binding_ctx_free; - observer->entity = entity; - comp->observer = observer; + /* If this is not a redo, start at the beginning */ + if (!redo) { + if (!table) { + flecs_table_cache_iter(&idr->cache, &op_ctx->it); - /* Create a trigger for each term in the filter */ - ecs_trigger_desc_t tdesc = { - .callback = observer_run_callback, - .ctx = observer, - .binding_ctx = desc->binding_ctx, - .match_prefab = observer->filter.match_prefab, - .match_disabled = observer->filter.match_disabled, - .last_event_id = &observer->last_event_id - }; + /* Return the first table_record in the table set. */ + table_record = find_next_table(&filter, op_ctx); + + /* If no table record was found, there are no results. */ + if (!table_record.hdr.table) { + return false; + } - for (i = 0; i < filter->term_count; i ++) { - tdesc.term = filter->terms[i]; - ecs_oper_kind_t oper = tdesc.term.oper; - ecs_id_t id = tdesc.term.id; + table = table_record.hdr.table; - bool is_tag = ecs_id_is_tag(world, id); + /* Set current column to first occurrence of queried for entity */ + column = op_ctx->column = table_record.column; - if (is_tag) { - /* If id is a tag, convert OnSet/UnSet to OnAdd/OnRemove. This - * allows for creating OnSet observers with both components and - * tags that only fire when the entity has all ids */ - for (e = 0; e < observer->event_count; e ++) { - if (observer->events[e] == EcsOnSet) { - tdesc.events[e] = EcsOnAdd; - } else - if (observer->events[e] == EcsUnSet) { - tdesc.events[e] = EcsOnRemove; - } else { - tdesc.events[e] = observer->events[e]; - } - } - } else { - ecs_os_memcpy_n(tdesc.events, observer->events, ecs_entity_t, - observer->event_count); - } + /* Store table in register */ + table_reg_set(rule, regs, r, table); + } + + /* If this is a redo, progress to the next match */ + } else { + /* First test if there are any more matches for the current table, in + * case we're looking for a wildcard. */ + if (filter.wildcard) { + table = table_reg_get(rule, regs, r).table; + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - /* AndFrom & OrFrom terms insert multiple triggers */ - if (oper == EcsAndFrom || oper == EcsOrFrom) { - const EcsType *type = ecs_get(world, id, EcsType); - int32_t ti, ti_count = ecs_vector_count(type->normalized->type); - ecs_id_t *ti_ids = ecs_vector_first( - type->normalized->type, ecs_id_t); + column = op_ctx->column; + column = find_next_column(world, table, column, &filter); + op_ctx->column = column; + } - /* Correct operator will be applied when a trigger occurs, and - * the observer is evaluated on the trigger source */ - tdesc.term.oper = EcsAnd; - for (ti = 0; ti < ti_count; ti ++) { - tdesc.term.pred.name = NULL; - tdesc.term.pred.entity = ti_ids[ti]; - tdesc.term.id = ti_ids[ti]; - ecs_entity_t t = ecs_vector_add(&observer->triggers, - ecs_entity_t)[0] = ecs_trigger_init(world, &tdesc); - if (!t) { - goto error; - } - } - continue; + /* If no next match was found for this table, move to next table */ + if (column == -1) { + if (output_is_input) { + return false; } - ecs_entity_t t = ecs_vector_add(&observer->triggers, ecs_entity_t) - [0] = ecs_trigger_init(world, &tdesc); - if (!t) { - goto error; + table_record = find_next_table(&filter, op_ctx); + if (!table_record.hdr.table) { + return false; } - } - if (desc->entity.name) { - ecs_trace("#[green]observer#[reset] %s created", - ecs_get_name(world, entity)); - } + /* Assign new table to table register */ + table_reg_set(rule, regs, r, (table = table_record.hdr.table)); - if (desc->yield_existing) { - observer_yield_existing(world, observer); + /* Assign first matching column */ + column = op_ctx->column = table_record.column; } - } else { - ecs_assert(comp->observer != NULL, ECS_INTERNAL_ERROR, NULL); + } - /* If existing entity handle was provided, override existing params */ - if (existing) { - if (desc->callback) { - ((ecs_observer_t*)comp->observer)->callback = desc->callback; - } - if (desc->ctx) { - ((ecs_observer_t*)comp->observer)->ctx = desc->ctx; - } - if (desc->binding_ctx) { - ((ecs_observer_t*)comp->observer)->binding_ctx = - desc->binding_ctx; - } - } + /* If we got here, we found a match. Table and column must be set */ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL); + + if (op->term != -1) { + columns[op->term] = column; } - return entity; -error: - if (entity) { - ecs_delete(world, entity); + /* If this is a wildcard query, fill out the variable registers */ + if (filter.wildcard) { + reify_variables(iter, op, &filter, table->type, column); } - return 0; + + return true; } -void flecs_observer_fini( - ecs_world_t *world, - ecs_observer_t *observer) +/* With operation. The With operation always comes after either the Select or + * another With operation, and applies additional filters to the table. */ +static +bool eval_with( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - /* Cleanup triggers */ - int i, count = ecs_vector_count(observer->triggers); - ecs_entity_t *triggers = ecs_vector_first(observer->triggers, ecs_entity_t); - for (i = 0; i < count; i ++) { - ecs_entity_t t = triggers[i]; - if (!t) continue; - ecs_delete(world, triggers[i]); - } - ecs_vector_free(observer->triggers); + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_world_t *world = rule->world; + ecs_rule_with_ctx_t *op_ctx = &iter->op_ctx[op_index].is.with; + ecs_rule_reg_t *regs = get_registers(iter, op); - /* Cleanup filters */ - ecs_filter_fini(&observer->filter); + /* Get register indices for input */ + int32_t r = op->r_in; - /* Cleanup context */ - if (observer->ctx_free) { - observer->ctx_free(observer->ctx); - } + /* Get queried for id, fill out potential variables */ + ecs_rule_pair_t pair = op->filter; + ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); + int32_t *columns = rule_get_columns(iter, op); - if (observer->binding_ctx_free) { - observer->binding_ctx_free(observer->binding_ctx); + /* If looked for entity is not a wildcard (meaning there are no unknown/ + * unconstrained variables) and this is a redo, nothing more to yield. */ + if (redo && !filter.wildcard) { + return false; } - /* Cleanup observer storage */ - flecs_sparse_remove(world->observers, observer->id); -} + int32_t column = -1; + ecs_table_t *table = NULL; + ecs_id_record_t *idr; -void* ecs_get_observer_ctx( - const ecs_world_t *world, - ecs_entity_t observer) -{ - const EcsObserver *o = ecs_get(world, observer, EcsObserver); - if (o) { - return o->observer->ctx; - } else { - return NULL; - } -} + if (op->term != -1) { + columns[op->term] = -1; + } -void* ecs_get_observer_binding_ctx( - const ecs_world_t *world, - ecs_entity_t observer) -{ - const EcsObserver *o = ecs_get(world, observer, EcsObserver); - if (o) { - return o->observer->binding_ctx; + /* If this is a redo, we already looked up the table set */ + if (redo) { + idr = op_ctx->idr; + + /* If this is not a redo lookup the table set. Even though this may not be + * the first time the operation is evaluated, variables may have changed + * since last time, which could change the table set to lookup. */ } else { - return NULL; - } -} + /* Predicates can be reflexive, which means that if we have a + * transitive predicate which is provided with the same subject and + * object, it should return true. By default with will not return true + * as the subject likely does not have itself as a relationship, which + * is why this is a special case. + * + * TODO: might want to move this code to a separate with_reflexive + * instruction to limit branches for non-transitive queries (and to keep + * code more readable). + */ + if (pair.transitive && pair.reflexive) { + ecs_entity_t subj = 0, obj = 0; + + if (r == UINT8_MAX) { + subj = op->subject; + } else { + const ecs_rule_var_t *v_subj = &rule->vars[r]; + if (v_subj->kind == EcsRuleVarKindEntity) { + subj = entity_reg_get(rule, regs, r); -static -void table_cache_list_remove( - ecs_table_cache_t *cache, - ecs_table_cache_hdr_t *elem) -{ - ecs_table_cache_hdr_t *next = elem->next; - ecs_table_cache_hdr_t *prev = elem->prev; + /* This is the input for the op, so should always be set */ + ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL); + } + } - if (next) { - next->prev = prev; - } - if (prev) { - prev->next = next; + /* If subj is set, it means that it is an entity. Try to also + * resolve the object. */ + if (subj) { + /* If the object is not a wildcard, it has been reified. Get the + * value from either the register or as a literal */ + if (!filter.obj_wildcard) { + obj = ecs_entity_t_lo(filter.mask); + if (subj == obj) { + return true; + } + } + } + } + + /* The With operation finds the table set that belongs to its pair + * filter. The table set is a sparse set that provides an O(1) operation + * to check whether the current table has the required expression. */ + idr = op_ctx->idr = find_tables(world, filter.mask); } - cache->empty_tables.count -= !!elem->empty; - cache->tables.count -= !elem->empty; + /* If no table set was found for queried for entity, there are no results. + * If this result is a transitive query, the table we're evaluating may not + * be in the returned table set. Regardless, if the filter that contains a + * transitive predicate does not have any tables associated with it, there + * can be no transitive matches for the filter. */ + if (!idr) { + return false; + } - if (cache->empty_tables.first == elem) { - cache->empty_tables.first = next; - } else if (cache->tables.first == elem) { - cache->tables.first = next; + table = reg_get_table(rule, op, regs, r).table; + if (!table) { + return false; } - if (cache->empty_tables.last == elem) { - cache->empty_tables.last = prev; + + /* If this is not a redo, start at the beginning */ + if (!redo) { + column = op_ctx->column = find_next_column(world, table, -1, &filter); + + /* If this is a redo, progress to the next match */ + } else { + if (!filter.wildcard) { + return false; + } + + /* Find the next match for the expression in the column. The columns + * array keeps track of the state for each With operation, so that + * even after redoing a With, the search doesn't have to start from + * the beginning. */ + column = find_next_column(world, table, op_ctx->column, &filter); + op_ctx->column = column; } - if (cache->tables.last == elem) { - cache->tables.last = prev; + + /* If no next match was found for this table, no more data */ + if (column == -1) { + return false; } -} -static -void table_cache_list_insert( - ecs_table_cache_t *cache, - ecs_table_cache_hdr_t *elem) -{ - ecs_table_cache_hdr_t *last; - if (elem->empty) { - last = cache->empty_tables.last; - cache->empty_tables.last = elem; - if ((++ cache->empty_tables.count) == 1) { - cache->empty_tables.first = elem; - } - } else { - last = cache->tables.last; - cache->tables.last = elem; - if ((++ cache->tables.count) == 1) { - cache->tables.first = elem; - } + if (op->term != -1) { + columns[op->term] = column; } - elem->next = NULL; - elem->prev = last; + /* If we got here, we found a match. Table and column must be set */ + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(column != -1, ECS_INTERNAL_ERROR, NULL); - if (last) { - last->next = elem; + /* If this is a wildcard query, fill out the variable registers */ + if (filter.wildcard) { + reify_variables(iter, op, &filter, table->type, column); } -} -void ecs_table_cache_init( - ecs_table_cache_t *cache) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_map_init(&cache->index, ecs_table_cache_hdr_t*, 0); -} + set_source(it, op, regs, r); -void ecs_table_cache_fini( - ecs_table_cache_t *cache) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_map_fini(&cache->index); + return true; } -bool ecs_table_cache_is_empty( - const ecs_table_cache_t *cache) +/* Each operation. The each operation is a simple operation that takes a table + * as input, and outputs each of the entities in a table. This operation is + * useful for rules that match a table, and where the entities of the table are + * used as predicate or object. If a rule contains an each operation, an + * iterator is guaranteed to yield an entity instead of a table. The input for + * an each operation can only be the root variable. */ +static +bool eval_each( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - return ecs_map_count(&cache->index) == 0; -} + ecs_rule_iter_t *iter = &it->priv.iter.rule; + ecs_rule_each_ctx_t *op_ctx = &iter->op_ctx[op_index].is.each; + ecs_rule_reg_t *regs = get_registers(iter, op); + int32_t r_in = op->r_in; + int32_t r_out = op->r_out; + ecs_entity_t e; -void ecs_table_cache_insert( - ecs_table_cache_t *cache, - const ecs_table_t *table, - ecs_table_cache_hdr_t *result) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!table || (ecs_table_cache_get(cache, table) == NULL), + /* Make sure in/out registers are of the correct kind */ + ecs_assert(iter->rule->vars[r_in].kind == EcsRuleVarKindTable, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(iter->rule->vars[r_out].kind == EcsRuleVarKindEntity, ECS_INTERNAL_ERROR, NULL); - ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); - bool empty; - if (!table) { - empty = false; - } else { - empty = ecs_table_count(table) == 0; - } + /* Get table, make sure that it contains data. The select operation should + * ensure that empty tables are never forwarded. */ + ecs_table_slice_t slice = table_reg_get(iter->rule, regs, r_in); + ecs_table_t *table = slice.table; + if (table) { + int32_t row, count = slice.count; + int32_t offset = slice.offset; - result->cache = cache; - result->table = (ecs_table_t*)table; - result->empty = empty; + if (!count) { + count = ecs_table_count(table); + ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL); + } else { + count += offset; + } - table_cache_list_insert(cache, result); + ecs_entity_t *entities = ecs_vector_first( + table->storage.entities, ecs_entity_t); + ecs_assert(entities != NULL, ECS_INTERNAL_ERROR, NULL); - if (table) { - ecs_map_set_ptr(&cache->index, table->id, result); + /* If this is is not a redo, start from row 0, otherwise go to the + * next entity. */ + if (!redo) { + row = op_ctx->row = offset; + } else { + row = ++ op_ctx->row; + } + + /* If row exceeds number of entities in table, return false */ + if (row >= count) { + return false; + } + + /* Skip builtin entities that could confuse operations */ + e = entities[row]; + while (e == EcsWildcard || e == EcsThis || e == EcsAny) { + row ++; + if (row == count) { + return false; + } + e = entities[row]; + } + } else { + if (!redo) { + e = entity_reg_get(iter->rule, regs, r_in); + } else { + return false; + } } - ecs_assert(empty || cache->tables.first != NULL, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!empty || cache->empty_tables.first != NULL, - ECS_INTERNAL_ERROR, NULL); -} + /* Assign entity */ + entity_reg_set(iter->rule, regs, r_out, e); -void* ecs_table_cache_get( - const ecs_table_cache_t *cache, - const ecs_table_t *table) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - return ecs_map_get_ptr(&cache->index, ecs_table_cache_hdr_t*, table->id); + return true; } -void* ecs_table_cache_remove( - ecs_table_cache_t *cache, - const ecs_table_t *table, - ecs_table_cache_hdr_t *elem) +/* Store operation. Stores entity in register. This can either be an entity + * literal or an entity variable that will be stored in a table register. The + * latter facilitates scenarios where an iterator only need to return a single + * entity but where the Yield returns tables. */ +static +bool eval_store( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + (void)op_index; - if (!ecs_map_is_initialized(&cache->index)) { - return NULL; + if (redo) { + /* Only ever return result once */ + return false; } - if (!elem) { - elem = ecs_map_get_ptr( - &cache->index, ecs_table_cache_hdr_t*, table->id); - if (!elem) { - return false; - } - } + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_rule_reg_t *regs = get_registers(iter, op); + int32_t r_in = op->r_in; + int32_t r_out = op->r_out; - ecs_assert(elem != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(elem->cache == cache, ECS_INTERNAL_ERROR, NULL); - ecs_assert(elem->table == table, ECS_INTERNAL_ERROR, NULL); + const ecs_rule_var_t *var_out = &rule->vars[r_out]; + if (var_out->kind == EcsRuleVarKindEntity) { + ecs_entity_t out, in = reg_get_entity(rule, op, regs, r_in); - table_cache_list_remove(cache, elem); + out = iter->registers[r_out].entity; + bool output_is_input = out && out != EcsWildcard; - ecs_map_remove(&cache->index, table->id); + if (output_is_input && !redo) { + ecs_assert(regs[r_out].entity == iter->registers[r_out].entity, + ECS_INTERNAL_ERROR, NULL); - return elem; -} + if (out != in) { + /* If output variable is set it must match the input */ + return false; + } + } -bool ecs_table_cache_set_empty( - ecs_table_cache_t *cache, - const ecs_table_t *table, - bool empty) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + reg_set_entity(rule, regs, r_out, in); + } else { + ecs_table_slice_t out, in = reg_get_table(rule, op, regs, r_in); - ecs_table_cache_hdr_t *elem = ecs_map_get_ptr( - &cache->index, ecs_table_cache_hdr_t*, table->id); - if (!elem) { - return false; - } + out = iter->registers[r_out].table; + bool output_is_input = out.table != NULL; - if (elem->empty == empty) { - return false; - } + if (output_is_input && !redo) { + ecs_assert(regs[r_out].entity == iter->registers[r_out].entity, + ECS_INTERNAL_ERROR, NULL); - table_cache_list_remove(cache, elem); - elem->empty = empty; - table_cache_list_insert(cache, elem); + if (ecs_os_memcmp_t(&out, &in, ecs_table_slice_t)) { + /* If output variable is set it must match the input */ + return false; + } + } - return true; -} + reg_set_table(rule, regs, r_out, in); -void ecs_table_cache_fini_delete_all( - ecs_world_t *world, - ecs_table_cache_t *cache) -{ - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - if (!ecs_map_is_initialized(&cache->index)) { - return; + /* Ensure that if the input was an empty entity, information is not + * lost */ + if (!regs[r_out].table.table) { + regs[r_out].entity = reg_get_entity(rule, op, regs, r_in); + } } - /* Temporarily set index to NULL, so that when the table tries to remove - * itself from the cache it won't be able to. This keeps the arrays we're - * iterating over consistent */ - ecs_map_t index = cache->index; - ecs_os_zeromem(&cache->index); - - ecs_table_cache_hdr_t *cur, *next = cache->tables.first; - while ((cur = next)) { - flecs_delete_table(world, cur->table); - next = cur->next; - } + ecs_rule_filter_t filter = pair_to_filter(iter, op, op->filter); + set_term_vars(rule, regs, op->term, filter.mask); - next = cache->empty_tables.first; - while ((cur = next)) { - flecs_delete_table(world, cur->table); - next = cur->next; - } + return true; +} - cache->index = index; +/* A setjmp operation sets the jump label for a subsequent jump label. When the + * operation is first evaluated (redo=false) it sets the label to the on_pass + * label, and returns true. When the operation is evaluated again (redo=true) + * the label is set to on_fail and the operation returns false. */ +static +bool eval_setjmp( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) +{ + ecs_rule_iter_t *iter = &it->priv.iter.rule; + ecs_rule_setjmp_ctx_t *ctx = &iter->op_ctx[op_index].is.setjmp; - ecs_table_cache_fini(cache); + if (!redo) { + ctx->label = op->on_pass; + return true; + } else { + ctx->label = op->on_fail; + return false; + } } -bool flecs_table_cache_iter( - ecs_table_cache_t *cache, - ecs_table_cache_iter_t *out) +/* The jump operation jumps to an operation label. The operation always returns + * true. Since the operation modifies the control flow of the program directly, + * the dispatcher does not look at the on_pass or on_fail labels of the jump + * instruction. Instead, the on_pass label is used to store the label of the + * operation that contains the label to jump to. */ +static +bool eval_jump( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); - out->next = cache->tables.first; - out->cur = NULL; - return out->next != NULL; + (void)it; + (void)op; + (void)op_index; + + /* Passthrough, result is not used for control flow */ + return !redo; } -bool flecs_table_cache_empty_iter( - ecs_table_cache_t *cache, - ecs_table_cache_iter_t *out) +/* The not operation reverts the result of the operation it embeds */ +static +bool eval_not( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - ecs_assert(cache != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(out != NULL, ECS_INTERNAL_ERROR, NULL); - out->next = cache->empty_tables.first; - out->cur = NULL; - return out->next != NULL; + (void)it; + (void)op; + (void)op_index; + + return !redo; } -ecs_table_cache_hdr_t* _flecs_table_cache_next( - ecs_table_cache_iter_t *it) +/* Check if entity is stored in table */ +static +bool eval_intable( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - ecs_table_cache_hdr_t *next = it->next; - if (!next) { + (void)op_index; + + if (redo) { return false; } - it->cur = next; - it->next = next->next; - return next; -} - -#include -#include + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + ecs_world_t *world = rule->world; + ecs_rule_reg_t *regs = get_registers(iter, op); + ecs_table_t *table = table_reg_get(rule, regs, op->r_in).table; -void ecs_os_api_impl(ecs_os_api_t *api); + ecs_rule_pair_t pair = op->filter; + ecs_rule_filter_t filter = pair_to_filter(iter, op, pair); + ecs_entity_t obj = ECS_PAIR_SECOND(filter.mask); + ecs_assert(obj != 0 && obj != EcsWildcard, ECS_INTERNAL_ERROR, NULL); + obj = ecs_get_alive(world, obj); + ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); -static bool ecs_os_api_initialized = false; -static bool ecs_os_api_initializing = false; -static int ecs_os_api_init_count = 0; + ecs_table_t *obj_table = ecs_get_table(world, obj); + return obj_table == table; +} -#ifndef __EMSCRIPTEN__ -ecs_os_api_t ecs_os_api = { - .log_with_color_ = true, - .log_level_ = -1 /* disable tracing by default, but enable >= warnings */ -}; -#else -/* Disable colors by default for emscripten */ -ecs_os_api_t ecs_os_api = { - .log_level_ = -1 -}; -#endif +/* Yield operation. This is the simplest operation, as all it does is return + * false. This will move the solver back to the previous instruction which + * forces redo's on previous operations, for as long as there are matching + * results. */ +static +bool eval_yield( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) +{ + (void)it; + (void)op; + (void)op_index; + (void)redo; -int64_t ecs_os_api_malloc_count = 0; -int64_t ecs_os_api_realloc_count = 0; -int64_t ecs_os_api_calloc_count = 0; -int64_t ecs_os_api_free_count = 0; + /* Yield always returns false, because there are never any operations after + * a yield. */ + return false; +} -void ecs_os_set_api( - ecs_os_api_t *os_api) +/* Dispatcher for operations */ +static +bool eval_op( + ecs_iter_t *it, + ecs_rule_op_t *op, + int32_t op_index, + bool redo) { - if (!ecs_os_api_initialized) { - ecs_os_api = *os_api; - ecs_os_api_initialized = true; + switch(op->kind) { + case EcsRuleInput: + return eval_input(it, op, op_index, redo); + case EcsRuleSelect: + return eval_select(it, op, op_index, redo); + case EcsRuleWith: + return eval_with(it, op, op_index, redo); + case EcsRuleSubSet: + return eval_subset(it, op, op_index, redo); + case EcsRuleSuperSet: + return eval_superset(it, op, op_index, redo); + case EcsRuleEach: + return eval_each(it, op, op_index, redo); + case EcsRuleStore: + return eval_store(it, op, op_index, redo); + case EcsRuleSetJmp: + return eval_setjmp(it, op, op_index, redo); + case EcsRuleJump: + return eval_jump(it, op, op_index, redo); + case EcsRuleNot: + return eval_not(it, op, op_index, redo); + case EcsRuleInTable: + return eval_intable(it, op, op_index, redo); + case EcsRuleYield: + return eval_yield(it, op, op_index, redo); + default: + return false; } } -void ecs_os_init(void) +/* Utility to copy all registers to the next frame. Keeping track of register + * values for each operation is necessary, because if an operation is asked to + * redo matching, it must to be able to pick up from where it left of */ +static +void push_registers( + ecs_rule_iter_t *it, + int32_t cur, + int32_t next) { - if (!ecs_os_api_initialized) { - ecs_os_set_api_defaults(); - } - - if (!(ecs_os_api_init_count ++)) { - if (ecs_os_api.init_) { - ecs_os_api.init_(); - } + if (!it->rule->var_count) { + return; } -} -void ecs_os_fini(void) { - if (!--ecs_os_api_init_count) { - if (ecs_os_api.fini_) { - ecs_os_api.fini_(); - } - } + ecs_rule_reg_t *src_regs = get_register_frame(it, cur); + ecs_rule_reg_t *dst_regs = get_register_frame(it, next); + + ecs_os_memcpy_n(dst_regs, src_regs, + ecs_rule_reg_t, it->rule->var_count); } -#if !defined(ECS_TARGET_WINDOWS) && !defined(ECS_TARGET_EM) && !defined(ECS_TARGET_ANDROID) -#include -#define ECS_BT_BUF_SIZE 100 +/* Utility to copy all columns to the next frame. Columns keep track of which + * columns are currently being evaluated for a table, and are populated by the + * Select and With operations. The columns array is important, as it is used + * to tell the application where to find component data. */ static -void dump_backtrace( - FILE *stream) +void push_columns( + ecs_rule_iter_t *it, + int32_t cur, + int32_t next) { - int nptrs; - void *buffer[ECS_BT_BUF_SIZE]; - char **strings; - - nptrs = backtrace(buffer, ECS_BT_BUF_SIZE); - - strings = backtrace_symbols(buffer, nptrs); - if (strings == NULL) { + if (!it->rule->filter.term_count) { return; } - for (int j = 3; j < nptrs; j++) { - fprintf(stream, "%s\n", strings[j]); - } + int32_t *src_cols = rule_get_columns_frame(it, cur); + int32_t *dst_cols = rule_get_columns_frame(it, next); - free(strings); -} -#else -static -void dump_backtrace( - FILE *stream) -{ - (void)stream; + ecs_os_memcpy_n(dst_cols, src_cols, int32_t, it->rule->filter.term_count); } -#endif +/* Populate iterator with data before yielding to application */ static -void log_msg( - int32_t level, - const char *file, - int32_t line, - const char *msg) +void populate_iterator( + const ecs_rule_t *rule, + ecs_iter_t *iter, + ecs_rule_iter_t *it, + ecs_rule_op_t *op) { - FILE *stream; - if (level >= 0) { - stream = stdout; - } else { - stream = stderr; - } + ecs_world_t *world = rule->world; + int32_t r = op->r_in; + ecs_rule_reg_t *regs = get_register_frame(it, op->frame); + ecs_table_t *table = NULL; + int32_t count = 0; + int32_t offset = 0; - if (level >= 0) { - if (level == 0) { - if (ecs_os_api.log_with_color_) fputs(ECS_MAGENTA, stream); + /* If the input register for the yield does not point to a variable, + * the rule doesn't contain a this (.) variable. In that case, the + * iterator doesn't contain any data, and this function will simply + * return true or false. An application will still be able to obtain + * the variables that were resolved. */ + if (r != UINT8_MAX) { + const ecs_rule_var_t *var = &rule->vars[r]; + ecs_rule_reg_t *reg = ®s[r]; + + if (var->kind == EcsRuleVarKindTable) { + ecs_table_slice_t slice = table_reg_get(rule, regs, r); + table = slice.table; + count = slice.count; + offset = slice.offset; } else { - if (ecs_os_api.log_with_color_) fputs(ECS_GREY, stream); + /* If a single entity is returned, simply return the + * iterator with count 1 and a pointer to the entity id */ + ecs_assert(var->kind == EcsRuleVarKindEntity, + ECS_INTERNAL_ERROR, NULL); + + ecs_entity_t e = reg->entity; + ecs_record_t *record = ecs_eis_get(world, e); + offset = ECS_RECORD_TO_ROW(record->row); + + /* If an entity is not stored in a table, it could not have + * been matched by anything */ + ecs_assert(record != NULL, ECS_INTERNAL_ERROR, NULL); + table = record->table; + count = 1; } - fputs("info", stream); - } else if (level == -2) { - if (ecs_os_api.log_with_color_) fputs(ECS_YELLOW, stream); - fputs("warning", stream); - } else if (level == -3) { - if (ecs_os_api.log_with_color_) fputs(ECS_RED, stream); - fputs("error", stream); - } else if (level == -4) { - if (ecs_os_api.log_with_color_) fputs(ECS_RED, stream); - fputs("fatal", stream); } - if (ecs_os_api.log_with_color_) fputs(ECS_NORMAL, stream); - fputs(": ", stream); + int32_t i, var_count = rule->var_count; + int32_t term_count = rule->filter.term_count; + iter->variables = it->variables; - if (level >= 0) { - if (ecs_os_api.log_indent_) { - char indent[32]; - int i, indent_count = ecs_os_api.log_indent_; - if (indent_count > 15) indent_count = 15; + for (i = 0; i < var_count; i ++) { + if (rule->vars[i].kind == EcsRuleVarKindEntity) { + it->variables[i] = regs[i].entity; + } else { + it->variables[i] = 0; + } + } - for (i = 0; i < indent_count; i ++) { - indent[i * 2] = '|'; - indent[i * 2 + 1] = ' '; + for (i = 0; i < term_count; i ++) { + int32_t v = rule->term_vars[i].subj; + if (v != -1) { + const ecs_rule_var_t *var = &rule->vars[v]; + if (var->name[0] != '.') { + if (var->kind == EcsRuleVarKindEntity) { + iter->subjects[i] = regs[var->id].entity; + } else { + /* This can happen for Any variables, where the actual + * content of the variable is not of interest to the query. + * Just pick the first entity from the table, so that the + * column can be correctly resolved */ + ecs_table_t *t = regs[var->id].table.table; + if (t) { + iter->subjects[i] = ecs_vector_first( + t->storage.entities, ecs_entity_t)[0]; + } else { + /* Can happen if term is optional */ + iter->subjects[i] = 0; + } + } } + } + } - if (ecs_os_api.log_indent_ != indent_count) { - indent[i * 2 - 2] = '+'; + /* Iterator expects column indices to start at 1 */ + iter->columns = rule_get_columns_frame(it, op->frame); + for (i = 0; i < term_count; i ++) { + ecs_entity_t subj = iter->subjects[i]; + int32_t c = ++ iter->columns[i]; + if (!subj) { + subj = iter->terms[i].subj.entity; + if (subj != EcsThis && subj != EcsAny) { + iter->columns[i] = 0; } - - indent[i * 2] = '\0'; - - fputs(indent, stream); + } else if (c) { + iter->columns[i] = -1; } } - if (level < 0) { - if (file) { - const char *file_ptr = strrchr(file, '/'); - if (!file_ptr) { - file_ptr = strrchr(file, '\\'); + /* Set iterator ids */ + for (i = 0; i < term_count; i ++) { + const ecs_rule_term_vars_t *vars = &rule->term_vars[i]; + ecs_term_t *term = &rule->filter.terms[i]; + if (term->oper == EcsOptional || term->oper == EcsNot) { + if (iter->columns[i] == 0) { + iter->ids[i] = term->id; + continue; } + } - if (file_ptr) { - file = file_ptr + 1; - } + ecs_id_t id = term->id; + ecs_entity_t pred = 0; + ecs_entity_t obj = 0; + bool is_pair = ECS_HAS_ROLE(id, PAIR); - fputs(file, stream); - fputs(": ", stream); + if (!is_pair) { + pred = id; + } else { + pred = ECS_PAIR_FIRST(id); + obj = ECS_PAIR_SECOND(id); } - if (line) { - fprintf(stream, "%d: ", line); + if (vars->pred != -1) { + pred = regs[vars->pred].entity; + } + if (vars->obj != -1) { + ecs_assert(is_pair, ECS_INTERNAL_ERROR, NULL); + obj = regs[vars->obj].entity; } - } - - fputs(msg, stream); - fputs("\n", stream); + if (!is_pair) { + id = pred; + } else { + id = ecs_pair(pred, obj); + } - if (level == -4) { - dump_backtrace(stream); + iter->ids[i] = id; } + + flecs_iter_populate_data(world, iter, table, offset, count, + iter->ptrs, iter->sizes); } -void ecs_os_dbg( - const char *file, - int32_t line, - const char *msg) +static +bool is_control_flow( + ecs_rule_op_t *op) { - if (ecs_os_api.log_) { - ecs_os_api.log_(1, file, line, msg); + switch(op->kind) { + case EcsRuleSetJmp: + case EcsRuleJump: + return true; + default: + return false; } } -void ecs_os_trace( - const char *file, - int32_t line, - const char *msg) +bool ecs_rule_next( + ecs_iter_t *it) { - if (ecs_os_api.log_) { - ecs_os_api.log_(0, file, line, msg); + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL); + + if (flecs_iter_next_row(it)) { + return true; } + + return flecs_iter_next_instanced(it, ecs_rule_next_instanced(it)); +error: + return false; } -void ecs_os_warn( - const char *file, - int32_t line, - const char *msg) -{ - if (ecs_os_api.log_) { - ecs_os_api.log_(-2, file, line, msg); - } -} +/* Iterator next function. This evaluates the program until it reaches a Yield + * operation, and returns the intermediate result(s) to the application. An + * iterator can, depending on the program, either return a table, entity, or + * just true/false, in case a rule doesn't contain the this variable. */ +bool ecs_rule_next_instanced( + ecs_iter_t *it) +{ + ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(it->next == ecs_rule_next, ECS_INVALID_PARAMETER, NULL); + + ecs_rule_iter_t *iter = &it->priv.iter.rule; + const ecs_rule_t *rule = iter->rule; + bool redo = iter->redo; + int32_t last_frame = -1; + bool init_subjects = it->subjects == NULL; + + /* Can't iterate an iterator that's already depleted */ + ecs_check(iter->op != -1, ECS_INVALID_PARAMETER, NULL); + + flecs_iter_init(it); + + /* Make sure that if there are any terms with literal subjects, they're + * initialized in the subjects array */ + if (init_subjects) { + int32_t i; + for (i = 0; i < rule->filter.term_count; i ++) { + ecs_term_t *t = &rule->filter.terms[i]; + ecs_term_id_t *subj = &t->subj; + ecs_assert(subj->var == EcsVarIsVariable || subj->entity != EcsThis, + ECS_INTERNAL_ERROR, NULL); + + if (subj->var == EcsVarIsEntity) { + it->subjects[i] = subj->entity; + } + } + } + + do { + /* Evaluate an operation. The result of an operation determines the + * flow of the program. If an operation returns true, the program + * continues to the operation pointed to by 'on_pass'. If the operation + * returns false, the program continues to the operation pointed to by + * 'on_fail'. + * + * In most scenarios, on_pass points to the next operation, and on_fail + * points to the previous operation. + * + * When an operation fails, the previous operation will be invoked with + * redo=true. This will cause the operation to continue its search from + * where it left off. When the operation succeeds, the next operation + * will be invoked with redo=false. This causes the operation to start + * from the beginning, which is necessary since it just received a new + * input. */ + int32_t op_index = iter->op; + ecs_rule_op_t *op = &rule->operations[op_index]; + int32_t cur = op->frame; + + /* If this is not the first operation and is also not a control flow + * operation, push a new frame on the stack for the next operation */ + if (!redo && !is_control_flow(op) && cur && cur != last_frame) { + int32_t prev = cur - 1; + push_registers(iter, prev, cur); + push_columns(iter, prev, cur); + } -void ecs_os_err( - const char *file, - int32_t line, - const char *msg) -{ - if (ecs_os_api.log_) { - ecs_os_api.log_(-3, file, line, msg); - } -} + /* Dispatch the operation */ + bool result = eval_op(it, op, op_index, redo); + iter->op = result ? op->on_pass : op->on_fail; -void ecs_os_fatal( - const char *file, - int32_t line, - const char *msg) -{ - if (ecs_os_api.log_) { - ecs_os_api.log_(-4, file, line, msg); - } -} + /* If the current operation is yield, return results */ + if (op->kind == EcsRuleYield) { + populate_iterator(rule, it, iter, op); + iter->redo = true; + return true; + } -static -void ecs_os_gettime(ecs_time_t *time) { - ecs_assert(ecs_os_has_time() == true, ECS_MISSING_OS_API, NULL); - - uint64_t now = ecs_os_now(); - uint64_t sec = now / 1000000000; + /* If the current operation is a jump, goto stored label */ + if (op->kind == EcsRuleJump) { + /* Label is stored in setjmp context */ + iter->op = iter->op_ctx[op->on_pass].is.setjmp.label; + } - assert(sec < UINT32_MAX); - assert((now - sec * 1000000000) < UINT32_MAX); + /* If jumping backwards, it's a redo */ + redo = iter->op <= op_index; - time->sec = (uint32_t)sec; - time->nanosec = (uint32_t)(now - sec * 1000000000); -} + if (!is_control_flow(op)) { + last_frame = op->frame; + } + } while (iter->op != -1); -static -void* ecs_os_api_malloc(ecs_size_t size) { - ecs_os_api_malloc_count ++; - ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); - return malloc((size_t)size); -} + ecs_iter_fini(it); -static -void* ecs_os_api_calloc(ecs_size_t size) { - ecs_os_api_calloc_count ++; - ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); - return calloc(1, (size_t)size); +error: + return false; } -static -void* ecs_os_api_realloc(void *ptr, ecs_size_t size) { - ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); +#endif - if (ptr) { - ecs_os_api_realloc_count ++; - } else { - /* If not actually reallocing, treat as malloc */ - ecs_os_api_malloc_count ++; - } - - return realloc(ptr, (size_t)size); -} +/* This is a heavily modified version of the EmbeddableWebServer (see copyright + * below). This version has been stripped from everything not strictly necessary + * for receiving/replying to simple HTTP requests, and has been modified to use + * the Flecs OS API. */ -static -void ecs_os_api_free(void *ptr) { - if (ptr) { - ecs_os_api_free_count ++; - } - free(ptr); -} +/* EmbeddableWebServer Copyright (c) 2016, 2019, 2020 Forrest Heller, and + * CONTRIBUTORS (see below) - All rights reserved. + * + * CONTRIBUTORS: + * Martin Pulec - bug fixes, warning fixes, IPv6 support + * Daniel Barry - bug fix (ifa_addr != NULL) + * + * Released under the BSD 2-clause license: + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. THIS SOFTWARE IS + * PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN + * NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ -static -char* ecs_os_api_strdup(const char *str) { - if (str) { - int len = ecs_os_strlen(str); - char *result = ecs_os_malloc(len + 1); - ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - ecs_os_strcpy(result, str); - return result; - } else { - return NULL; - } -} -/* Replace dots with underscores */ -static -char *module_file_base(const char *module, char sep) { - char *base = ecs_os_strdup(module); - ecs_size_t i, len = ecs_os_strlen(base); - for (i = 0; i < len; i ++) { - if (base[i] == '.') { - base[i] = sep; - } - } +#ifdef FLECS_HTTP - return base; -} +#if defined(ECS_TARGET_WINDOWS) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#pragma comment(lib, "Ws2_32.lib") +#include +#include +#include +typedef SOCKET ecs_http_socket_t; +#else +#include +#include +#include +#include +#include +#include +typedef int ecs_http_socket_t; +#endif -static -char* ecs_os_api_module_to_dl(const char *module) { - ecs_strbuf_t lib = ECS_STRBUF_INIT; +/* Max length of request method */ +#define ECS_HTTP_METHOD_LEN_MAX (8) - /* Best guess, use module name with underscores + OS library extension */ - char *file_base = module_file_base(module, '_'); +/* Timeout (s) before connection purge */ +#define ECS_HTTP_CONNECTION_PURGE_TIMEOUT (1.0) -# if defined(ECS_TARGET_LINUX) || defined(ECS_TARGET_FREEBSD) - ecs_strbuf_appendstr(&lib, "lib"); - ecs_strbuf_appendstr(&lib, file_base); - ecs_strbuf_appendstr(&lib, ".so"); -# elif defined(ECS_TARGET_DARWIN) - ecs_strbuf_appendstr(&lib, "lib"); - ecs_strbuf_appendstr(&lib, file_base); - ecs_strbuf_appendstr(&lib, ".dylib"); -# elif defined(ECS_TARGET_WINDOWS) - ecs_strbuf_appendstr(&lib, file_base); - ecs_strbuf_appendstr(&lib, ".dll"); -# endif +/* Number of dequeues before purging */ +#define ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT (5) - ecs_os_free(file_base); +/* Minimum interval between dequeueing requests (ms) */ +#define ECS_HTTP_MIN_DEQUEUE_INTERVAL (100) - return ecs_strbuf_get(&lib); -} +/* Minimum interval between printing statistics (ms) */ +#define ECS_HTTP_MIN_STATS_INTERVAL (10 * 1000) -static -char* ecs_os_api_module_to_etc(const char *module) { - ecs_strbuf_t lib = ECS_STRBUF_INIT; +/* Max length of headers in reply */ +#define ECS_HTTP_REPLY_HEADER_SIZE (1024) - /* Best guess, use module name with dashes + /etc */ - char *file_base = module_file_base(module, '-'); +/* Receive buffer size */ +#define ECS_HTTP_SEND_RECV_BUFFER_SIZE (16 * 1024) - ecs_strbuf_appendstr(&lib, file_base); - ecs_strbuf_appendstr(&lib, "/etc"); +/* Max length of request (path + query + headers + body) */ +#define ECS_HTTP_REQUEST_LEN_MAX (10 * 1024 * 1024) - ecs_os_free(file_base); +/* HTTP server struct */ +struct ecs_http_server_t { + bool should_run; + bool running; - return ecs_strbuf_get(&lib); -} + ecs_http_socket_t sock; + ecs_os_mutex_t lock; + ecs_os_thread_t thread; -void ecs_os_set_api_defaults(void) -{ - /* Don't overwrite if already initialized */ - if (ecs_os_api_initialized != 0) { - return; - } + ecs_http_reply_action_t callback; + void *ctx; - if (ecs_os_api_initializing != 0) { - return; - } + ecs_sparse_t *connections; /* sparse */ + ecs_sparse_t *requests; /* sparse */ - ecs_os_api_initializing = true; - - /* Memory management */ - ecs_os_api.malloc_ = ecs_os_api_malloc; - ecs_os_api.free_ = ecs_os_api_free; - ecs_os_api.realloc_ = ecs_os_api_realloc; - ecs_os_api.calloc_ = ecs_os_api_calloc; + bool initialized; - /* Strings */ - ecs_os_api.strdup_ = ecs_os_api_strdup; + uint16_t port; + const char *ipaddr; - /* Time */ - ecs_os_api.get_time_ = ecs_os_gettime; + FLECS_FLOAT dequeue_timeout; /* used to not lock request queue too often */ + FLECS_FLOAT stats_timeout; /* used for periodic reporting of statistics */ - /* Logging */ - ecs_os_api.log_ = log_msg; + FLECS_FLOAT request_time; /* time spent on requests in last stats interval */ + FLECS_FLOAT request_time_total; /* total time spent on requests */ + int32_t requests_processed; /* requests processed in last stats interval */ + int32_t requests_processed_total; /* total requests processed */ + int32_t dequeue_count; /* number of dequeues in last stats interval */ +}; - /* Modules */ - if (!ecs_os_api.module_to_dl_) { - ecs_os_api.module_to_dl_ = ecs_os_api_module_to_dl; - } +/** Fragment state, used by HTTP request parser */ +typedef enum { + HttpFragStateBegin, + HttpFragStateMethod, + HttpFragStatePath, + HttpFragStateVersion, + HttpFragStateHeaderStart, + HttpFragStateHeaderName, + HttpFragStateHeaderValueStart, + HttpFragStateHeaderValue, + HttpFragStateCR, + HttpFragStateCRLF, + HttpFragStateCRLFCR, + HttpFragStateBody, + HttpFragStateDone +} HttpFragState; - if (!ecs_os_api.module_to_etc_) { - ecs_os_api.module_to_etc_ = ecs_os_api_module_to_etc; - } +/** A fragment is a partially received HTTP request */ +typedef struct { + HttpFragState state; + ecs_strbuf_t buf; + ecs_http_method_t method; + int32_t body_offset; + int32_t query_offset; + int32_t header_offsets[ECS_HTTP_HEADER_COUNT_MAX]; + int32_t header_value_offsets[ECS_HTTP_HEADER_COUNT_MAX]; + int32_t header_count; + int32_t param_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX]; + int32_t param_value_offsets[ECS_HTTP_QUERY_PARAM_COUNT_MAX]; + int32_t param_count; + char header_buf[32]; + char *header_buf_ptr; + int32_t content_length; + bool parse_content_length; + bool invalid; +} ecs_http_fragment_t; - ecs_os_api.abort_ = abort; +/** Extend public connection type with fragment data */ +typedef struct { + ecs_http_connection_t pub; + ecs_http_fragment_t frag; + ecs_http_socket_t sock; -# ifdef FLECS_OS_API_IMPL - /* Initialize defaults to OS API IMPL addon, but still allow for overriding - * by the application */ - ecs_set_os_api_impl(); - ecs_os_api_initialized = false; -# endif + /* Connection is purged after both timeout expires and connection has + * exceeded retry count. This ensures that a connection does not immediately + * timeout when a frame takes longer than usual */ + FLECS_FLOAT dequeue_timeout; + int32_t dequeue_retries; +} ecs_http_connection_impl_t; - ecs_os_api_initializing = false; +typedef struct { + ecs_http_request_t pub; + uint64_t conn_id; /* for sanity check */ + void *res; +} ecs_http_request_impl_t; + +static +ecs_size_t http_send( + ecs_http_socket_t sock, + const void *buf, + ecs_size_t size, + int flags) +{ +#ifndef ECS_TARGET_MSVC + ssize_t send_bytes = send(sock, buf, flecs_itosize(size), flags); + return flecs_itoi32(send_bytes); +#else + int send_bytes = send(sock, buf, size, flags); + return flecs_itoi32(send_bytes); +#endif } -bool ecs_os_has_heap(void) { - return - (ecs_os_api.malloc_ != NULL) && - (ecs_os_api.calloc_ != NULL) && - (ecs_os_api.realloc_ != NULL) && - (ecs_os_api.free_ != NULL); +static +ecs_size_t http_recv( + ecs_http_socket_t sock, + void *buf, + ecs_size_t size, + int flags) +{ + ecs_size_t ret; +#ifndef ECS_TARGET_MSVC + ssize_t recv_bytes = recv(sock, buf, flecs_itosize(size), flags); + ret = flecs_itoi32(recv_bytes); +#else + int recv_bytes = recv(sock, buf, size, flags); + ret = flecs_itoi32(recv_bytes); +#endif + if (ret == -1) { + ecs_dbg("recv failed: %s (sock = %d)", ecs_os_strerror(errno), sock); + } else if (ret == 0) { + ecs_dbg("recv: received 0 bytes (sock = %d)", sock); + } + + return ret; } -bool ecs_os_has_threading(void) { - return - (ecs_os_api.mutex_new_ != NULL) && - (ecs_os_api.mutex_free_ != NULL) && - (ecs_os_api.mutex_lock_ != NULL) && - (ecs_os_api.mutex_unlock_ != NULL) && - (ecs_os_api.cond_new_ != NULL) && - (ecs_os_api.cond_free_ != NULL) && - (ecs_os_api.cond_wait_ != NULL) && - (ecs_os_api.cond_signal_ != NULL) && - (ecs_os_api.cond_broadcast_ != NULL) && - (ecs_os_api.thread_new_ != NULL) && - (ecs_os_api.thread_join_ != NULL); +static +int http_getnameinfo( + const struct sockaddr* addr, + ecs_size_t addr_len, + char *host, + ecs_size_t host_len, + char *port, + ecs_size_t port_len, + int flags) +{ + ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(host_len > 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(port_len > 0, ECS_INTERNAL_ERROR, NULL); + return getnameinfo(addr, (uint32_t)addr_len, host, (uint32_t)host_len, + port, (uint32_t)port_len, flags); } -bool ecs_os_has_time(void) { - return - (ecs_os_api.get_time_ != NULL) && - (ecs_os_api.sleep_ != NULL) && - (ecs_os_api.now_ != NULL) && - (ecs_os_api.enable_high_timer_resolution_ != NULL); +static +int http_bind( + ecs_http_socket_t sock, + const struct sockaddr* addr, + ecs_size_t addr_len) +{ + ecs_assert(addr_len > 0, ECS_INTERNAL_ERROR, NULL); + return bind(sock, addr, (uint32_t)addr_len); } -bool ecs_os_has_logging(void) { - return (ecs_os_api.log_ != NULL); +static +void http_close( + ecs_http_socket_t sock) +{ +#if defined(ECS_TARGET_WINDOWS) + closesocket(sock); +#else + shutdown(sock, SHUT_RDWR); + close(sock); +#endif } -bool ecs_os_has_dl(void) { - return - (ecs_os_api.dlopen_ != NULL) && - (ecs_os_api.dlproc_ != NULL) && - (ecs_os_api.dlclose_ != NULL); +static +ecs_http_socket_t http_accept( + ecs_http_socket_t sock, + struct sockaddr* addr, + ecs_size_t *addr_len) +{ + socklen_t len = (socklen_t)addr_len[0]; + ecs_http_socket_t result = accept(sock, addr, &len); + addr_len[0] = (ecs_size_t)len; + return result; } -bool ecs_os_has_modules(void) { - return - (ecs_os_api.module_to_dl_ != NULL) && - (ecs_os_api.module_to_etc_ != NULL); +static +void reply_free(ecs_http_reply_t* response) { + ecs_assert(response != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_os_free(response->body.content); } -void ecs_os_enable_high_timer_resolution(bool enable) { - if (ecs_os_api.enable_high_timer_resolution_) { - ecs_os_api.enable_high_timer_resolution_(enable); - } else { - ecs_assert(enable == false, ECS_MISSING_OS_API, - "enable_high_timer_resolution"); - } +static +void request_free(ecs_http_request_impl_t *req) { + ecs_assert(req != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(req->pub.conn != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(req->pub.conn->server != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(req->pub.conn->server->requests != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(req->pub.conn->id == req->conn_id, ECS_INTERNAL_ERROR, NULL); + ecs_os_free(req->res); + flecs_sparse_remove(req->pub.conn->server->requests, req->pub.id); } -#if defined(ECS_TARGET_WINDOWS) -static char error_str[255]; -#endif +static +void connection_free(ecs_http_connection_impl_t *conn) { + ecs_assert(conn != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(conn->pub.id != 0, ECS_INTERNAL_ERROR, NULL); + uint64_t conn_id = conn->pub.id; -const char* ecs_os_strerror(int err) { -# if defined(ECS_TARGET_WINDOWS) - strerror_s(error_str, 255, err); - return error_str; -# else - return strerror(err); -# endif + if (conn->sock) { + http_close(conn->sock); + } + + flecs_sparse_remove(conn->pub.server->connections, conn_id); } +// https://stackoverflow.com/questions/10156409/convert-hex-string-char-to-int +static +char hex_2_int(char a, char b){ + a = (a <= '9') ? (char)(a - '0') : (char)((a & 0x7) + 9); + b = (b <= '9') ? (char)(b - '0') : (char)((b & 0x7) + 9); + return (char)((a << 4) + b); +} -#ifdef FLECS_SYSTEM -#endif +static +void decode_url_str( + char *str) +{ + char ch, *ptr, *dst = str; + for (ptr = str; (ch = *ptr); ptr++) { + if (ch == '%') { + dst[0] = hex_2_int(ptr[1], ptr[2]); + dst ++; + ptr += 2; + } else { + dst[0] = ptr[0]; + dst ++; + } + } + dst[0] = '\0'; +} static -void compute_group_id( - ecs_query_t *query, - ecs_query_table_match_t *match) +void parse_method( + ecs_http_fragment_t *frag) { - ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); - - if (query->group_by) { - ecs_table_t *table = match->table; - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - - match->group_id = query->group_by(query->world, table->type, - query->group_by_id, query->group_by_ctx); - } else { - match->group_id = 0; + char *method = ecs_strbuf_get_small(&frag->buf); + if (!ecs_os_strcmp(method, "GET")) frag->method = EcsHttpGet; + else if (!ecs_os_strcmp(method, "POST")) frag->method = EcsHttpPost; + else if (!ecs_os_strcmp(method, "PUT")) frag->method = EcsHttpPut; + else if (!ecs_os_strcmp(method, "DELETE")) frag->method = EcsHttpDelete; + else if (!ecs_os_strcmp(method, "OPTIONS")) frag->method = EcsHttpOptions; + else { + frag->method = EcsHttpMethodUnsupported; + frag->invalid = true; } + ecs_strbuf_reset(&frag->buf); } static -ecs_query_table_list_t* get_group( - ecs_query_t *query, - uint64_t group_id) +bool header_writable( + ecs_http_fragment_t *frag) { - return ecs_map_get(&query->groups, ecs_query_table_list_t, group_id); + return frag->header_count < ECS_HTTP_HEADER_COUNT_MAX; } static -ecs_query_table_list_t* ensure_group( - ecs_query_t *query, - uint64_t group_id) +void header_buf_reset( + ecs_http_fragment_t *frag) { - return ecs_map_ensure(&query->groups, ecs_query_table_list_t, group_id); + frag->header_buf[0] = '\0'; + frag->header_buf_ptr = frag->header_buf; } -/* Find the last node of the group after which this group should be inserted */ static -ecs_query_table_node_t* find_group_insertion_node( - ecs_query_t *query, - uint64_t group_id) +void header_buf_append( + ecs_http_fragment_t *frag, + char ch) { - /* Grouping must be enabled */ - ecs_assert(query->group_by != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_map_iter_t it = ecs_map_iter(&query->groups); - ecs_query_table_list_t *list, *closest_list = NULL; - uint64_t id, closest_id = 0; - - /* Find closest smaller group id */ - while ((list = ecs_map_next(&it, ecs_query_table_list_t, &id))) { - if (id >= group_id) { - continue; - } - - if (!list->last) { - ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL); - continue; - } - - if (!closest_list || ((group_id - id) < (group_id - closest_id))) { - closest_id = id; - closest_list = list; - } - } - - if (closest_list) { - return closest_list->last; + if ((frag->header_buf_ptr - frag->header_buf) < + ECS_SIZEOF(frag->header_buf)) + { + frag->header_buf_ptr[0] = ch; + frag->header_buf_ptr ++; } else { - return NULL; /* Group should be first in query */ + frag->header_buf_ptr[0] = '\0'; } } -/* Initialize group with first node */ static -void create_group( - ecs_query_t *query, - ecs_query_table_node_t *node) +void enqueue_request( + ecs_http_connection_impl_t *conn) { - ecs_query_table_match_t *match = node->match; - uint64_t group_id = match->group_id; - - /* If query has grouping enabled & this is a new/empty group, find - * the insertion point for the group */ - ecs_query_table_node_t *insert_after = find_group_insertion_node( - query, group_id); + ecs_http_server_t *srv = conn->pub.server; + ecs_http_fragment_t *frag = &conn->frag; - if (!insert_after) { - /* This group should appear first in the query list */ - ecs_query_table_node_t *query_first = query->list.first; - if (query_first) { - /* If this is not the first match for the query, insert before it */ - node->next = query_first; - query_first->prev = node; - query->list.first = node; - } else { - /* If this is the first match of the query, initialize its list */ - ecs_assert(query->list.last == NULL, ECS_INTERNAL_ERROR, NULL); - query->list.first = node; - query->list.last = node; - } + if (frag->invalid) { /* invalid request received, don't enqueue */ + ecs_strbuf_reset(&frag->buf); } else { - ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); + char *res = ecs_strbuf_get(&frag->buf); + if (res) { + ecs_os_mutex_lock(srv->lock); + ecs_http_request_impl_t *req = flecs_sparse_add( + srv->requests, ecs_http_request_impl_t); + req->pub.id = flecs_sparse_last_id(srv->requests); + req->conn_id = conn->pub.id; + ecs_os_mutex_unlock(srv->lock); - /* This group should appear after another group */ - ecs_query_table_node_t *insert_before = insert_after->next; - node->prev = insert_after; - insert_after->next = node; - node->next = insert_before; - if (insert_before) { - insert_before->prev = node; - } else { - ecs_assert(query->list.last == insert_after, - ECS_INTERNAL_ERROR, NULL); - - /* This group should appear last in the query list */ - query->list.last = node; + req->pub.conn = (ecs_http_connection_t*)conn; + req->pub.method = frag->method; + req->pub.path = res + 1; + if (frag->body_offset) { + req->pub.body = &res[frag->body_offset]; + } + int32_t i, count = frag->header_count; + for (i = 0; i < count; i ++) { + req->pub.headers[i].key = &res[frag->header_offsets[i]]; + req->pub.headers[i].value = &res[frag->header_value_offsets[i]]; + } + count = frag->param_count; + for (i = 0; i < count; i ++) { + req->pub.params[i].key = &res[frag->param_offsets[i]]; + req->pub.params[i].value = &res[frag->param_value_offsets[i]]; + decode_url_str((char*)req->pub.params[i].value); + } + + req->pub.header_count = frag->header_count; + req->pub.param_count = frag->param_count; + req->res = res; } } } static -void remove_group( - ecs_query_t *query, - uint64_t group_id) +bool parse_request( + ecs_http_connection_impl_t *conn, + uint64_t conn_id, + const char* req_frag, + ecs_size_t req_frag_len) { - ecs_map_remove(&query->groups, group_id); -} + ecs_http_fragment_t *frag = &conn->frag; -/* Find the list the node should be part of */ -static -ecs_query_table_list_t* get_node_list( - ecs_query_t *query, - ecs_query_table_node_t *node) -{ - ecs_query_table_match_t *match = node->match; - if (query->group_by) { - return get_group(query, match->group_id); - } else { - return &query->list; + int32_t i; + for (i = 0; i < req_frag_len; i++) { + char c = req_frag[i]; + switch (frag->state) { + case HttpFragStateBegin: + ecs_os_memset_t(frag, 0, ecs_http_fragment_t); + frag->buf.max = ECS_HTTP_METHOD_LEN_MAX; + frag->state = HttpFragStateMethod; + frag->header_buf_ptr = frag->header_buf; + /* fallthrough */ + case HttpFragStateMethod: + if (c == ' ') { + parse_method(frag); + frag->state = HttpFragStatePath; + frag->buf.max = ECS_HTTP_REQUEST_LEN_MAX; + } else { + ecs_strbuf_appendch(&frag->buf, c); + } + break; + case HttpFragStatePath: + if (c == ' ') { + frag->state = HttpFragStateVersion; + ecs_strbuf_appendch(&frag->buf, '\0'); + } else { + if (c == '?' || c == '=' || c == '&') { + ecs_strbuf_appendch(&frag->buf, '\0'); + int32_t offset = ecs_strbuf_written(&frag->buf); + if (c == '?' || c == '&') { + frag->param_offsets[frag->param_count] = offset; + } else { + frag->param_value_offsets[frag->param_count] = offset; + frag->param_count ++; + } + } else { + ecs_strbuf_appendch(&frag->buf, c); + } + } + break; + case HttpFragStateVersion: + if (c == '\r') { + frag->state = HttpFragStateCR; + } /* version is not stored */ + break; + case HttpFragStateHeaderStart: + if (header_writable(frag)) { + frag->header_offsets[frag->header_count] = + ecs_strbuf_written(&frag->buf); + } + header_buf_reset(frag); + frag->state = HttpFragStateHeaderName; + /* fallthrough */ + case HttpFragStateHeaderName: + if (c == ':') { + frag->state = HttpFragStateHeaderValueStart; + header_buf_append(frag, '\0'); + frag->parse_content_length = !ecs_os_strcmp( + frag->header_buf, "Content-Length"); + + if (header_writable(frag)) { + ecs_strbuf_appendch(&frag->buf, '\0'); + frag->header_value_offsets[frag->header_count] = + ecs_strbuf_written(&frag->buf); + } + } else if (c == '\r') { + frag->state = HttpFragStateCR; + } else { + header_buf_append(frag, c); + if (header_writable(frag)) { + ecs_strbuf_appendch(&frag->buf, c); + } + } + break; + case HttpFragStateHeaderValueStart: + header_buf_reset(frag); + frag->state = HttpFragStateHeaderValue; + if (c == ' ') { /* skip first space */ + break; + } + /* fallthrough */ + case HttpFragStateHeaderValue: + if (c == '\r') { + if (frag->parse_content_length) { + header_buf_append(frag, '\0'); + int32_t len = atoi(frag->header_buf); + if (len < 0) { + frag->invalid = true; + } else { + frag->content_length = len; + } + frag->parse_content_length = false; + } + if (header_writable(frag)) { + int32_t cur = ecs_strbuf_written(&frag->buf); + if (frag->header_offsets[frag->header_count] < cur && + frag->header_value_offsets[frag->header_count] < cur) + { + ecs_strbuf_appendch(&frag->buf, '\0'); + frag->header_count ++; + } + } + frag->state = HttpFragStateCR; + } else { + if (frag->parse_content_length) { + header_buf_append(frag, c); + } + if (header_writable(frag)) { + ecs_strbuf_appendch(&frag->buf, c); + } + } + break; + case HttpFragStateCR: + if (c == '\n') { + frag->state = HttpFragStateCRLF; + } else { + frag->state = HttpFragStateHeaderStart; + } + break; + case HttpFragStateCRLF: + if (c == '\r') { + frag->state = HttpFragStateCRLFCR; + } else { + frag->state = HttpFragStateHeaderStart; + i--; + } + break; + case HttpFragStateCRLFCR: + if (c == '\n') { + if (frag->content_length != 0) { + frag->body_offset = ecs_strbuf_written(&frag->buf); + frag->state = HttpFragStateBody; + } else { + frag->state = HttpFragStateDone; + } + } else { + frag->state = HttpFragStateHeaderStart; + } + break; + case HttpFragStateBody: { + ecs_strbuf_appendch(&frag->buf, c); + if ((ecs_strbuf_written(&frag->buf) - frag->body_offset) == + frag->content_length) + { + frag->state = HttpFragStateDone; + } + } + break; + case HttpFragStateDone: + break; + } } -} -/* Find or create the list the node should be part of */ -static -ecs_query_table_list_t* ensure_node_list( - ecs_query_t *query, - ecs_query_table_node_t *node) -{ - ecs_query_table_match_t *match = node->match; - if (query->group_by) { - return ensure_group(query, match->group_id); + if (frag->state == HttpFragStateDone) { + frag->state = HttpFragStateBegin; + if (conn->pub.id == conn_id) { + enqueue_request(conn); + } + return true; } else { - return &query->list; + return false; } } -/* Remove node from list */ static -void remove_table_node( - ecs_query_t *query, - ecs_query_table_node_t *node) +void append_send_headers( + ecs_strbuf_t *hdrs, + int code, + const char* status, + const char* content_type, + ecs_strbuf_t *extra_headers, + ecs_size_t content_len) { - ecs_query_table_node_t *prev = node->prev; - ecs_query_table_node_t *next = node->next; + ecs_strbuf_appendstr(hdrs, "HTTP/1.1 "); + ecs_strbuf_append(hdrs, "%d ", code); + ecs_strbuf_appendstr(hdrs, status); + ecs_strbuf_appendstr(hdrs, "\r\n"); - ecs_assert(prev != node, ECS_INTERNAL_ERROR, NULL); - ecs_assert(next != node, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!prev || prev != next, ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_appendstr(hdrs, "Content-Type: "); + ecs_strbuf_appendstr(hdrs, content_type); + ecs_strbuf_appendstr(hdrs, "\r\n"); - ecs_query_table_list_t *list = get_node_list(query, node); + ecs_strbuf_appendstr(hdrs, "Content-Length: "); + ecs_strbuf_append(hdrs, "%d", content_len); + ecs_strbuf_appendstr(hdrs, "\r\n"); - if (!list || !list->first) { - /* If list contains no nodes, the node must be empty */ - ecs_assert(!list || list->last == NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL); - return; - } + ecs_strbuf_appendstr(hdrs, "Server: flecs\r\n"); - ecs_assert(prev != NULL || query->list.first == node, - ECS_INTERNAL_ERROR, NULL); - ecs_assert(next != NULL || query->list.last == node, - ECS_INTERNAL_ERROR, NULL); + ecs_strbuf_mergebuff(hdrs, extra_headers); - if (prev) { - prev->next = next; - } - if (next) { - next->prev = prev; - } + ecs_strbuf_appendstr(hdrs, "\r\n"); +} - ecs_assert(list->count > 0, ECS_INTERNAL_ERROR, NULL); - list->count --; +static +void send_reply( + ecs_http_connection_impl_t* conn, + ecs_http_reply_t* reply) +{ + char hdrs[ECS_HTTP_REPLY_HEADER_SIZE]; + ecs_strbuf_t hdr_buf = ECS_STRBUF_INIT; + hdr_buf.buf = hdrs; + hdr_buf.max = ECS_HTTP_REPLY_HEADER_SIZE; + hdr_buf.buf = hdrs; - if (query->group_by) { - ecs_query_table_match_t *match = node->match; - uint64_t group_id = match->group_id; + char *content = ecs_strbuf_get(&reply->body); + int32_t content_length = reply->body.length - 1; - /* Make sure query.list is updated if this is the first or last group */ - if (query->list.first == node) { - ecs_assert(prev == NULL, ECS_INTERNAL_ERROR, NULL); - query->list.first = next; - prev = next; - } - if (query->list.last == node) { - ecs_assert(next == NULL, ECS_INTERNAL_ERROR, NULL); - query->list.last = prev; - next = prev; - } + /* First, send the response HTTP headers */ + append_send_headers(&hdr_buf, reply->code, reply->status, + reply->content_type, &reply->headers, content_length); - ecs_assert(query->list.count > 0, ECS_INTERNAL_ERROR, NULL); - query->list.count --; + ecs_size_t hdrs_len = ecs_strbuf_written(&hdr_buf); + hdrs[hdrs_len] = '\0'; + ecs_size_t written = http_send(conn->sock, hdrs, hdrs_len, 0); - /* Make sure group list only contains nodes that belong to the group */ - if (prev && prev->match->group_id != group_id) { - /* The previous node belonged to another group */ - prev = next; - } - if (next && next->match->group_id != group_id) { - /* The next node belonged to another group */ - next = prev; - } + if (written != hdrs_len) { + ecs_err("failed to write HTTP response headers to '%s:%s': %s", + conn->pub.host, conn->pub.port, ecs_os_strerror(errno)); + return; + } - /* Do check again, in case both prev & next belonged to another group */ - if (prev && prev->match->group_id != group_id) { - /* There are no more matches left in this group */ - remove_group(query, group_id); - list = NULL; + /* Second, send response body */ + if (content_length > 0) { + written = http_send(conn->sock, content, content_length, 0); + if (written != content_length) { + ecs_err("failed to write HTTP response body to '%s:%s': %s", + conn->pub.host, conn->pub.port, ecs_os_strerror(errno)); } } +} - if (list) { - if (list->first == node) { - list->first = next; +static +void recv_request( + ecs_http_server_t *srv, + ecs_http_connection_impl_t *conn, + uint64_t conn_id, + ecs_http_socket_t sock) +{ + ecs_size_t bytes_read; + char recv_buf[ECS_HTTP_SEND_RECV_BUFFER_SIZE]; + + while ((bytes_read = http_recv( + sock, recv_buf, ECS_SIZEOF(recv_buf), 0)) > 0) + { + ecs_os_mutex_lock(srv->lock); + bool is_alive = conn->pub.id == conn_id; + if (is_alive) { + conn->dequeue_timeout = 0; + conn->dequeue_retries = 0; } - if (list->last == node) { - list->last = prev; + ecs_os_mutex_unlock(srv->lock); + + if (is_alive) { + if (parse_request(conn, conn_id, recv_buf, bytes_read)) { + return; + } + } else { + return; } } +} + +static +void init_connection( + ecs_http_server_t *srv, + ecs_http_socket_t sock_conn, + struct sockaddr_storage *remote_addr, + ecs_size_t remote_addr_len) +{ + /* Create new connection */ + ecs_os_mutex_lock(srv->lock); + ecs_http_connection_impl_t *conn = flecs_sparse_add( + srv->connections, ecs_http_connection_impl_t); + uint64_t conn_id = conn->pub.id = flecs_sparse_last_id(srv->connections); + conn->pub.server = srv; + conn->sock = sock_conn; + ecs_os_mutex_unlock(srv->lock); + + char *remote_host = conn->pub.host; + char *remote_port = conn->pub.port; + + /* Fetch name & port info */ + if (http_getnameinfo((struct sockaddr*) remote_addr, remote_addr_len, + remote_host, ECS_SIZEOF(conn->pub.host), + remote_port, ECS_SIZEOF(conn->pub.port), + NI_NUMERICHOST | NI_NUMERICSERV)) + { + ecs_os_strcpy(remote_host, "unknown"); + ecs_os_strcpy(remote_port, "unknown"); + } - node->prev = NULL; - node->next = NULL; + ecs_dbg_2("http: connection established from '%s:%s'", + remote_host, remote_port); -#ifdef FLECS_SYSTEM - if (query->list.first == NULL && query->system && !query->world->is_fini) { - ecs_system_activate(query->world, query->system, false, NULL); - } -#endif + recv_request(srv, conn, conn_id, sock_conn); - query->match_count ++; + ecs_dbg_2("http: request received from '%s:%s'", + remote_host, remote_port); } -/* Add node to list */ static -void insert_table_node( - ecs_query_t *query, - ecs_query_table_node_t *node) +void accept_connections( + ecs_http_server_t* srv, + const struct sockaddr* addr, + ecs_size_t addr_len) { - /* Node should not be part of an existing list */ - ecs_assert(node->prev == NULL && node->next == NULL, - ECS_INTERNAL_ERROR, NULL); - - /* If this is the first match, activate system */ -#ifdef FLECS_SYSTEM - if (!query->list.first && query->system) { - ecs_system_activate(query->world, query->system, true, NULL); +#ifdef ECS_TARGET_WINDOWS + /* If on Windows, test if winsock needs to be initialized */ + SOCKET testsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (SOCKET_ERROR == testsocket && WSANOTINITIALISED == WSAGetLastError()) { + WSADATA data = { 0 }; + int result = WSAStartup(MAKEWORD(2, 2), &data); + if (result) { + ecs_warn("WSAStartup failed with GetLastError = %d\n", + GetLastError()); + return; + } + } else { + http_close(testsocket); } #endif - compute_group_id(query, node->match); - - ecs_query_table_list_t *list = ensure_node_list(query, node); - if (list->last) { - ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_query_table_node_t *last = list->last; - ecs_query_table_node_t *last_next = last->next; + /* Resolve name + port (used for logging) */ + char addr_host[256]; + char addr_port[20]; - node->prev = last; - node->next = last_next; - last->next = node; + if (http_getnameinfo( + addr, addr_len, addr_host, ECS_SIZEOF(addr_host), addr_port, + ECS_SIZEOF(addr_port), NI_NUMERICHOST | NI_NUMERICSERV)) + { + ecs_os_strcpy(addr_host, "unknown"); + ecs_os_strcpy(addr_port, "unknown"); + } - if (last_next) { - last_next->prev = node; + ecs_os_mutex_lock(srv->lock); + if (srv->should_run) { + ecs_dbg_2("http: initializing connection socket"); + + srv->sock = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP); + if (srv->sock < 0) { + ecs_err("unable to create new connection socket: %s", + ecs_os_strerror(errno)); + ecs_os_mutex_unlock(srv->lock); + goto done; } - list->last = node; + int reuse = 1; + int result = setsockopt(srv->sock, SOL_SOCKET, SO_REUSEADDR, + (char*)&reuse, ECS_SIZEOF(reuse)); + if (result) { + ecs_warn("failed to setsockopt: %s", ecs_os_strerror(errno)); + } - if (query->group_by) { - /* Make sure to update query list if this is the last group */ - if (query->list.last == last) { - query->list.last = node; + if (addr->sa_family == AF_INET6) { + int ipv6only = 0; + if (setsockopt(srv->sock, IPPROTO_IPV6, IPV6_V6ONLY, + (char*)&ipv6only, ECS_SIZEOF(ipv6only))) + { + ecs_warn("failed to setsockopt: %s", ecs_os_strerror(errno)); } } - } else { - ecs_assert(list->first == NULL, ECS_INTERNAL_ERROR, NULL); + + result = http_bind(srv->sock, addr, addr_len); + if (result) { + ecs_err("http: failed to bind to '%s:%s': %s", + addr_host, addr_port, ecs_os_strerror(errno)); + ecs_os_mutex_unlock(srv->lock); + goto done; + } - list->first = node; - list->last = node; + result = listen(srv->sock, SOMAXCONN); + if (result) { + ecs_warn("http: could not listen for SOMAXCONN (%d) connections: %s", + SOMAXCONN, ecs_os_strerror(errno)); + } - if (query->group_by) { - /* Initialize group with its first node */ - create_group(query, node); + ecs_trace("http: listening for incoming connections on '%s:%s'", + addr_host, addr_port); + } + ecs_os_mutex_unlock(srv->lock); + + ecs_http_socket_t sock_conn; + struct sockaddr_storage remote_addr; + ecs_size_t remote_addr_len; + + while (srv->should_run) { + remote_addr_len = ECS_SIZEOF(remote_addr); + sock_conn = http_accept(srv->sock, (struct sockaddr*) &remote_addr, + &remote_addr_len); + + if (sock_conn == -1) { + if (srv->should_run) { + ecs_dbg("http: connection attempt failed: %s", + ecs_os_strerror(errno)); + } + continue; } + + init_connection(srv, sock_conn, &remote_addr, remote_addr_len); } - if (query->group_by) { - query->list.count ++; +done: + if (srv->sock && errno != EBADF) { + http_close(srv->sock); + srv->sock = 0; } - list->count ++; - query->match_count ++; + ecs_trace("http: no longer accepting connections on '%s:%s'", + addr_host, addr_port); +} - ecs_assert(node->prev != node, ECS_INTERNAL_ERROR, NULL); - ecs_assert(node->next != node, ECS_INTERNAL_ERROR, NULL); +static +void* http_server_thread(void* arg) { + ecs_http_server_t *srv = arg; + struct sockaddr_in addr; + ecs_os_zeromem(&addr); + addr.sin_family = AF_INET; + addr.sin_port = htons(srv->port); - ecs_assert(list->first != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(list->last != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(list->last == node, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.first != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.last != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.first->prev == NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(query->list.last->next == NULL, ECS_INTERNAL_ERROR, NULL); + if (!srv->ipaddr) { + addr.sin_addr.s_addr = htonl(INADDR_ANY); + } else { + inet_pton(AF_INET, srv->ipaddr, &(addr.sin_addr)); + } + + accept_connections(srv, (struct sockaddr*)&addr, ECS_SIZEOF(addr)); + return NULL; } static -ecs_query_table_match_t* cache_add( - ecs_query_table_t *elem) +void handle_request( + ecs_http_server_t *srv, + ecs_http_request_impl_t *req) { - ecs_query_table_match_t *result = ecs_os_calloc_t(ecs_query_table_match_t); - ecs_query_table_node_t *node = &result->node; + ecs_http_reply_t reply = ECS_HTTP_REPLY_INIT; + ecs_http_connection_impl_t *conn = + (ecs_http_connection_impl_t*)req->pub.conn; - node->match = result; - if (!elem->first) { - elem->first = result; - elem->last = result; - } else { - ecs_assert(elem->last != NULL, ECS_INTERNAL_ERROR, NULL); - elem->last->next_match = result; - elem->last = result; + if (srv->callback((ecs_http_request_t*)req, &reply, srv->ctx) == 0) { + reply.code = 404; + reply.status = "Resource not found"; } - return result; -} + send_reply(conn, &reply); + ecs_dbg_2("http: reply sent to '%s:%s'", conn->pub.host, conn->pub.port); -typedef struct { - ecs_table_t *table; - int32_t *dirty_state; - int32_t column; -} table_dirty_state_t; + reply_free(&reply); + request_free(req); + connection_free(conn); +} static -void get_dirty_state( - ecs_query_t *query, - ecs_query_table_match_t *match, - int32_t term, - table_dirty_state_t *out) +int32_t dequeue_requests( + ecs_http_server_t *srv, + float delta_time) { - ecs_world_t *world = query->world; - ecs_entity_t subject = match->subjects[term]; - int32_t column; + ecs_os_mutex_lock(srv->lock); - if (!subject) { - out->table = match->table; - column = match->columns[term]; - if (column == -1) { - column = 0; + int32_t i, request_count = flecs_sparse_count(srv->requests); + for (i = request_count - 1; i >= 1; i --) { + ecs_http_request_impl_t *req = flecs_sparse_get_dense( + srv->requests, ecs_http_request_impl_t, i); + handle_request(srv, req); + } + + int32_t connections_count = flecs_sparse_count(srv->connections); + for (i = connections_count - 1; i >= 1; i --) { + ecs_http_connection_impl_t *conn = flecs_sparse_get_dense( + srv->connections, ecs_http_connection_impl_t, i); + + conn->dequeue_timeout += delta_time; + conn->dequeue_retries ++; + + if ((conn->dequeue_timeout > + (FLECS_FLOAT)ECS_HTTP_CONNECTION_PURGE_TIMEOUT) && + (conn->dequeue_retries > ECS_HTTP_CONNECTION_PURGE_RETRY_COUNT)) + { + ecs_dbg("http: purging connection '%s:%s' (sock = %d)", + conn->pub.host, conn->pub.port, conn->sock); + connection_free(conn); } - } else { - out->table = ecs_get_table(world, subject); - column = -match->columns[term]; } - out->dirty_state = flecs_table_get_dirty_state(out->table); + ecs_os_mutex_unlock(srv->lock); - if (column) { - out->column = ecs_table_type_to_storage_index(out->table, column - 1); - } else { - out->column = -1; + return request_count; +} + +const char* ecs_http_get_header( + const ecs_http_request_t* req, + const char* name) +{ + for (ecs_size_t i = 0; i < req->header_count; i++) { + if (!ecs_os_strcmp(req->headers[i].key, name)) { + return req->headers[i].value; + } } + return NULL; } -/* Get match monitor. Monitors are used to keep track of whether components - * matched by the query in a table have changed. */ -static -bool get_match_monitor( - ecs_query_t *query, - ecs_query_table_match_t *match) +const char* ecs_http_get_param( + const ecs_http_request_t* req, + const char* name) { - if (match->monitor) { - return false; + for (ecs_size_t i = 0; i < req->param_count; i++) { + if (!ecs_os_strcmp(req->params[i].key, name)) { + return req->params[i].value; + } } + return NULL; +} - int32_t *monitor = ecs_os_calloc_n(int32_t, query->filter.term_count + 1); +ecs_http_server_t* ecs_http_server_init( + const ecs_http_server_desc_t *desc) +{ + ecs_check(ecs_os_has_threading(), ECS_UNSUPPORTED, + "missing OS API implementation"); - /* Mark terms that don't need to be monitored. This saves time when reading - * and/or updating the monitor. */ - const ecs_filter_t *f = &query->filter; - int32_t i, t = -1, term_count = f->term_count_actual; - table_dirty_state_t cur_dirty_state; + ecs_http_server_t* srv = ecs_os_calloc_t(ecs_http_server_t); + srv->lock = ecs_os_mutex_new(); - for (i = 0; i < term_count; i ++) { - if (t == f->terms[i].index) { - if (monitor[t + 1] != -1) { - continue; - } - } + srv->should_run = false; + srv->initialized = true; - t = f->terms[i].index; - monitor[t + 1] = -1; + srv->callback = desc->callback; + srv->ctx = desc->ctx; + srv->port = desc->port; + srv->ipaddr = desc->ipaddr; - if (f->terms[i].inout != EcsIn && - f->terms[i].inout != EcsInOut && - f->terms[i].inout != EcsInOutDefault) { - continue; /* If term isn't read, don't monitor */ - } + srv->connections = flecs_sparse_new(ecs_http_connection_impl_t); + srv->requests = flecs_sparse_new(ecs_http_request_impl_t); - int32_t column = match->columns[t]; - if (column == 0) { - continue; /* Don't track terms that aren't matched */ - } + /* Start at id 1 */ + flecs_sparse_new_id(srv->connections); + flecs_sparse_new_id(srv->requests); - get_dirty_state(query, match, t, &cur_dirty_state); - if (cur_dirty_state.column == -1) { - continue; /* Don't track terms that aren't stored */ - } +#ifndef ECS_TARGET_WINDOWS + /* Ignore pipe signal. SIGPIPE can occur when a message is sent to a client + * but te client already disconnected. */ + signal(SIGPIPE, SIG_IGN); +#endif - monitor[t + 1] = 0; + return srv; +error: + return NULL; +} + +void ecs_http_server_fini( + ecs_http_server_t* srv) +{ + if (srv->should_run) { + ecs_http_server_stop(srv); } + ecs_os_mutex_free(srv->lock); + flecs_sparse_free(srv->connections); + flecs_sparse_free(srv->requests); + ecs_os_free(srv); +} - match->monitor = monitor; +int ecs_http_server_start( + ecs_http_server_t *srv) +{ + ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL); + ecs_check(!srv->should_run, ECS_INVALID_PARAMETER, NULL); + ecs_check(!srv->thread, ECS_INVALID_PARAMETER, NULL); - query->flags |= EcsQueryHasMonitor; + srv->should_run = true; - return true; + ecs_dbg("http: starting server thread"); + + srv->thread = ecs_os_thread_new(http_server_thread, srv); + if (!srv->thread) { + goto error; + } + + return 0; +error: + return -1; } -/* Synchronize match monitor with table dirty state */ -static -void sync_match_monitor( - ecs_query_t *query, - ecs_query_table_match_t *match) +void ecs_http_server_stop( + ecs_http_server_t* srv) { - ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); - if (!match->monitor) { - if (query->flags & EcsQueryHasMonitor) { - get_match_monitor(query, match); - } else { - return; - } + ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(srv->initialized, ECS_INVALID_OPERATION, NULL); + ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL); + + /* Stop server thread */ + ecs_dbg("http: shutting down server thread"); + + ecs_os_mutex_lock(srv->lock); + srv->should_run = false; + if (srv->sock >= 0) { + http_close(srv->sock); } + ecs_os_mutex_unlock(srv->lock); - int32_t *monitor = match->monitor; - ecs_table_t *table = match->table; - int32_t *dirty_state = flecs_table_get_dirty_state(table); - ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); - table_dirty_state_t cur; + ecs_os_thread_join(srv->thread); - monitor[0] = dirty_state[0]; /* Did table gain/lose entities */ + ecs_trace("http: server thread shut down"); - int32_t i, term_count = query->filter.term_count_actual; - for (i = 0; i < term_count; i ++) { - int32_t t = query->filter.terms[i].index; - if (monitor[t + 1] == -1) { - continue; - } - - get_dirty_state(query, match, t, &cur); - ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); - monitor[t + 1] = cur.dirty_state[cur.column + 1]; + /* Cleanup all outstanding requests */ + int i, count = flecs_sparse_count(srv->requests); + for (i = count - 1; i >= 1; i --) { + request_free(flecs_sparse_get_dense( + srv->requests, ecs_http_request_impl_t, i)); + } + + /* Close all connections */ + count = flecs_sparse_count(srv->connections); + for (i = count - 1; i >= 1; i --) { + connection_free(flecs_sparse_get_dense( + srv->connections, ecs_http_connection_impl_t, i)); } + + ecs_assert(flecs_sparse_count(srv->connections) == 1, + ECS_INTERNAL_ERROR, NULL); + ecs_assert(flecs_sparse_count(srv->requests) == 1, + ECS_INTERNAL_ERROR, NULL); + + srv->thread = 0; +error: + return; } -/* Check if single match term has changed */ -static -bool check_match_monitor_term( - ecs_query_t *query, - ecs_query_table_match_t *match, - int32_t term) +void ecs_http_server_dequeue( + ecs_http_server_t* srv, + float delta_time) { - ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_check(srv != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(srv->initialized, ECS_INVALID_PARAMETER, NULL); + ecs_check(srv->should_run, ECS_INVALID_PARAMETER, NULL); + + srv->dequeue_timeout += delta_time; + srv->stats_timeout += delta_time; + + if ((1000 * srv->dequeue_timeout) > + (FLECS_FLOAT)ECS_HTTP_MIN_DEQUEUE_INTERVAL) + { + srv->dequeue_timeout = 0; + + ecs_time_t t = {0}; + ecs_time_measure(&t); + int32_t request_count = dequeue_requests(srv, srv->dequeue_timeout); + srv->requests_processed += request_count; + srv->requests_processed_total += request_count; + FLECS_FLOAT time_spent = (FLECS_FLOAT)ecs_time_measure(&t); + srv->request_time += time_spent; + srv->request_time_total += time_spent; + srv->dequeue_count ++; + } + + if ((1000 * srv->stats_timeout) > + (FLECS_FLOAT)ECS_HTTP_MIN_STATS_INTERVAL) + { + srv->stats_timeout = 0; + ecs_dbg("http: processed %d requests in %.3fs (avg %.3fs / dequeue)", + srv->requests_processed, (double)srv->request_time, + (double)(srv->request_time / (FLECS_FLOAT)srv->dequeue_count)); + srv->requests_processed = 0; + srv->request_time = 0; + srv->dequeue_count = 0; + } + +error: + return; +} + +#endif + + + +#ifdef FLECS_UNITS + +ECS_DECLARE(EcsUnitPrefixes); + +ECS_DECLARE(EcsYocto); +ECS_DECLARE(EcsZepto); +ECS_DECLARE(EcsAtto); +ECS_DECLARE(EcsFemto); +ECS_DECLARE(EcsPico); +ECS_DECLARE(EcsNano); +ECS_DECLARE(EcsMicro); +ECS_DECLARE(EcsMilli); +ECS_DECLARE(EcsCenti); +ECS_DECLARE(EcsDeci); +ECS_DECLARE(EcsDeca); +ECS_DECLARE(EcsHecto); +ECS_DECLARE(EcsKilo); +ECS_DECLARE(EcsMega); +ECS_DECLARE(EcsGiga); +ECS_DECLARE(EcsTera); +ECS_DECLARE(EcsPeta); +ECS_DECLARE(EcsExa); +ECS_DECLARE(EcsZetta); +ECS_DECLARE(EcsYotta); - if (get_match_monitor(query, match)) { - return true; - } - - int32_t *monitor = match->monitor; - ecs_table_t *table = match->table; - int32_t *dirty_state = flecs_table_get_dirty_state(table); - ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); - table_dirty_state_t cur; +ECS_DECLARE(EcsKibi); +ECS_DECLARE(EcsMebi); +ECS_DECLARE(EcsGibi); +ECS_DECLARE(EcsTebi); +ECS_DECLARE(EcsPebi); +ECS_DECLARE(EcsExbi); +ECS_DECLARE(EcsZebi); +ECS_DECLARE(EcsYobi); - int32_t state = monitor[term]; - if (state == -1) { - return false; - } +ECS_DECLARE(EcsDuration); + ECS_DECLARE(EcsPicoSeconds); + ECS_DECLARE(EcsNanoSeconds); + ECS_DECLARE(EcsMicroSeconds); + ECS_DECLARE(EcsMilliSeconds); + ECS_DECLARE(EcsSeconds); + ECS_DECLARE(EcsMinutes); + ECS_DECLARE(EcsHours); + ECS_DECLARE(EcsDays); - if (!term) { - return monitor[0] != dirty_state[0]; - } +ECS_DECLARE(EcsTime); + ECS_DECLARE(EcsDate); - get_dirty_state(query, match, term - 1, &cur); - ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); +ECS_DECLARE(EcsMass); + ECS_DECLARE(EcsGrams); + ECS_DECLARE(EcsKiloGrams); - return monitor[term] != cur.dirty_state[cur.column + 1]; -} +ECS_DECLARE(EcsElectricCurrent); + ECS_DECLARE(EcsAmpere); -/* Check if any term for match has changed */ -static -bool check_match_monitor( - ecs_query_t *query, - ecs_query_table_match_t *match) -{ - ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); +ECS_DECLARE(EcsAmount); + ECS_DECLARE(EcsMole); - if (get_match_monitor(query, match)) { - return true; - } +ECS_DECLARE(EcsLuminousIntensity); + ECS_DECLARE(EcsCandela); - int32_t *monitor = match->monitor; - ecs_table_t *table = match->table; - int32_t *dirty_state = flecs_table_get_dirty_state(table); - ecs_assert(dirty_state != NULL, ECS_INTERNAL_ERROR, NULL); - table_dirty_state_t cur; +ECS_DECLARE(EcsForce); + ECS_DECLARE(EcsNewton); - if (monitor[0] != dirty_state[0]) { - return true; - } +ECS_DECLARE(EcsLength); + ECS_DECLARE(EcsMeters); + ECS_DECLARE(EcsPicoMeters); + ECS_DECLARE(EcsNanoMeters); + ECS_DECLARE(EcsMicroMeters); + ECS_DECLARE(EcsMilliMeters); + ECS_DECLARE(EcsCentiMeters); + ECS_DECLARE(EcsKiloMeters); + ECS_DECLARE(EcsMiles); - ecs_filter_t *f = &query->filter; - int32_t i, term_count = f->term_count_actual; - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &f->terms[i]; - int32_t t = term->index; - if (monitor[t + 1] == -1) { - continue; - } +ECS_DECLARE(EcsPressure); + ECS_DECLARE(EcsPascal); + ECS_DECLARE(EcsBar); - get_dirty_state(query, match, t, &cur); - ecs_assert(cur.column != -1, ECS_INTERNAL_ERROR, NULL); +ECS_DECLARE(EcsSpeed); + ECS_DECLARE(EcsMetersPerSecond); + ECS_DECLARE(EcsKiloMetersPerSecond); + ECS_DECLARE(EcsKiloMetersPerHour); + ECS_DECLARE(EcsMilesPerHour); - if (monitor[t + 1] != cur.dirty_state[cur.column + 1]) { - return true; - } - } +ECS_DECLARE(EcsAcceleration); - return false; -} +ECS_DECLARE(EcsTemperature); + ECS_DECLARE(EcsKelvin); + ECS_DECLARE(EcsCelsius); + ECS_DECLARE(EcsFahrenheit); -/* Check if any term for matched table has changed */ -static -bool check_table_monitor( - ecs_query_t *query, - ecs_query_table_t *table, - int32_t term) -{ - ecs_query_table_node_t *cur, *end = table->last->node.next; +ECS_DECLARE(EcsData); + ECS_DECLARE(EcsBits); + ECS_DECLARE(EcsKiloBits); + ECS_DECLARE(EcsMegaBits); + ECS_DECLARE(EcsGigaBits); + ECS_DECLARE(EcsBytes); + ECS_DECLARE(EcsKiloBytes); + ECS_DECLARE(EcsMegaBytes); + ECS_DECLARE(EcsGigaBytes); + ECS_DECLARE(EcsKibiBytes); + ECS_DECLARE(EcsGibiBytes); + ECS_DECLARE(EcsMebiBytes); - for (cur = &table->first->node; cur != end; cur = cur->next) { - ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur; - if (term == -1) { - if (check_match_monitor(query, match)) { - return true; - } - } else { - if (check_match_monitor_term(query, match, term)) { - return true; - } - } - } +ECS_DECLARE(EcsDataRate); + ECS_DECLARE(EcsBitsPerSecond); + ECS_DECLARE(EcsKiloBitsPerSecond); + ECS_DECLARE(EcsMegaBitsPerSecond); + ECS_DECLARE(EcsGigaBitsPerSecond); + ECS_DECLARE(EcsBytesPerSecond); + ECS_DECLARE(EcsKiloBytesPerSecond); + ECS_DECLARE(EcsMegaBytesPerSecond); + ECS_DECLARE(EcsGigaBytesPerSecond); - return false; -} +ECS_DECLARE(EcsPercentage); -static -bool check_query_monitor( - ecs_query_t *query) -{ - ecs_table_cache_iter_t it; - if (flecs_table_cache_iter(&query->cache, &it)) { - ecs_query_table_t *qt; - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - if (check_table_monitor(query, qt, -1)) { - return true; - } - } - } +ECS_DECLARE(EcsAngle); + ECS_DECLARE(EcsRadians); + ECS_DECLARE(EcsDegrees); - return false; -} +ECS_DECLARE(EcsBel); +ECS_DECLARE(EcsDeciBel); -static -void init_query_monitors( - ecs_query_t *query) +void FlecsUnitsImport( + ecs_world_t *world) { - ecs_query_table_node_t *cur = query->list.first; + ECS_MODULE(world, FlecsUnits); - /* Ensure each match has a monitor */ - for (; cur != NULL; cur = cur->next) { - ecs_query_table_match_t *match = (ecs_query_table_match_t*)cur; - get_match_monitor(query, match); - } -} + ecs_set_name_prefix(world, "Ecs"); -/* Builtin group_by callback for Cascade terms. - * This function traces the hierarchy depth of an entity type by following a - * relation upwards (to its 'parents') for as long as those parents have the - * specified component id. - * The result of the function is the number of parents with the provided - * component for a given relation. */ -static -uint64_t group_by_cascade( - ecs_world_t *world, - ecs_type_t type, - ecs_entity_t component, - void *ctx) -{ - uint64_t result = 0; - int32_t i, count = ecs_vector_count(type); - ecs_entity_t *array = ecs_vector_first(type, ecs_entity_t); - ecs_term_t *term = ctx; - ecs_entity_t relation = term->subj.set.relation; + EcsUnitPrefixes = ecs_entity_init(world, &(ecs_entity_desc_t) { + .name = "prefixes", + .add = { EcsModule } + }); - /* Cascade needs a relation to calculate depth from */ - ecs_check(relation != 0, ECS_INVALID_PARAMETER, NULL); + /* Initialize unit prefixes */ - /* Should only be used with cascade terms */ - ecs_check(term->subj.set.mask & EcsCascade, ECS_INVALID_PARAMETER, NULL); + ecs_entity_t prev_scope = ecs_set_scope(world, EcsUnitPrefixes); - /* Iterate back to front as relations are more likely to occur near the - * end of a type. */ - for (i = count - 1; i >= 0; i --) { - /* Find relation & relation object in entity type */ - if (ECS_HAS_RELATION(array[i], relation)) { - ecs_type_t obj_type = ecs_get_type(world, - ecs_pair_second(world, array[i])); - int32_t j, c_count = ecs_vector_count(obj_type); - ecs_entity_t *c_array = ecs_vector_first(obj_type, ecs_entity_t); + EcsYocto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Yocto", + .symbol = "y", + .translation = { .factor = 10, .power = -24 } + }); + EcsZepto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Zepto", + .symbol = "z", + .translation = { .factor = 10, .power = -21 } + }); + EcsAtto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Atto", + .symbol = "a", + .translation = { .factor = 10, .power = -18 } + }); + EcsFemto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Femto", + .symbol = "a", + .translation = { .factor = 10, .power = -15 } + }); + EcsPico = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Pico", + .symbol = "p", + .translation = { .factor = 10, .power = -12 } + }); + EcsNano = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Nano", + .symbol = "n", + .translation = { .factor = 10, .power = -9 } + }); + EcsMicro = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Micro", + .symbol = "μ", + .translation = { .factor = 10, .power = -6 } + }); + EcsMilli = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Milli", + .symbol = "m", + .translation = { .factor = 10, .power = -3 } + }); + EcsCenti = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Centi", + .symbol = "c", + .translation = { .factor = 10, .power = -2 } + }); + EcsDeci = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Deci", + .symbol = "d", + .translation = { .factor = 10, .power = -1 } + }); + EcsDeca = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Deca", + .symbol = "da", + .translation = { .factor = 10, .power = 1 } + }); + EcsHecto = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Hecto", + .symbol = "h", + .translation = { .factor = 10, .power = 2 } + }); + EcsKilo = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Kilo", + .symbol = "k", + .translation = { .factor = 10, .power = 3 } + }); + EcsMega = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Mega", + .symbol = "M", + .translation = { .factor = 10, .power = 6 } + }); + EcsGiga = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Giga", + .symbol = "G", + .translation = { .factor = 10, .power = 9 } + }); + EcsTera = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Tera", + .symbol = "T", + .translation = { .factor = 10, .power = 12 } + }); + EcsPeta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Peta", + .symbol = "P", + .translation = { .factor = 10, .power = 15 } + }); + EcsExa = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Exa", + .symbol = "E", + .translation = { .factor = 10, .power = 18 } + }); + EcsZetta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Zetta", + .symbol = "Z", + .translation = { .factor = 10, .power = 21 } + }); + EcsYotta = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Yotta", + .symbol = "Y", + .translation = { .factor = 10, .power = 24 } + }); - /* Iterate object type, check if it has the specified component */ - for (j = 0; j < c_count; j ++) { - /* If it has the component, it is part of the tree matched by - * the query, increase depth */ - if (c_array[j] == component) { - result ++; + EcsKibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Kibi", + .symbol = "Ki", + .translation = { .factor = 1024, .power = 1 } + }); + EcsMebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Mebi", + .symbol = "Mi", + .translation = { .factor = 1024, .power = 2 } + }); + EcsGibi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Gibi", + .symbol = "Gi", + .translation = { .factor = 1024, .power = 3 } + }); + EcsTebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Tebi", + .symbol = "Ti", + .translation = { .factor = 1024, .power = 4 } + }); + EcsPebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Pebi", + .symbol = "Pi", + .translation = { .factor = 1024, .power = 5 } + }); + EcsExbi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Exbi", + .symbol = "Ei", + .translation = { .factor = 1024, .power = 6 } + }); + EcsZebi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Zebi", + .symbol = "Zi", + .translation = { .factor = 1024, .power = 7 } + }); + EcsYobi = ecs_unit_prefix_init(world, &(ecs_unit_prefix_desc_t) { + .entity.name = "Yobi", + .symbol = "Yi", + .translation = { .factor = 1024, .power = 8 } + }); - /* Recurse to test if the object has matching parents */ - result += group_by_cascade(world, obj_type, component, ctx); - break; - } - } + ecs_set_scope(world, prev_scope); - if (j != c_count) { - break; - } + /* Duration units */ - /* If the id doesn't have a role set, we'll find no more relations */ - } else if (!(array[i] & ECS_ROLE_MASK)) { - break; - } - } + EcsDuration = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Duration" }); + prev_scope = ecs_set_scope(world, EcsDuration); - return result; -error: - return 0; -} + EcsSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Seconds", + .quantity = EcsDuration, + .symbol = "s" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsSeconds, + .kind = EcsF32 + }); + EcsPicoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "PicoSeconds", + .quantity = EcsDuration, + .base = EcsSeconds, + .prefix = EcsPico }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsPicoSeconds, + .kind = EcsF32 + }); -static -int get_comp_and_src( - ecs_world_t *world, - ecs_query_t *query, - int32_t t, - ecs_table_t *table_arg, - ecs_entity_t *component_out, - ecs_entity_t *entity_out, - bool *match_out) -{ - ecs_entity_t component = 0, entity = 0; - ecs_term_t *terms = query->filter.terms; - int32_t term_count = query->filter.term_count; - ecs_term_t *term = &terms[t]; - ecs_term_id_t *subj = &term->subj; - ecs_oper_kind_t op = term->oper; + EcsNanoSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "NanoSeconds", + .quantity = EcsDuration, + .base = EcsSeconds, + .prefix = EcsNano }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsNanoSeconds, + .kind = EcsF32 + }); - *match_out = true; + EcsMicroSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MicroSeconds", + .quantity = EcsDuration, + .base = EcsSeconds, + .prefix = EcsMicro }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMicroSeconds, + .kind = EcsF32 + }); - if (op == EcsNot) { - entity = subj->entity; - } + EcsMilliSeconds = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MilliSeconds", + .quantity = EcsDuration, + .base = EcsSeconds, + .prefix = EcsMilli }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMilliSeconds, + .kind = EcsF32 + }); - if (!subj->entity) { - component = term->id; - } else { - ecs_table_t *table = table_arg; - if (subj->entity != EcsThis) { - table = ecs_get_table(world, subj->entity); - } + EcsMinutes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Minutes", + .quantity = EcsDuration, + .base = EcsSeconds, + .symbol = "min", + .translation = { .factor = 60, .power = 1 } }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMinutes, + .kind = EcsU32 + }); - if (op == EcsOr) { - for (; t < term_count; t ++) { - term = &terms[t]; + EcsHours = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Hours", + .quantity = EcsDuration, + .base = EcsMinutes, + .symbol = "h", + .translation = { .factor = 60, .power = 1 } }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsHours, + .kind = EcsU32 + }); - /* Keep iterating until the next non-OR expression */ - if (term->oper != EcsOr) { - t --; - break; - } + EcsDays = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Days", + .quantity = EcsDuration, + .base = EcsHours, + .symbol = "d", + .translation = { .factor = 24, .power = 1 } }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsDays, + .kind = EcsU32 + }); + ecs_set_scope(world, prev_scope); - if (!component) { - ecs_entity_t source = 0; - int32_t result = ecs_search_relation(world, table, - 0, term->id, subj->set.relation, subj->set.min_depth, - subj->set.max_depth, &source, NULL, NULL); + /* Time units */ - if (result != -1) { - component = term->id; - } + EcsTime = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Time" }); + prev_scope = ecs_set_scope(world, EcsTime); - if (source) { - entity = source; - } - } - } - } else { - component = term->id; + EcsDate = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Date", + .quantity = EcsTime }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsDate, + .kind = EcsU32 + }); + ecs_set_scope(world, prev_scope); - ecs_entity_t source = 0; - bool result = ecs_search_relation(world, table, 0, component, - subj->set.relation, subj->set.min_depth, subj->set.max_depth, - &source, NULL, NULL) != -1; + /* Mass units */ - *match_out = result; + EcsMass = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Mass" }); + prev_scope = ecs_set_scope(world, EcsMass); + EcsGrams = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Grams", + .quantity = EcsMass, + .symbol = "g" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGrams, + .kind = EcsF32 + }); + EcsKiloGrams = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloGrams", + .quantity = EcsMass, + .prefix = EcsKilo, + .base = EcsGrams }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloGrams, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - if (op == EcsNot) { - result = !result; - } + /* Electric current units */ - /* Optional terms may not have the component. *From terms contain - * the id of a type of which the contents must match, but the type - * itself does not need to match. */ - if (op == EcsOptional || op == EcsAndFrom || op == EcsOrFrom || - op == EcsNotFrom) - { - result = true; - } + EcsElectricCurrent = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "ElectricCurrent" }); + prev_scope = ecs_set_scope(world, EcsElectricCurrent); + EcsAmpere = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Ampere", + .quantity = EcsElectricCurrent, + .symbol = "A" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsAmpere, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - /* Table has already been matched, so unless column is optional - * any components matched from the table must be available. */ - if (table == table_arg) { - ecs_assert(result == true, ECS_INTERNAL_ERROR, NULL); - } + /* Amount of substance units */ - if (source) { - entity = source; - } - } + EcsAmount = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Amount" }); + prev_scope = ecs_set_scope(world, EcsAmount); + EcsMole = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Mole", + .quantity = EcsAmount, + .symbol = "mol" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMole, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - if (subj->entity != EcsThis) { - entity = subj->entity; - } - } + /* Luminous intensity units */ - if (entity == EcsThis) { - entity = 0; - } + EcsLuminousIntensity = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "LuminousIntensity" }); + prev_scope = ecs_set_scope(world, EcsLuminousIntensity); + EcsCandela = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Candela", + .quantity = EcsLuminousIntensity, + .symbol = "cd" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsCandela, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - *component_out = component; - *entity_out = entity; + /* Force units */ - return t; -} + EcsForce = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Force" }); + prev_scope = ecs_set_scope(world, EcsForce); + EcsNewton = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Newton", + .quantity = EcsForce, + .symbol = "N" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsNewton, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); -typedef struct pair_offset_t { - int32_t index; - int32_t count; -} pair_offset_t; + /* Length units */ -/* Get index for specified pair. Take into account that a pair can be matched - * multiple times per table, by keeping an offset of the last found index */ -static -int32_t get_pair_index( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_id_t pair, - int32_t column_index, - pair_offset_t *pair_offsets, - int32_t count) -{ - int32_t result; + EcsLength = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Length" }); + prev_scope = ecs_set_scope(world, EcsLength); + EcsMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Meters", + .quantity = EcsLength, + .symbol = "m" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMeters, + .kind = EcsF32 + }); - /* The count variable keeps track of the number of times a pair has been - * matched with the current table. Compare the count to check if the index - * was already resolved for this iteration */ - if (pair_offsets[column_index].count == count) { - /* If it was resolved, return the last stored index. Subtract one as the - * index is offset by one, to ensure we're not getting stuck on the same - * index. */ - result = pair_offsets[column_index].index - 1; - } else { - /* First time for this iteration that the pair index is resolved, look - * it up in the type. */ - result = ecs_search_offset(world, table, - pair_offsets[column_index].index, pair, 0); - pair_offsets[column_index].index = result + 1; - pair_offsets[column_index].count = count; - } + EcsPicoMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "PicoMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsPico }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsPicoMeters, + .kind = EcsF32 + }); - return result; -} + EcsNanoMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "NanoMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsNano }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsNanoMeters, + .kind = EcsF32 + }); -static -int32_t get_component_index( - ecs_world_t *world, - ecs_table_t *table, - ecs_type_t table_type, - ecs_entity_t *component_out, - int32_t column_index, - ecs_oper_kind_t op, - pair_offset_t *pair_offsets, - int32_t count) -{ - int32_t result = 0; - ecs_entity_t component = *component_out; + EcsMicroMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MicroMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsMicro }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMicroMeters, + .kind = EcsF32 + }); - ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); + EcsMilliMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MilliMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsMilli }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMilliMeters, + .kind = EcsF32 + }); - if (component) { - /* If requested component is a case, find the corresponding switch to - * lookup in the table */ - if (ECS_HAS_ROLE(component, CASE)) { - ecs_entity_t sw = ECS_PAIR_FIRST(component); - result = ecs_search(world, table, ECS_SWITCH | sw, 0); - ecs_assert(result != -1, ECS_INTERNAL_ERROR, NULL); - } else - if (ECS_HAS_ROLE(component, PAIR)) { - ecs_entity_t rel = ECS_PAIR_FIRST(component); - ecs_entity_t obj = ECS_PAIR_SECOND(component); + EcsCentiMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "CentiMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsCenti }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsCentiMeters, + .kind = EcsF32 + }); - /* Both the relationship and the object of the pair must be set */ - ecs_assert(rel != 0, ECS_INVALID_PARAMETER, NULL); - ecs_assert(obj != 0, ECS_INVALID_PARAMETER, NULL); + EcsKiloMeters = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloMeters", + .quantity = EcsLength, + .base = EcsMeters, + .prefix = EcsKilo }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloMeters, + .kind = EcsF32 + }); + + EcsMiles = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Miles", + .quantity = EcsLength, + .symbol = "mi" + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMiles, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - if (rel == EcsWildcard || obj == EcsWildcard) { - ecs_assert(pair_offsets != NULL, ECS_INTERNAL_ERROR, NULL); + /* Pressure units */ - /* Get index of pair. Start looking from the last pair index - * as this may not be the first instance of the pair. */ - result = get_pair_index(world, table, component, column_index, - pair_offsets, count); - - if (result != -1) { - /* If component of current column is a pair, get the actual - * pair type for the table, so the system can see which - * component the pair was applied to */ - ecs_entity_t *pair = ecs_vector_get( - table_type, ecs_entity_t, result); - *component_out = *pair; + EcsPressure = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Pressure" }); + prev_scope = ecs_set_scope(world, EcsPressure); + EcsPascal = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Pascal", + .quantity = EcsPressure, + .symbol = "Pa" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsPascal, + .kind = EcsF32 + }); + EcsBar = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Bar", + .quantity = EcsPressure, + .symbol = "bar" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBar, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - /* Check if the pair is a tag or whether it has data */ - if (ecs_get(world, rel, EcsComponent) == NULL) { - /* If pair has no data associated with it, use the - * component to which the pair has been added */ - component = ECS_PAIR_SECOND(*pair); - } else { - component = rel; - } - } - } else { - /* If the low part is a regular entity (component), then - * this query exactly matches a single pair instance. In - * this case we can simply do a lookup of the pair - * identifier in the table type. */ - result = ecs_search(world, table, component, 0); - } - } else { - /* Get column index for component */ - result = ecs_search(world, table, component, 0); - } + /* Speed units */ - /* If column is found, add one to the index, as column zero in - * a table is reserved for entity id's */ - if (result != -1) { - result ++; - } + EcsSpeed = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Speed" }); + prev_scope = ecs_set_scope(world, EcsSpeed); + EcsMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MetersPerSecond", + .quantity = EcsSpeed, + .base = EcsMeters, + .over = EcsSeconds }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMetersPerSecond, + .kind = EcsF32 + }); + EcsKiloMetersPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloMetersPerSecond", + .quantity = EcsSpeed, + .base = EcsKiloMeters, + .over = EcsSeconds }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloMetersPerSecond, + .kind = EcsF32 + }); + EcsKiloMetersPerHour = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloMetersPerHour", + .quantity = EcsSpeed, + .base = EcsKiloMeters, + .over = EcsHours }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloMetersPerHour, + .kind = EcsF32 + }); + EcsMilesPerHour = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MilesPerHour", + .quantity = EcsSpeed, + .base = EcsMiles, + .over = EcsHours }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMilesPerHour, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); + + /* Acceleration */ - /* ecs_table_column_offset may return -1 if the component comes - * from a prefab. If so, the component will be resolved as a - * reference (see below) */ - } + EcsAcceleration = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Acceleration", + .base = EcsMetersPerSecond, + .over = EcsSeconds }); + ecs_quantity_init(world, &(ecs_entity_desc_t) { + .entity = EcsAcceleration + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsAcceleration, + .kind = EcsF32 + }); - if (op == EcsAndFrom || op == EcsOrFrom || op == EcsNotFrom) { - result = 0; - } else if (op == EcsOptional) { - /* If table doesn't have the field, mark it as no data */ - if (-1 == ecs_search_relation(world, table, 0, component, EcsIsA, - 0, 0, 0, 0, 0)) - { - result = 0; - } - } + /* Temperature units */ - return result; -} + EcsTemperature = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Temperature" }); + prev_scope = ecs_set_scope(world, EcsTemperature); + EcsKelvin = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Kelvin", + .quantity = EcsTemperature, + .symbol = "K" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKelvin, + .kind = EcsF32 + }); + EcsCelsius = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Celsius", + .quantity = EcsTemperature, + .symbol = "°C" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsCelsius, + .kind = EcsF32 + }); + EcsFahrenheit = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Fahrenheit", + .quantity = EcsTemperature, + .symbol = "F" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsFahrenheit, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); -static -ecs_vector_t* add_ref( - ecs_world_t *world, - ecs_query_t *query, - ecs_vector_t *references, - ecs_term_t *term, - ecs_entity_t component, - ecs_entity_t entity) -{ - ecs_ref_t *ref = ecs_vector_add(&references, ecs_ref_t); - ecs_term_id_t *subj = &term->subj; + /* Data units */ - if (!(subj->set.mask & EcsCascade)) { - ecs_assert(entity != 0, ECS_INTERNAL_ERROR, NULL); - } - - *ref = (ecs_ref_t){0}; - ref->entity = entity; - ref->component = component; + EcsData = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Data" }); + prev_scope = ecs_set_scope(world, EcsData); - const EcsComponent *c_info = flecs_component_from_id(world, component); - if (c_info) { - if (c_info->size && subj->entity != 0) { - if (entity) { - ecs_get_ref_id(world, ref, entity, component); - } + EcsBits = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Bits", + .quantity = EcsData, + .symbol = "bit" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBits, + .kind = EcsU64 + }); - query->flags |= EcsQueryHasRefs; - } - } + EcsKiloBits = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloBits", + .quantity = EcsData, + .base = EcsBits, + .prefix = EcsKilo }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloBits, + .kind = EcsU64 + }); - return references; -} + EcsMegaBits = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MegaBits", + .quantity = EcsData, + .base = EcsBits, + .prefix = EcsMega }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMegaBits, + .kind = EcsU64 + }); -static -int32_t get_pair_count( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_entity_t pair) -{ - int32_t i = -1, result = 0; - while (-1 != (i = ecs_search_offset(world, table, i + 1, pair, 0))) { - result ++; - } + EcsGigaBits = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "GigaBits", + .quantity = EcsData, + .base = EcsBits, + .prefix = EcsGiga }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGigaBits, + .kind = EcsU64 + }); + + EcsBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Bytes", + .quantity = EcsData, + .symbol = "B", + .base = EcsBits, + .translation = { .factor = 8, .power = 1 } }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBytes, + .kind = EcsU64 + }); - return result; -} + EcsKiloBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsKilo }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloBytes, + .kind = EcsU64 + }); -/* For each pair that the query subscribes for, count the occurrences in the - * table. Cardinality of subscribed for pairs must be the same as in the table - * or else the table won't match. */ -static -int32_t count_pairs( - const ecs_world_t *world, - const ecs_query_t *query, - const ecs_table_t *table) -{ - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count; - int32_t first_count = 0, pair_count = 0; + EcsMegaBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MegaBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsMega }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMegaBytes, + .kind = EcsU64 + }); - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; + EcsGigaBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "GigaBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsGiga }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGigaBytes, + .kind = EcsU64 + }); - if (!ECS_HAS_ROLE(term->id, PAIR)) { - continue; - } + EcsKibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KibiBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsKibi }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKibiBytes, + .kind = EcsU64 + }); - if (term->subj.entity != EcsThis) { - continue; - } + EcsMebiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MebiBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsMebi }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMebiBytes, + .kind = EcsU64 + }); - if (ecs_id_is_wildcard(term->id)) { - pair_count = get_pair_count(world, table, term->id); - if (!first_count) { - first_count = pair_count; - } else { - if (first_count != pair_count) { - /* The pairs that this query subscribed for occur in the - * table but don't have the same cardinality. Ignore the - * table. This could typically happen for empty tables along - * a path in the table graph. */ - return -1; - } - } - } - } + EcsGibiBytes = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "GibiBytes", + .quantity = EcsData, + .base = EcsBytes, + .prefix = EcsGibi }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGibiBytes, + .kind = EcsU64 + }); - return first_count; -} + ecs_set_scope(world, prev_scope); -static -ecs_type_t get_term_type( - ecs_world_t *world, - ecs_term_t *term, - ecs_entity_t component) -{ - ecs_oper_kind_t oper = term->oper; - ecs_assert(oper == EcsAndFrom || oper == EcsOrFrom || oper == EcsNotFrom, - ECS_INTERNAL_ERROR, NULL); - (void)oper; + /* DataRate units */ - const EcsType *type = ecs_get(world, component, EcsType); - if (type) { - return type->normalized->type; - } else { - return ecs_get_type(world, component); - } -} + EcsDataRate = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "DataRate" }); + prev_scope = ecs_set_scope(world, EcsDataRate); -/** Add table to system, compute offsets for system components in table it */ -static -void add_table( - ecs_world_t *world, - ecs_query_t *query, - ecs_table_t *table) -{ - ecs_type_t table_type = NULL; - ecs_term_t *terms = query->filter.terms; - int32_t t, c, term_count = query->filter.term_count; + EcsBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "BitsPerSecond", + .quantity = EcsDataRate, + .base = EcsBits, + .over = EcsSeconds }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBitsPerSecond, + .kind = EcsU64 + }); - if (table) { - table_type = table->type; - } + EcsKiloBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloBitsPerSecond", + .quantity = EcsDataRate, + .base = EcsKiloBits, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloBitsPerSecond, + .kind = EcsU64 + }); - int32_t pair_cur = 0, pair_count = count_pairs(world, query, table); - - /* If the query has pairs, we need to account for the fact that a table may - * have multiple components to which the pair is applied, which means the - * table has to be registered with the query multiple times, with different - * table columns. If so, allocate a small array for each pair in which the - * last added table index of the pair is stored, so that in the next - * iteration we can start the search from the correct offset type. */ - pair_offset_t *pair_offsets = NULL; - if (pair_count) { - pair_offsets = ecs_os_calloc( - ECS_SIZEOF(pair_offset_t) * term_count); - } + EcsMegaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MegaBitsPerSecond", + .quantity = EcsDataRate, + .base = EcsMegaBits, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMegaBitsPerSecond, + .kind = EcsU64 + }); - ecs_query_table_match_t *table_data; - ecs_vector_t *references = NULL; + EcsGigaBitsPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "GigaBitsPerSecond", + .quantity = EcsDataRate, + .base = EcsGigaBits, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGigaBitsPerSecond, + .kind = EcsU64 + }); - ecs_query_table_t *qt = ecs_os_calloc_t(ecs_query_table_t); - ecs_table_cache_insert(&query->cache, table, &qt->hdr); + EcsBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "BytesPerSecond", + .quantity = EcsDataRate, + .base = EcsBytes, + .over = EcsSeconds }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBytesPerSecond, + .kind = EcsU64 + }); -add_pair: - table_data = cache_add(qt); - table_data->table = table; - if (table) { - table_type = table->type; - } + EcsKiloBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "KiloBytesPerSecond", + .quantity = EcsDataRate, + .base = EcsKiloBytes, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsKiloBytesPerSecond, + .kind = EcsU64 + }); - if (term_count) { - /* Array that contains the system column to table column mapping */ - table_data->columns = ecs_os_calloc_n(int32_t, query->filter.term_count_actual); - ecs_assert(table_data->columns != NULL, ECS_OUT_OF_MEMORY, NULL); + EcsMegaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "MegaBytesPerSecond", + .quantity = EcsDataRate, + .base = EcsMegaBytes, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsMegaBytesPerSecond, + .kind = EcsU64 + }); - /* Store the components of the matched table. In the case of OR expressions, - * components may differ per matched table. */ - table_data->ids = ecs_os_calloc_n(ecs_entity_t, query->filter.term_count_actual); - ecs_assert(table_data->ids != NULL, ECS_OUT_OF_MEMORY, NULL); + EcsGigaBytesPerSecond = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "GigaBytesPerSecond", + .quantity = EcsDataRate, + .base = EcsGigaBytes, + .over = EcsSeconds + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsGigaBytesPerSecond, + .kind = EcsU64 + }); - /* Cache subject (source) entity ids for components */ - table_data->subjects = ecs_os_calloc_n(ecs_entity_t, query->filter.term_count_actual); - ecs_assert(table_data->subjects != NULL, ECS_OUT_OF_MEMORY, NULL); + ecs_set_scope(world, prev_scope); - /* Cache subject (source) entity ids for components */ - table_data->sizes = ecs_os_calloc_n(ecs_size_t, query->filter.term_count_actual); - ecs_assert(table_data->sizes != NULL, ECS_OUT_OF_MEMORY, NULL); - } + /* Percentage */ - /* Walk columns parsed from the system signature */ - c = 0; - for (t = 0; t < term_count; t ++) { - ecs_term_t *term = &terms[t]; - ecs_term_id_t subj = term->subj; - ecs_entity_t entity = 0, component = 0; - ecs_oper_kind_t op = term->oper; + EcsPercentage = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Percentage" }); + ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.entity = EcsPercentage, + .symbol = "%" + }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsPercentage, + .kind = EcsF32 + }); - if (op == EcsNot) { - subj.entity = 0; - } + /* Angles */ - /* Get actual component and component source for current column */ - bool match; - t = get_comp_and_src(world, query, t, table, &component, &entity, &match); + EcsAngle = ecs_quantity_init(world, &(ecs_entity_desc_t) { + .name = "Angle" }); + prev_scope = ecs_set_scope(world, EcsAngle); + EcsRadians = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Radians", + .quantity = EcsAngle, + .symbol = "rad" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsRadians, + .kind = EcsF32 + }); - /* This column does not retrieve data from a static entity */ - if (!entity && subj.entity) { - int32_t index = get_component_index(world, table, table_type, - &component, c, op, pair_offsets, pair_cur + 1); + EcsDegrees = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Degrees", + .quantity = EcsAngle, + .symbol = "°" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsDegrees, + .kind = EcsF32 + }); + ecs_set_scope(world, prev_scope); - if (index == -1) { - if (op == EcsOptional && subj.set.mask == EcsSelf) { - index = 0; - } - } else { - if (op == EcsOptional && !(subj.set.mask & EcsSelf)) { - index = 0; - } - } + /* DeciBel */ - table_data->columns[c] = index; + EcsBel = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "Bel", + .symbol = "B" }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsBel, + .kind = EcsF32 + }); + EcsDeciBel = ecs_unit_init(world, &(ecs_unit_desc_t) { + .entity.name = "DeciBel", + .prefix = EcsDeci, + .base = EcsBel }); + ecs_primitive_init(world, &(ecs_primitive_desc_t) { + .entity.entity = EcsDeciBel, + .kind = EcsF32 + }); - /* If the column is a case, we should only iterate the entities in - * the column for this specific case. Add a sparse column with the - * case id so we can find the correct entities when iterating */ - if (ECS_HAS_ROLE(component, CASE)) { - flecs_sparse_column_t *sc = ecs_vector_add( - &table_data->sparse_columns, flecs_sparse_column_t); - sc->signature_column_index = t; - sc->sw_case = ECS_PAIR_SECOND(component); - sc->sw_column = NULL; - } + /* Documentation */ +#ifdef FLECS_DOC + ECS_IMPORT(world, FlecsDoc); - /* If table has a disabled bitmask for components, check if there is - * a disabled column for the queried for component. If so, cache it - * in a vector as the iterator will need to skip the entity when the - * component is disabled. */ - if (index && (table && table->flags & EcsTableHasDisabled)) { - ecs_entity_t bs_id = - (component & ECS_COMPONENT_MASK) | ECS_DISABLED; - int32_t bs_index = ecs_search(world, table, bs_id, 0); - if (bs_index != -1) { - flecs_bitset_column_t *elem = ecs_vector_add( - &table_data->bitset_columns, flecs_bitset_column_t); - elem->column_index = bs_index; - elem->bs_column = NULL; - } - } - } + ecs_doc_set_brief(world, EcsDuration, + "Time amount (e.g. \"20 seconds\", \"2 hours\")"); + ecs_doc_set_brief(world, EcsSeconds, "Time amount in seconds"); + ecs_doc_set_brief(world, EcsMinutes, "60 seconds"); + ecs_doc_set_brief(world, EcsHours, "60 minutes"); + ecs_doc_set_brief(world, EcsDays, "24 hours"); - ecs_entity_t type_id = ecs_get_typeid(world, component); - if (!type_id && !(ECS_ROLE_MASK & component)) { - type_id = component; - } + ecs_doc_set_brief(world, EcsTime, + "Time passed since an epoch (e.g. \"5pm\", \"March 3rd 2022\")"); + ecs_doc_set_brief(world, EcsDate, + "Seconds passed since January 1st 1970"); - if (entity || table_data->columns[c] == -1 || subj.set.mask & EcsCascade) { - if (type_id) { - references = add_ref(world, query, references, term, - component, entity); - table_data->columns[c] = -ecs_vector_count(references); - } + ecs_doc_set_brief(world, EcsMass, "Units of mass (e.g. \"5 kilograms\")"); - table_data->subjects[c] = entity; - flecs_add_flag(world, entity, ECS_FLAG_OBSERVED); + ecs_doc_set_brief(world, EcsElectricCurrent, + "Units of electrical current (e.g. \"2 ampere\")"); - if (!match) { - ecs_ref_t *ref = ecs_vector_last(references, ecs_ref_t); - ref->entity = 0; - } - } + ecs_doc_set_brief(world, EcsAmount, + "Units of amount of substance (e.g. \"2 mole\")"); - if (type_id) { - const EcsComponent *cptr = ecs_get(world, type_id, EcsComponent); - if (!cptr || !cptr->size) { - int32_t column = table_data->columns[c]; - if (column < 0) { - ecs_ref_t *r = ecs_vector_get( - references, ecs_ref_t, -column - 1); - r->component = 0; - } - } + ecs_doc_set_brief(world, EcsLuminousIntensity, + "Units of luminous intensity (e.g. \"1 candela\")"); - if (cptr) { - table_data->sizes[c] = cptr->size; - } else { - table_data->sizes[c] = 0; - } - } else { - table_data->sizes[c] = 0; - } + ecs_doc_set_brief(world, EcsForce, "Units of force (e.g. \"10 newton\")"); + ecs_doc_set_brief(world, EcsLength, + "Units of length (e.g. \"5 meters\", \"20 miles\")"); - if (ECS_HAS_ROLE(component, SWITCH)) { - table_data->sizes[c] = ECS_SIZEOF(ecs_entity_t); - } else if (ECS_HAS_ROLE(component, CASE)) { - table_data->sizes[c] = ECS_SIZEOF(ecs_entity_t); - } + ecs_doc_set_brief(world, EcsPressure, + "Units of pressure (e.g. \"1 bar\", \"1000 pascal\")"); - table_data->ids[c] = component; + ecs_doc_set_brief(world, EcsSpeed, + "Units of movement (e.g. \"5 meters/second\")"); - c ++; - } + ecs_doc_set_brief(world, EcsAcceleration, + "Unit of speed increase (e.g. \"5 meters/second/second\")"); - if (references) { - ecs_size_t ref_size = ECS_SIZEOF(ecs_ref_t) * ecs_vector_count(references); - table_data->references = ecs_os_malloc(ref_size); - ecs_os_memcpy(table_data->references, - ecs_vector_first(references, ecs_ref_t), ref_size); - ecs_vector_free(references); - references = NULL; - } + ecs_doc_set_brief(world, EcsTemperature, + "Units of temperature (e.g. \"5 degrees Celsius\")"); - /* Insert match to iteration list if table is not empty */ - if (!table || ecs_table_count(table) != 0) { - ecs_assert(table == qt->hdr.table, ECS_INTERNAL_ERROR, NULL); - insert_table_node(query, &table_data->node); - } + ecs_doc_set_brief(world, EcsData, + "Units of information (e.g. \"8 bits\", \"100 megabytes\")"); - /* Use tail recursion when adding table for multiple pairs */ - pair_cur ++; - if (pair_cur < pair_count) { - goto add_pair; - } + ecs_doc_set_brief(world, EcsDataRate, + "Units of data transmission (e.g. \"100 megabits/second\")"); - if (pair_offsets) { - ecs_os_free(pair_offsets); - } -} + ecs_doc_set_brief(world, EcsAngle, + "Units of rotation (e.g. \"1.2 radians\", \"180 degrees\")"); -static -bool match_term( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_term_t *term) -{ - ecs_term_id_t *subj = &term->subj; +#endif +} - /* If term has no subject, there's nothing to match */ - if (!subj->entity) { - return true; - } +#endif - if (term->subj.entity != EcsThis) { - table = ecs_get_table(world, subj->entity); - } - return ecs_search_relation( - world, table, 0, term->id, subj->set.relation, - subj->set.min_depth, subj->set.max_depth, NULL, NULL, NULL) != -1; -} +#ifdef FLECS_SNAPSHOT -/* Match table with query */ -bool flecs_query_match( - const ecs_world_t *world, - const ecs_table_t *table, - const ecs_query_t *query) -{ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - if (!table->type) { - return false; - } - if (!(query->flags & EcsQueryNeedsTables)) { - return false; - } +/* World snapshot */ +struct ecs_snapshot_t { + ecs_world_t *world; + ecs_sparse_t *entity_index; + ecs_vector_t *tables; + ecs_entity_t last_id; + ecs_filter_t filter; +}; - /* Don't match disabled entities */ - if (!(query->flags & EcsQueryMatchDisabled) && ecs_search( - world, table, EcsDisabled, 0) != -1) - { - return false; - } +/** Small footprint data structure for storing data associated with a table. */ +typedef struct ecs_table_leaf_t { + ecs_table_t *table; + ecs_vector_t *type; + ecs_data_t *data; +} ecs_table_leaf_t; - /* Don't match prefab entities */ - if (!(query->flags & EcsQueryMatchPrefab) && ecs_search( - world, table, EcsPrefab, 0) != -1) - { - return false; +static +ecs_data_t* duplicate_data( + const ecs_world_t *world, + ecs_table_t *table, + ecs_data_t *main_data) +{ + if (!ecs_table_count(table)) { + return NULL; } - /* Check if pair cardinality matches pairs in query, if any */ - if (count_pairs(world, query, table) == -1) { - return false; - } + ecs_data_t *result = ecs_os_calloc(ECS_SIZEOF(ecs_data_t)); - ecs_term_t *terms = query->filter.terms; - int32_t i, term_count = query->filter.term_count; + ecs_type_t storage_type = table->storage_type; + int32_t i, column_count = ecs_vector_count(storage_type); + ecs_entity_t *components = ecs_vector_first(storage_type, ecs_entity_t); - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &terms[i]; - ecs_oper_kind_t oper = term->oper; + result->columns = ecs_os_memdup( + main_data->columns, ECS_SIZEOF(ecs_column_t) * column_count); - if (term->subj.var != EcsVarIsVariable || term->subj.entity != EcsThis){ - /* If term is matched on entity instead of This variable, it does - * not affect whether the table is matched */ - continue; - } + /* Copy entities */ + result->entities = ecs_vector_copy(main_data->entities, ecs_entity_t); + ecs_entity_t *entities = ecs_vector_first(result->entities, ecs_entity_t); - if (oper == EcsAnd) { - if (!match_term(world, table, term)) { - return false; - } + /* Copy record ptrs */ + result->record_ptrs = ecs_vector_copy( + main_data->record_ptrs, ecs_record_t*); - } else if (oper == EcsNot) { - if (match_term(world, table, term)) { - return false; - } + ecs_size_t to_alloc = ecs_vector_size(result->entities); - } else if (oper == EcsOr) { - bool match = false; + /* Copy each column */ + for (i = 0; i < column_count; i ++) { + ecs_entity_t component = components[i]; + ecs_column_t *column = &result->columns[i]; - for (; i < term_count; i ++) { - term = &terms[i]; - if (term->oper != EcsOr) { - i --; - break; - } + component = ecs_get_typeid(world, component); - if (!match && match_term( world, table, term)) { - match = true; - } - } + const ecs_type_info_t *ti = flecs_get_type_info(world, component); + int16_t size = column->size; + int16_t alignment = column->alignment; + ecs_copy_t copy; - if (!match) { - return false; + if (ti && (copy = ti->lifecycle.copy)) { + int32_t count = ecs_vector_count(column->data); + ecs_vector_t *dst_vec = ecs_vector_new_t(size, alignment, to_alloc); + ecs_vector_set_count_t(&dst_vec, size, alignment, count); + void *dst_ptr = ecs_vector_first_t(dst_vec, size, alignment); + + ecs_xtor_t ctor = ti->lifecycle.ctor; + if (ctor) { + ctor((ecs_world_t*)world, entities, dst_ptr, count, ti); } - - } else if (oper == EcsAndFrom || oper == EcsOrFrom || oper == EcsNotFrom) { - ecs_type_t type = get_term_type((ecs_world_t*)world, term, term->id); - int32_t match_count = 0, j, count = ecs_vector_count(type); - ecs_entity_t *ids = ecs_vector_first(type, ecs_entity_t); - - for (j = 0; j < count; j ++) { - ecs_term_t tmp_term = *term; - tmp_term.oper = EcsAnd; - tmp_term.id = ids[j]; - tmp_term.pred.entity = ids[j]; - if (match_term(world, table, &tmp_term)) { - match_count ++; - } - } + void *src_ptr = ecs_vector_first_t(column->data, size, alignment); + copy((ecs_world_t*)world, entities, entities, dst_ptr, + src_ptr, count, ti); - if (oper == EcsAndFrom && match_count != count) { - return false; - } - if (oper == EcsOrFrom && match_count == 0) { - return false; - } - if (oper == EcsNotFrom && match_count != 0) { - return false; - } + column->data = dst_vec; + } else { + column->data = ecs_vector_copy_t(column->data, size, alignment); } } - return true; + return result; } -/** Match existing tables against system (table is created before system) */ static -void match_tables( - ecs_world_t *world, - ecs_query_t *query) +void snapshot_table( + const ecs_world_t *world, + ecs_snapshot_t *snapshot, + ecs_table_t *table) { - int32_t i, count = flecs_sparse_count(&world->store.tables); - - for (i = 0; i < count; i ++) { - ecs_table_t *table = flecs_sparse_get_dense( - &world->store.tables, ecs_table_t, i); - - if (flecs_query_match(world, table, query)) { - add_table(world, query, table); - } + if (table->flags & EcsTableHasBuiltins) { + return; } + + ecs_table_leaf_t *l = ecs_vector_get( + snapshot->tables, ecs_table_leaf_t, (int32_t)table->id); + ecs_assert(l != NULL, ECS_INTERNAL_ERROR, NULL); + + l->table = table; + l->type = ecs_vector_copy(table->type, ecs_id_t); + l->data = duplicate_data(world, table, &table->storage); } static -int32_t qsort_partition( - ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - ecs_entity_t *entities, - void *ptr, - int32_t elem_size, - int32_t lo, - int32_t hi, - ecs_order_by_action_t compare) +ecs_snapshot_t* snapshot_create( + const ecs_world_t *world, + const ecs_sparse_t *entity_index, + ecs_iter_t *iter, + ecs_iter_next_action_t next) { - int32_t p = (hi + lo) / 2; - void *pivot = ECS_ELEM(ptr, elem_size, p); - ecs_entity_t pivot_e = entities[p]; - int32_t i = lo - 1, j = hi + 1; - void *el; - -repeat: - { - do { - i ++; - el = ECS_ELEM(ptr, elem_size, i); - } while ( compare(entities[i], el, pivot_e, pivot) < 0); - - do { - j --; - el = ECS_ELEM(ptr, elem_size, j); - } while ( compare(entities[j], el, pivot_e, pivot) > 0); - - if (i >= j) { - return j; - } + ecs_snapshot_t *result = ecs_os_calloc_t(ecs_snapshot_t); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); - flecs_table_swap(world, table, data, i, j); + ecs_force_aperiodic((ecs_world_t*)world); - if (p == i) { - pivot = ECS_ELEM(ptr, elem_size, j); - pivot_e = entities[j]; - } else if (p == j) { - pivot = ECS_ELEM(ptr, elem_size, i); - pivot_e = entities[i]; - } + result->world = (ecs_world_t*)world; - goto repeat; + /* If no iterator is provided, the snapshot will be taken of the entire + * world, and we can simply copy the entity index as it will be restored + * entirely upon snapshote restore. */ + if (!iter && entity_index) { + result->entity_index = flecs_sparse_copy(entity_index); } -} -static -void qsort_array( - ecs_world_t *world, - ecs_table_t *table, - ecs_data_t *data, - ecs_entity_t *entities, - void *ptr, - int32_t size, - int32_t lo, - int32_t hi, - ecs_order_by_action_t compare) -{ - if ((hi - lo) < 1) { - return; - } + /* Create vector with as many elements as tables, so we can store the + * snapshot tables at their element ids. When restoring a snapshot, the code + * will run a diff between the tables in the world and the snapshot, to see + * which of the world tables still exist, no longer exist, or need to be + * deleted. */ + uint64_t t, table_count = flecs_sparse_last_id(&world->store.tables) + 1; + result->tables = ecs_vector_new(ecs_table_leaf_t, (int32_t)table_count); + ecs_vector_set_count(&result->tables, ecs_table_leaf_t, (int32_t)table_count); + ecs_table_leaf_t *arr = ecs_vector_first(result->tables, ecs_table_leaf_t); - int32_t p = qsort_partition( - world, table, data, entities, ptr, size, lo, hi, compare); + /* Array may have holes, so initialize with 0 */ + ecs_os_memset_n(arr, 0, ecs_table_leaf_t, table_count); - qsort_array(world, table, data, entities, ptr, size, lo, p, compare); + /* Iterate tables in iterator */ + if (iter) { + while (next(iter)) { + ecs_table_t *table = iter->table; + snapshot_table(world, result, table); + } + } else { + for (t = 0; t < table_count; t ++) { + ecs_table_t *table = flecs_sparse_get( + &world->store.tables, ecs_table_t, t); + snapshot_table(world, result, table); + } + } - qsort_array(world, table, data, entities, ptr, size, p + 1, hi, compare); + return result; } -static -void sort_table( - ecs_world_t *world, - ecs_table_t *table, - int32_t column_index, - ecs_order_by_action_t compare) +/** Create a snapshot */ +ecs_snapshot_t* ecs_snapshot_take( + ecs_world_t *stage) { - ecs_data_t *data = &table->storage; - if (!data->entities) { - /* Nothing to sort */ - return; - } - - int32_t count = flecs_table_data_count(data); - if (count < 2) { - return; - } + const ecs_world_t *world = ecs_get_world(stage); - ecs_entity_t *entities = ecs_vector_first(data->entities, ecs_entity_t); + ecs_snapshot_t *result = snapshot_create( + world, ecs_eis(world), NULL, NULL); - void *ptr = NULL; - int32_t size = 0; - if (column_index != -1) { - ecs_column_t *column = &data->columns[column_index]; - size = column->size; - ptr = ecs_vector_first_t(column->data, size, column->alignment); - } + result->last_id = world->stats.last_id; - qsort_array(world, table, data, entities, ptr, size, 0, count - 1, compare); + return result; } -/* Helper struct for building sorted table ranges */ -typedef struct sort_helper_t { - ecs_query_table_match_t *match; - ecs_entity_t *entities; - const void *ptr; - int32_t row; - int32_t elem_size; - int32_t count; - bool shared; -} sort_helper_t; - -static -const void* ptr_from_helper( - sort_helper_t *helper) +/** Create a filtered snapshot */ +ecs_snapshot_t* ecs_snapshot_take_w_iter( + ecs_iter_t *iter) { - ecs_assert(helper->row < helper->count, ECS_INTERNAL_ERROR, NULL); - ecs_assert(helper->elem_size >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(helper->row >= 0, ECS_INTERNAL_ERROR, NULL); - if (helper->shared) { - return helper->ptr; - } else { - return ECS_ELEM(helper->ptr, helper->elem_size, helper->row); - } -} + ecs_world_t *world = iter->world; + ecs_assert(world != NULL, ECS_INTERNAL_ERROR, NULL); -static -ecs_entity_t e_from_helper( - sort_helper_t *helper) -{ - if (helper->row < helper->count) { - return helper->entities[helper->row]; - } else { - return 0; - } + ecs_snapshot_t *result = snapshot_create( + world, ecs_eis(world), iter, iter ? iter->next : NULL); + + result->last_id = world->stats.last_id; + + return result; } +/* Restoring an unfiltered snapshot restores the world to the exact state it was + * when the snapshot was taken. */ static -void build_sorted_table_range( - ecs_query_t *query, - ecs_query_table_list_t *list) +void restore_unfiltered( + ecs_world_t *world, + ecs_snapshot_t *snapshot) { - ecs_world_t *world = query->world; - ecs_entity_t id = query->order_by_component; - ecs_order_by_action_t compare = query->order_by; + flecs_sparse_restore(ecs_eis(world), snapshot->entity_index); + flecs_sparse_free(snapshot->entity_index); - if (!list->count) { - return; - } + world->stats.last_id = snapshot->last_id; - int to_sort = 0; + ecs_table_leaf_t *leafs = ecs_vector_first( + snapshot->tables, ecs_table_leaf_t); + int32_t i, count = (int32_t)flecs_sparse_last_id(&world->store.tables); + int32_t snapshot_count = ecs_vector_count(snapshot->tables); - sort_helper_t *helper = ecs_os_malloc_n(sort_helper_t, list->count); - ecs_query_table_node_t *cur, *end = list->last->next; - for (cur = list->first; cur != end; cur = cur->next) { - ecs_query_table_match_t *match = cur->match; - ecs_table_t *table = match->table; - ecs_data_t *data = &table->storage; - ecs_vector_t *entities; + for (i = 0; i <= count; i ++) { + ecs_table_t *world_table = flecs_sparse_get( + &world->store.tables, ecs_table_t, (uint32_t)i); - if (!(entities = data->entities) || !ecs_table_count(table)) { + if (world_table && (world_table->flags & EcsTableHasBuiltins)) { continue; } - int32_t index = -1; - if (id) { - index = ecs_search(world, table->storage_table, id, 0); - } - - if (index != -1) { - ecs_column_t *column = &data->columns[index]; - int16_t size = column->size; - int16_t align = column->alignment; - helper[to_sort].ptr = ecs_vector_first_t(column->data, size, align); - helper[to_sort].elem_size = size; - helper[to_sort].shared = false; - } else if (id) { - /* Find component in prefab */ - ecs_entity_t base = 0; - ecs_search_relation(world, table, 0, id, - EcsIsA, 1, 0, &base, NULL, NULL); - - /* If a base was not found, the query should not have allowed using - * the component for sorting */ - ecs_assert(base != 0, ECS_INTERNAL_ERROR, NULL); - - const EcsComponent *cptr = ecs_get(world, id, EcsComponent); - ecs_assert(cptr != NULL, ECS_INTERNAL_ERROR, NULL); - - helper[to_sort].ptr = ecs_get_id(world, base, id); - helper[to_sort].elem_size = cptr->size; - helper[to_sort].shared = true; - } else { - helper[to_sort].ptr = NULL; - helper[to_sort].elem_size = 0; - helper[to_sort].shared = false; - } - - helper[to_sort].match = match; - helper[to_sort].entities = ecs_vector_first(entities, ecs_entity_t); - helper[to_sort].row = 0; - helper[to_sort].count = ecs_table_count(table); - to_sort ++; - } - - ecs_assert(to_sort != 0, ECS_INTERNAL_ERROR, NULL); - - bool proceed; - do { - int32_t j, min = 0; - proceed = true; - - ecs_entity_t e1; - while (!(e1 = e_from_helper(&helper[min]))) { - min ++; - if (min == to_sort) { - proceed = false; - break; + ecs_table_leaf_t *snapshot_table = NULL; + if (i < snapshot_count) { + snapshot_table = &leafs[i]; + if (!snapshot_table->table) { + snapshot_table = NULL; } } - if (!proceed) { - break; - } + /* If the world table no longer exists but the snapshot table does, + * reinsert it */ + if (!world_table && snapshot_table) { + ecs_ids_t type = { + .array = ecs_vector_first(snapshot_table->type, ecs_id_t), + .count = ecs_vector_count(snapshot_table->type) + }; - for (j = min + 1; j < to_sort; j++) { - ecs_entity_t e2 = e_from_helper(&helper[j]); - if (!e2) { - continue; - } + ecs_table_t *table = flecs_table_find_or_create(world, &type); + ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - const void *ptr1 = ptr_from_helper(&helper[min]); - const void *ptr2 = ptr_from_helper(&helper[j]); + if (snapshot_table->data) { + flecs_table_replace_data(world, table, snapshot_table->data); + } + + /* If the world table still exists, replace its data */ + } else if (world_table && snapshot_table) { + ecs_assert(snapshot_table->table == world_table, + ECS_INTERNAL_ERROR, NULL); - if (compare(e1, ptr1, e2, ptr2) > 0) { - min = j; - e1 = e_from_helper(&helper[min]); + if (snapshot_table->data) { + flecs_table_replace_data( + world, world_table, snapshot_table->data); + } else { + flecs_table_clear_data( + world, world_table, &world_table->storage); + flecs_table_init_data(world, world_table); } - } + + /* If the snapshot table doesn't exist, this table was created after the + * snapshot was taken and needs to be deleted */ + } else if (world_table && !snapshot_table) { + /* Deleting a table invokes OnRemove triggers & updates the entity + * index. That is not what we want, since entities may no longer be + * valid (if they don't exist in the snapshot) or may have been + * restored in a different table. Therefore first clear the data + * from the table (which doesn't invoke triggers), and then delete + * the table. */ + flecs_table_clear_data(world, world_table, &world_table->storage); + flecs_delete_table(world, world_table); + + /* If there is no world & snapshot table, nothing needs to be done */ + } else { } - sort_helper_t *cur_helper = &helper[min]; - if (!cur || cur->match != cur_helper->match) { - cur = ecs_vector_add(&query->table_slices, ecs_query_table_node_t); - ecs_assert(cur != NULL, ECS_INTERNAL_ERROR, NULL); - cur->match = cur_helper->match; - cur->offset = cur_helper->row; - cur->count = 1; - } else { - cur->count ++; + if (snapshot_table) { + ecs_os_free(snapshot_table->data); + ecs_os_free(snapshot_table->type); } - - cur_helper->row ++; - } while (proceed); - - /* Iterate through the vector of slices to set the prev/next ptrs. This - * can't be done while building the vector, as reallocs may occur */ - int32_t i, count = ecs_vector_count(query->table_slices); - ecs_query_table_node_t *nodes = ecs_vector_first( - query->table_slices, ecs_query_table_node_t); - for (i = 0; i < count; i ++) { - nodes[i].prev = &nodes[i - 1]; - nodes[i].next = &nodes[i + 1]; } - nodes[0].prev = NULL; - nodes[i - 1].next = NULL; - - ecs_os_free(helper); -} - -static -void build_sorted_tables( - ecs_query_t *query) -{ - ecs_vector_clear(query->table_slices); - - if (query->group_by) { - /* Populate sorted node list in grouping order */ - ecs_query_table_node_t *cur = query->list.first; - if (cur) { - do { - /* Find list for current group */ - ecs_query_table_match_t *match = cur->match; - ecs_assert(match != NULL, ECS_INTERNAL_ERROR, NULL); - uint64_t group_id = match->group_id; - ecs_query_table_list_t *list = ecs_map_get(&query->groups, - ecs_query_table_list_t, group_id); - ecs_assert(list != NULL, ECS_INTERNAL_ERROR, NULL); - - /* Sort tables in current group */ - build_sorted_table_range(query, list); - - /* Find next group to sort */ - cur = list->last->next; - } while (cur); + /* Now that all tables have been restored and world is in a consistent + * state, run OnSet systems */ + int32_t world_count = flecs_sparse_count(&world->store.tables); + for (i = 0; i < world_count; i ++) { + ecs_table_t *table = flecs_sparse_get_dense( + &world->store.tables, ecs_table_t, i); + if (table->flags & EcsTableHasBuiltins) { + continue; + } + + int32_t tcount = ecs_table_count(table); + if (tcount) { + flecs_notify_on_set(world, table, 0, tcount, NULL, true); } - } else { - build_sorted_table_range(query, &query->list); } } +/* Restoring a filtered snapshots only restores the entities in the snapshot + * to their previous state. */ static -void sort_tables( +void restore_filtered( ecs_world_t *world, - ecs_query_t *query) + ecs_snapshot_t *snapshot) { - ecs_order_by_action_t compare = query->order_by; - if (!compare) { - return; - } - - ecs_entity_t order_by_component = query->order_by_component; - int32_t i, order_by_term = -1; + ecs_table_leaf_t *leafs = ecs_vector_first( + snapshot->tables, ecs_table_leaf_t); + int32_t l = 0, snapshot_count = ecs_vector_count(snapshot->tables); - /* Find term that iterates over component (must be at least one) */ - if (order_by_component) { - const ecs_filter_t *f = &query->filter; - int32_t term_count = f->term_count_actual; - for (i = 0; i < term_count; i ++) { - ecs_term_t *term = &f->terms[i]; - if (term->subj.entity != EcsThis) { - continue; - } + for (l = 0; l < snapshot_count; l ++) { + ecs_table_leaf_t *snapshot_table = &leafs[l]; + ecs_table_t *table = snapshot_table->table; - if (term->id == order_by_component) { - order_by_term = i; - break; - } + if (!table) { + continue; } - ecs_assert(order_by_term != -1, ECS_INTERNAL_ERROR, NULL); - } - - /* Iterate over non-empty tables. Don't bother with empty tables as they - * have nothing to sort */ - - bool tables_sorted = false; - - ecs_table_cache_iter_t it; - ecs_query_table_t *qt; - flecs_table_cache_iter(&query->cache, &it); - - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - ecs_table_t *table = qt->hdr.table; - bool dirty = false; - - if (check_table_monitor(query, qt, 0)) { - dirty = true; + ecs_data_t *data = snapshot_table->data; + if (!data) { + ecs_vector_free(snapshot_table->type); + continue; } - int32_t column = -1; - if (order_by_component) { - if (check_table_monitor(query, qt, order_by_term + 1)) { - dirty = true; + /* Delete entity from storage first, so that when we restore it to the + * current table we can be sure that there won't be any duplicates */ + int32_t i, entity_count = ecs_vector_count(data->entities); + ecs_entity_t *entities = ecs_vector_first( + snapshot_table->data->entities, ecs_entity_t); + for (i = 0; i < entity_count; i ++) { + ecs_entity_t e = entities[i]; + ecs_record_t *r = ecs_eis_get(world, e); + if (r && r->table) { + flecs_table_delete(world, r->table, &r->table->storage, + ECS_RECORD_TO_ROW(r->row), true); + } else { + /* Make sure that the entity has the same generation count */ + ecs_eis_set_generation(world, e); } + } - if (dirty) { - column = -1; - - ecs_table_t *storage_table = table->storage_table; - if (storage_table) { - column = ecs_search(world, storage_table, - order_by_component, NULL); - } + /* Merge data from snapshot table with world table */ + int32_t old_count = ecs_table_count(snapshot_table->table); + int32_t new_count = flecs_table_data_count(snapshot_table->data); - if (column == -1) { - /* Component is shared, no sorting is needed */ - dirty = false; - } - } - } + flecs_table_merge(world, table, table, &table->storage, snapshot_table->data); - if (!dirty) { - continue; + /* Run OnSet systems for merged entities */ + if (new_count) { + flecs_notify_on_set( + world, table, old_count, new_count, NULL, true); } - /* Something has changed, sort the table */ - sort_table(world, table, column, compare); - tables_sorted = true; + ecs_os_free(snapshot_table->data->columns); + ecs_os_free(snapshot_table->data); + ecs_vector_free(snapshot_table->type); } +} - if (tables_sorted || query->match_count != query->prev_match_count) { - build_sorted_tables(query); - query->match_count ++; /* Increase version if tables changed */ +/** Restore a snapshot */ +void ecs_snapshot_restore( + ecs_world_t *world, + ecs_snapshot_t *snapshot) +{ + ecs_force_aperiodic(world); + + if (snapshot->entity_index) { + /* Unfiltered snapshots have a copy of the entity index which is + * copied back entirely when the snapshot is restored */ + restore_unfiltered(world, snapshot); + } else { + restore_filtered(world, snapshot); } + + ecs_vector_free(snapshot->tables); + + ecs_os_free(snapshot); } -static -bool has_refs( - ecs_query_t *query) +ecs_iter_t ecs_snapshot_iter( + ecs_snapshot_t *snapshot) { - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count; + ecs_snapshot_iter_t iter = { + .tables = snapshot->tables, + .index = 0 + }; - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - ecs_term_id_t *subj = &term->subj; + return (ecs_iter_t){ + .world = snapshot->world, + .table_count = ecs_vector_count(snapshot->tables), + .priv.iter.snapshot = iter, + .next = ecs_snapshot_next + }; +} - if (term->oper == EcsNot && !subj->entity) { - /* Special case: if oper kind is Not and the query contained a - * shared expression, the expression is translated to FromEmpty to - * prevent resolving the ref */ - return true; - } else if (subj->entity && (subj->entity != EcsThis || subj->set.mask != EcsSelf)) { - /* If entity is not this, or if it can be substituted by other - * entities, the query can have references. */ - return true; - } +bool ecs_snapshot_next( + ecs_iter_t *it) +{ + ecs_snapshot_iter_t *iter = &it->priv.iter.snapshot; + ecs_table_leaf_t *tables = ecs_vector_first(iter->tables, ecs_table_leaf_t); + int32_t count = ecs_vector_count(iter->tables); + int32_t i; + + for (i = iter->index; i < count; i ++) { + ecs_table_t *table = tables[i].table; + if (!table) { + continue; + } + + ecs_data_t *data = tables[i].data; + + it->table = table; + it->count = ecs_table_count(table); + if (data) { + it->entities = ecs_vector_first(data->entities, ecs_entity_t); + } else { + it->entities = NULL; + } + + it->is_valid = true; + iter->index = i + 1; + + goto yield; } + it->is_valid = false; return false; + +yield: + it->is_valid = true; + return true; } -static -bool has_pairs( - ecs_query_t *query) +/** Cleanup snapshot */ +void ecs_snapshot_free( + ecs_snapshot_t *snapshot) { - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count; + flecs_sparse_free(snapshot->entity_index); + ecs_table_leaf_t *tables = ecs_vector_first(snapshot->tables, ecs_table_leaf_t); + int32_t i, count = ecs_vector_count(snapshot->tables); for (i = 0; i < count; i ++) { - if (ecs_id_is_wildcard(terms[i].id)) { - return true; + ecs_table_leaf_t *snapshot_table = &tables[i]; + ecs_table_t *table = snapshot_table->table; + if (table) { + ecs_data_t *data = snapshot_table->data; + if (data) { + flecs_table_clear_data(snapshot->world, table, data); + ecs_os_free(data); + } + ecs_vector_free(snapshot_table->type); } - } + } - return false; + ecs_vector_free(snapshot->tables); + ecs_os_free(snapshot); } -static -void for_each_component_monitor( - ecs_world_t *world, - ecs_query_t *query, - void(*callback)( - ecs_world_t* world, - ecs_entity_t relation, - ecs_id_t id, - ecs_query_t *query)) -{ - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count; +#endif - for (i = 0; i < count; i++) { - ecs_term_t *term = &terms[i]; - ecs_term_id_t *subj = &term->subj; - /* If component is requested with EcsCascade register component as a - * parent monitor. Parent monitors keep track of whether an entity moved - * in the hierarchy, which potentially requires the query to reorder its - * tables. - * Also register a regular component monitor for EcsCascade columns. - * This ensures that when the component used in the EcsCascade column - * is added or removed tables are updated accordingly*/ - if (subj->set.mask & EcsSuperSet && subj->set.mask & EcsCascade && - subj->set.relation != EcsIsA) - { - if (term->oper != EcsOr) { - if (term->subj.set.relation != EcsIsA) { - callback( - world, term->subj.set.relation, term->id, query); - } - callback(world, 0, term->id, query); - } - /* FromAny also requires registering a monitor, as FromAny columns can - * be matched with prefabs. The only term kinds that do not require - * registering a monitor are FromOwned and FromEmpty. */ - } else if ((subj->set.mask & EcsSuperSet) || (subj->entity != EcsThis)){ - if (term->oper != EcsOr) { - callback(world, 0, term->id, query); - } - } - } +#ifdef FLECS_DOC + +static ECS_COPY(EcsDocDescription, dst, src, { + ecs_os_strset((char**)&dst->value, src->value); + +}) + +static ECS_MOVE(EcsDocDescription, dst, src, { + ecs_os_free((char*)dst->value); + dst->value = src->value; + src->value = NULL; +}) + +static ECS_DTOR(EcsDocDescription, ptr, { + ecs_os_free((char*)ptr->value); +}) + +void ecs_doc_set_name( + ecs_world_t *world, + ecs_entity_t entity, + const char *name) +{ + ecs_set_pair(world, entity, EcsDocDescription, EcsName, { + .value = name + }); } -static -void register_monitors( +void ecs_doc_set_brief( ecs_world_t *world, - ecs_query_t *query) + ecs_entity_t entity, + const char *description) { - for_each_component_monitor(world, query, flecs_monitor_register); + ecs_set_pair(world, entity, EcsDocDescription, EcsDocBrief, { + .value = description + }); } -static -void unregister_monitors( +void ecs_doc_set_detail( ecs_world_t *world, - ecs_query_t *query) + ecs_entity_t entity, + const char *description) { - for_each_component_monitor(world, query, flecs_monitor_unregister); + ecs_set_pair(world, entity, EcsDocDescription, EcsDocDetail, { + .value = description + }); } -static -bool is_term_id_supported( - ecs_term_id_t *term_id) +void ecs_doc_set_link( + ecs_world_t *world, + ecs_entity_t entity, + const char *link) { - if (term_id->var != EcsVarIsVariable) { - return true; + ecs_set_pair(world, entity, EcsDocDescription, EcsDocLink, { + .value = link + }); +} + +const char* ecs_doc_get_name( + const ecs_world_t *world, + ecs_entity_t entity) +{ + EcsDocDescription *ptr = ecs_get_pair( + world, entity, EcsDocDescription, EcsName); + if (ptr) { + return ptr->value; + } else { + return ecs_get_name(world, entity); } - if (term_id->entity == EcsWildcard) { - return true; +} + +const char* ecs_doc_get_brief( + const ecs_world_t *world, + ecs_entity_t entity) +{ + EcsDocDescription *ptr = ecs_get_pair( + world, entity, EcsDocDescription, EcsDocBrief); + if (ptr) { + return ptr->value; + } else { + return NULL; } - return false; } -static -void process_signature( - ecs_world_t *world, - ecs_query_t *query) +const char* ecs_doc_get_detail( + const ecs_world_t *world, + ecs_entity_t entity) { - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count; + EcsDocDescription *ptr = ecs_get_pair( + world, entity, EcsDocDescription, EcsDocDetail); + if (ptr) { + return ptr->value; + } else { + return NULL; + } +} - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - ecs_term_id_t *pred = &term->pred; - ecs_term_id_t *subj = &term->subj; - ecs_term_id_t *obj = &term->obj; - ecs_oper_kind_t op = term->oper; - ecs_inout_kind_t inout = term->inout; +const char* ecs_doc_get_link( + const ecs_world_t *world, + ecs_entity_t entity) +{ + EcsDocDescription *ptr = ecs_get_pair( + world, entity, EcsDocDescription, EcsDocLink); + if (ptr) { + return ptr->value; + } else { + return NULL; + } +} - bool is_pred_supported = is_term_id_supported(pred); - bool is_subj_supported = is_term_id_supported(subj); - bool is_obj_supported = is_term_id_supported(obj); +void FlecsDocImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsDoc); - (void)pred; - (void)obj; - (void)is_pred_supported; - (void)is_subj_supported; - (void)is_obj_supported; + ecs_set_name_prefix(world, "EcsDoc"); - /* Queries do not support named variables */ - ecs_check(is_pred_supported, ECS_UNSUPPORTED, NULL); - ecs_check(is_obj_supported, ECS_UNSUPPORTED, NULL); - ecs_check(is_subj_supported || subj->entity == EcsThis, - ECS_UNSUPPORTED, NULL); + flecs_bootstrap_component(world, EcsDocDescription); + flecs_bootstrap_tag(world, EcsDocBrief); + flecs_bootstrap_tag(world, EcsDocDetail); + flecs_bootstrap_tag(world, EcsDocLink); - /* If self is not included in set, always start from depth 1 */ - if (!subj->set.min_depth && !(subj->set.mask & EcsSelf)) { - subj->set.min_depth = 1; - } + ecs_set_component_actions(world, EcsDocDescription, { + .ctor = ecs_default_ctor, + .move = ecs_move(EcsDocDescription), + .copy = ecs_copy(EcsDocDescription), + .dtor = ecs_dtor(EcsDocDescription) + }); - if (inout != EcsIn) { - query->flags |= EcsQueryHasOutColumns; - } + ecs_add_id(world, ecs_id(EcsDocDescription), EcsDontInherit); +} - if (op == EcsOptional) { - query->flags |= EcsQueryHasOptional; - } +#endif - if (!(query->flags & EcsQueryMatchDisabled)) { - if (op == EcsAnd || op == EcsOr || op == EcsOptional) { - if (term->id == EcsDisabled) { - query->flags |= EcsQueryMatchDisabled; - } - } - } - if (!(query->flags & EcsQueryMatchPrefab)) { - if (op == EcsAnd || op == EcsOr || op == EcsOptional) { - if (term->id == EcsPrefab) { - query->flags |= EcsQueryMatchPrefab; - } - } - } +#ifdef FLECS_PLECS - if (subj->entity == EcsThis) { - query->flags |= EcsQueryNeedsTables; - } +#include +#include - if (subj->set.mask & EcsCascade && term->oper == EcsOptional) { - /* Query can only have one cascade column */ - ecs_assert(query->cascade_by == 0, ECS_INVALID_PARAMETER, NULL); - query->cascade_by = i + 1; - } +#define TOK_NEWLINE '\n' +#define TOK_WITH "with" +#define TOK_USING "using" - if (subj->entity && subj->entity != EcsThis && - subj->set.mask == EcsSelf) - { - flecs_add_flag(world, term->subj.entity, ECS_FLAG_OBSERVED); - } - } +#define STACK_MAX_SIZE (64) - query->flags |= (ecs_flags32_t)(has_refs(query) * EcsQueryHasRefs); - query->flags |= (ecs_flags32_t)(has_pairs(query) * EcsQueryHasTraits); +typedef struct { + const char *name; + const char *code; - if (!(query->flags & EcsQueryIsSubquery)) { - register_monitors(world, query); - } -error: - return; -} + ecs_entity_t last_predicate; + ecs_entity_t last_subject; + ecs_entity_t last_object; -static -bool match_table( - ecs_world_t *world, - ecs_query_t *query, - ecs_table_t *table) -{ - if (flecs_query_match(world, table, query)) { - add_table(world, query, table); - return true; - } - return false; -} + ecs_id_t last_assign_id; + ecs_entity_t assign_to; -/** When a table becomes empty remove it from the query list, or vice versa. */ -static -void update_table( - ecs_query_t *query, - ecs_table_t *table, - bool empty) -{ - int32_t prev_count = ecs_query_table_count(query); - ecs_table_cache_set_empty(&query->cache, table, empty); - int32_t cur_count = ecs_query_table_count(query); + ecs_entity_t scope[STACK_MAX_SIZE]; + ecs_entity_t default_scope_type[STACK_MAX_SIZE]; + ecs_entity_t with[STACK_MAX_SIZE]; + ecs_entity_t using[STACK_MAX_SIZE]; + int32_t with_frames[STACK_MAX_SIZE]; + int32_t using_frames[STACK_MAX_SIZE]; + int32_t sp; + int32_t with_frame; + int32_t using_frame; - if (prev_count != cur_count) { - ecs_query_table_t *qt = ecs_table_cache_get(&query->cache, table); - ecs_assert(qt != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_query_table_match_t *cur, *next; + char *comment; - for (cur = qt->first; cur != NULL; cur = next) { - next = cur->next_match; + bool with_stmt; + bool scope_assign_stmt; + bool using_stmt; + bool assign_stmt; + bool isa_stmt; - if (empty) { - ecs_assert(ecs_table_count(table) == 0, - ECS_INTERNAL_ERROR, NULL); + int32_t errors; +} plecs_state_t; - remove_table_node(query, &cur->node); - } else { - ecs_assert(ecs_table_count(table) != 0, - ECS_INTERNAL_ERROR, NULL); - insert_table_node(query, &cur->node); +static +ecs_entity_t plecs_lookup( + const ecs_world_t *world, + const char *path, + plecs_state_t *state, + bool is_subject) +{ + ecs_entity_t e = 0; + + if (!is_subject) { + int using_scope = state->using_frame - 1; + for (; using_scope >= 0; using_scope--) { + e = ecs_lookup_path_w_sep( + world, state->using[using_scope], path, NULL, NULL, false); + if (e) { + break; } } } - ecs_assert(cur_count || query->list.first == NULL, - ECS_INTERNAL_ERROR, NULL); + if (!e) { + e = ecs_lookup_path_w_sep(world, 0, path, NULL, NULL, !is_subject); + } + + return e; } +/* Lookup action used for deserializing entity refs in component values */ +#ifdef FLECS_EXPR static -void add_subquery( - ecs_world_t *world, - ecs_query_t *parent, - ecs_query_t *subquery) +ecs_entity_t plecs_lookup_action( + const ecs_world_t *world, + const char *path, + void *ctx) { - ecs_query_t **elem = ecs_vector_add(&parent->subqueries, ecs_query_t*); - *elem = subquery; - - ecs_table_cache_t *cache = &parent->cache; - ecs_table_cache_iter_t it; - ecs_query_table_t *qt; - flecs_table_cache_iter(cache, &it); - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - match_table(world, subquery, qt->hdr.table); - } - - flecs_table_cache_empty_iter(cache, &it); - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - match_table(world, subquery, qt->hdr.table); - } + return plecs_lookup(world, path, ctx, false); } +#endif static -void notify_subqueries( - ecs_world_t *world, - ecs_query_t *query, - ecs_query_event_t *event) +void clear_comment( + const char *expr, + const char *ptr, + plecs_state_t *state) { - if (query->subqueries) { - ecs_query_t **queries = ecs_vector_first(query->subqueries, ecs_query_t*); - int32_t i, count = ecs_vector_count(query->subqueries); - - ecs_query_event_t sub_event = *event; - sub_event.parent_query = query; + if (state->comment) { + ecs_parser_error(state->name, expr, ptr - expr, "unused doc comment"); + ecs_os_free(state->comment); + state->comment = NULL; - for (i = 0; i < count; i ++) { - ecs_query_t *sub = queries[i]; - flecs_query_notify(world, sub, &sub_event); - } + state->errors ++; /* Non-fatal error */ } } static -void resolve_cascade_subject_for_table( - ecs_world_t *world, - ecs_query_t *query, - const ecs_table_t *table, - ecs_query_table_match_t *table_data) +const char* parse_fluff( + const char *expr, + const char *ptr, + plecs_state_t *state) { - int32_t term_index = query->cascade_by - 1; - ecs_term_t *term = &query->filter.terms[term_index]; - - ecs_assert(table_data->references != 0, ECS_INTERNAL_ERROR, NULL); - - /* Obtain reference index */ - int32_t *column_indices = table_data->columns; - int32_t ref_index = -column_indices[term_index] - 1; - - /* Obtain pointer to the reference data */ - ecs_ref_t *references = table_data->references; + char *comment; + const char *next = ecs_parse_fluff(ptr, &comment); - /* Find source for component */ - ecs_entity_t subject = 0; - ecs_search_relation(world, table, 0, term->id, - term->subj.set.relation, 1, 0, &subject, NULL, NULL); + if (comment && comment[0] == '/') { + comment = (char*)ecs_parse_fluff(comment + 1, NULL); + int32_t len = (ecs_size_t)(next - comment); + int32_t newline_count = 0; - /* If container was found, update the reference */ - if (subject) { - ecs_ref_t *ref = &references[ref_index]; - ecs_assert(ref->component == term->id, ECS_INTERNAL_ERROR, NULL); + /* Trim trailing whitespaces */ + while (len >= 0 && (isspace(comment[len - 1]))) { + if (comment[len - 1] == '\n') { + newline_count ++; + if (newline_count > 1) { + /* If newline separates comment from statement, discard */ + len = -1; + break; + } + } + len --; + } - references[ref_index].entity = ecs_get_alive(world, subject); - table_data->subjects[term_index] = subject; - ecs_get_ref_id(world, ref, subject, term->id); + if (len > 0) { + clear_comment(expr, ptr, state); + state->comment = ecs_os_calloc_n(char, len + 1); + ecs_os_strncpy(state->comment, comment, len); + } else { + ecs_parser_error(state->name, expr, ptr - expr, + "unused doc comment"); + state->errors ++; + } } else { - references[ref_index].entity = 0; - table_data->subjects[term_index] = 0; + if (ptr != next && state->comment) { + clear_comment(expr, ptr, state); + } } - if (ecs_table_count(table)) { - /* The subject (or depth of the subject) may have changed, so reinsert - * the node to make sure it's in the right group */ - remove_table_node(query, &table_data->node); - insert_table_node(query, &table_data->node); - } + return next; } static -void resolve_cascade_subject( +ecs_entity_t ensure_entity( ecs_world_t *world, - ecs_query_t *query, - ecs_query_table_t *elem, - const ecs_table_t *table) + plecs_state_t *state, + const char *path, + bool is_subject) { - ecs_query_table_match_t *cur; - for (cur = elem->first; cur != NULL; cur = cur->next_match) { - resolve_cascade_subject_for_table(world, query, table, cur); + if (!path) { + return 0; } -} -/* Remove table */ -static -void query_table_free( - ecs_query_t *query, - ecs_query_table_t *elem) -{ - ecs_query_table_match_t *cur, *next; + ecs_entity_t e = plecs_lookup(world, path, state, is_subject); + if (!e) { + if (!is_subject) { + /* If this is not a subject create an existing empty id, which + * ensures that scope & with are not applied */ + e = ecs_new_id(world); + } - for (cur = elem->first; cur != NULL; cur = next) { - ecs_os_free(cur->columns); - ecs_os_free(cur->ids); - ecs_os_free(cur->subjects); - ecs_os_free(cur->sizes); - ecs_os_free(cur->references); - ecs_os_free(cur->sparse_columns); - ecs_os_free(cur->bitset_columns); - ecs_os_free(cur->monitor); + e = ecs_add_path(world, e, 0, path); + ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL); + } else { + /* If entity exists, make sure it gets the right scope and with */ + if (is_subject) { + ecs_entity_t scope = ecs_get_scope(world); + if (scope) { + ecs_add_pair(world, e, EcsChildOf, scope); + } - if (!elem->hdr.empty) { - remove_table_node(query, &cur->node); + ecs_entity_t with = ecs_get_with(world); + if (with) { + ecs_add_id(world, e, with); + } } + } - next = cur->next_match; + return e; +} - ecs_os_free(cur); +static +bool pred_is_subj( + ecs_term_t *term, + plecs_state_t *state) +{ + if (term->subj.name != NULL) { + return false; + } + if (term->obj.name != NULL) { + return false; + } + if (term->subj.set.mask == EcsNothing) { + return false; + } + if (state->with_stmt) { + return false; + } + if (state->assign_stmt) { + return false; + } + if (state->isa_stmt) { + return false; + } + if (state->using_stmt) { + return false; } - ecs_os_free(elem); + return true; } +/* Set masks aren't useful in plecs, so translate them back to entity names */ static -void unmatch_table( - ecs_query_t *query, - ecs_table_t *table) +const char* set_mask_to_name( + ecs_flags32_t flags) { - ecs_query_table_t *qt = ecs_table_cache_remove( - &query->cache, table, NULL); - if (qt) { - query_table_free(query, qt); + if (flags == EcsSelf) { + return "self"; + } else if (flags == EcsAll) { + return "all"; + } else if (flags == EcsSuperSet) { + return "super"; + } else if (flags == EcsSubSet) { + return "sub"; + } else if (flags == EcsCascade || flags == (EcsSuperSet|EcsCascade)) { + return "cascade"; + } else if (flags == EcsParent) { + return "parent"; } + return NULL; } static -void rematch_table( - ecs_world_t *world, - ecs_query_t *query, - ecs_table_t *table) +int create_term( + ecs_world_t *world, + ecs_term_t *term, + const char *name, + const char *expr, + int64_t column, + plecs_state_t *state) { - ecs_query_table_t *match = ecs_table_cache_get(&query->cache, table); + state->last_subject = 0; + state->last_predicate = 0; + state->last_object = 0; + state->last_assign_id = 0; - if (flecs_query_match(world, table, query)) { - /* If the table matches, and it is not currently matched, add */ - if (match == NULL) { - add_table(world, query, table); + const char *pred_name = term->pred.name; + const char *subj_name = term->subj.name; + const char *obj_name = term->obj.name; - /* If table still matches and has cascade column, reevaluate the - * sources of references. This may have changed in case - * components were added/removed to container entities */ - } else if (query->cascade_by) { - resolve_cascade_subject(world, query, match, table); + if (!subj_name) { + subj_name = set_mask_to_name(term->subj.set.mask); + } + if (!obj_name) { + obj_name = set_mask_to_name(term->obj.set.mask); + } - /* If query has optional columns, it is possible that a column that - * previously had data no longer has data, or vice versa. Do a - * rematch to make sure data is consistent. */ - } else if (query->flags & EcsQueryHasOptional) { - /* Check if optional terms that weren't matched before are matched - * now & vice versa */ - ecs_query_table_match_t *qt = match->first; + if (!ecs_term_id_is_set(&term->pred)) { + ecs_parser_error(name, expr, column, "missing predicate in expression"); + return -1; + } - bool rematch = false; - int32_t i, count = query->filter.term_count_actual; - for (i = 0; i < count; i ++) { - ecs_term_t *term = &query->filter.terms[i]; + if (state->assign_stmt && term->subj.entity != EcsThis) { + ecs_parser_error(name, expr, column, + "invalid statement in assign statement"); + return -1; + } - if (term->oper == EcsOptional) { - int32_t t = term->index; - int32_t column = 0; - flecs_term_match_table(world, term, table, - table->type, 0, &column, 0, 0, true); - if (column && (qt->columns[t] == 0)) { - rematch = true; - } else if (!column && (qt->columns[t] != 0)) { - rematch = true; - } - } - } + bool pred_as_subj = pred_is_subj(term, state); - if (rematch) { - unmatch_table(query, table); - add_table(world, query, table); - } + ecs_entity_t pred = ensure_entity(world, state, pred_name, pred_as_subj); + ecs_entity_t subj = ensure_entity(world, state, subj_name, true); + ecs_entity_t obj = 0; + + if (ecs_term_id_is_set(&term->obj)) { + obj = ensure_entity(world, state, obj_name, + state->assign_stmt == false); + } + + if (state->assign_stmt || state->isa_stmt) { + subj = state->assign_to; + } + + if (state->isa_stmt && obj) { + ecs_parser_error(name, expr, column, + "invalid object in inheritance statement"); + return -1; + } + + if (state->using_stmt && (obj || subj)) { + ecs_parser_error(name, expr, column, + "invalid predicate/object in using statement"); + return -1; + } + + if (state->isa_stmt) { + pred = ecs_pair(EcsIsA, pred); + } + + if (subj) { + if (!obj) { + ecs_add_id(world, subj, pred); + state->last_assign_id = pred; + } else { + ecs_add_pair(world, subj, pred, obj); + state->last_object = obj; + state->last_assign_id = ecs_pair(pred, obj); } + state->last_predicate = pred; + state->last_subject = subj; + + pred_as_subj = false; } else { - /* Table no longer matches, remove */ - if (match != NULL) { - unmatch_table(query, table); - notify_subqueries(world, query, &(ecs_query_event_t){ - .kind = EcsQueryTableUnmatch, - .table = table - }); + if (!obj) { + /* If no subject or object were provided, use predicate as subj + * unless the expression explictly excluded the subject */ + if (pred_as_subj) { + state->last_subject = pred; + subj = pred; + } else { + state->last_predicate = pred; + pred_as_subj = false; + } + } else { + state->last_predicate = pred; + state->last_object = obj; + pred_as_subj = false; } } -} - -static -bool satisfy_constraints( - ecs_world_t *world, - const ecs_filter_t *filter) -{ - ecs_term_t *terms = filter->terms; - int32_t i, count = filter->term_count; - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - ecs_term_id_t *subj = &term->subj; - ecs_oper_kind_t oper = term->oper; + /* If this is a with clause (the list of entities between 'with' and scope + * open), add subject to the array of with frames */ + if (state->with_stmt) { + ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL); + ecs_id_t id; - if (oper == EcsOptional) { - continue; + if (obj) { + id = ecs_pair(pred, obj); + } else { + id = pred; } - if (subj->entity != EcsThis && subj->entity) { - ecs_table_t *table = ecs_get_table(world, subj->entity); - if (!table) { - goto no_match; - } + state->with[state->with_frame ++] = id; + + } else if (state->using_stmt) { + ecs_assert(pred != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(obj == 0, ECS_INTERNAL_ERROR, NULL); - if (!flecs_term_match_table(world, term, table, table->type, NULL, - NULL, NULL, NULL, true)) - { - goto no_match; + state->using[state->using_frame ++] = pred; + state->using_frames[state->sp] = state->using_frame; + + /* If this is not a with/using clause, add with frames to subject */ + } else { + if (subj) { + int32_t i, frame_count = state->with_frames[state->sp]; + for (i = 0; i < frame_count; i ++) { + ecs_add_id(world, subj, state->with[i]); } } } - return true; -no_match: - return false; -} + /* If an id was provided by itself, add default scope type to it */ + ecs_entity_t default_scope_type = state->default_scope_type[state->sp]; + if (pred_as_subj && default_scope_type) { + ecs_add_id(world, subj, default_scope_type); + } -/* Rematch system with tables after a change happened to a watched entity */ -static -void rematch_tables( - ecs_world_t *world, - ecs_query_t *query, - ecs_query_t *parent_query) -{ - if (parent_query) { - ecs_table_cache_iter_t it; - if (flecs_table_cache_iter(&parent_query->cache, &it)) { - ecs_query_table_t *qt; - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - rematch_table(world, query, qt->hdr.table); - } - } + /* If a comment preceded the statement, add it as a brief description */ +#ifdef FLECS_DOC + if (subj && state->comment) { + ecs_doc_set_brief(world, subj, state->comment); + ecs_os_free(state->comment); + state->comment = NULL; + } +#endif - if (flecs_table_cache_empty_iter(&parent_query->cache, &it)) { - ecs_query_table_t *qt; - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - rematch_table(world, query, qt->hdr.table); - } - } - } else { - ecs_sparse_t *tables = &world->store.tables; - int32_t i, count = flecs_sparse_count(tables); + return 0; +} - for (i = 0; i < count; i ++) { - /* Is the system currently matched with the table? */ - ecs_table_t *table = flecs_sparse_get_dense(tables, ecs_table_t, i); - rematch_table(world, query, table); - } +static +const char* parse_inherit_stmt( + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) +{ + if (state->isa_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "cannot nest inheritance"); + return NULL; + } + + if (!state->last_subject) { + ecs_parser_error(name, expr, ptr - expr, + "missing entity to assign inheritance to"); + return NULL; } + + state->isa_stmt = true; + state->assign_to = state->last_subject; - /* Enable/disable system if constraints are (not) met. If the system is - * already dis/enabled this operation has no side effects. */ - query->constraints_satisfied = satisfy_constraints(world, &query->filter); + return ptr; } static -void remove_subquery( - ecs_query_t *parent, - ecs_query_t *sub) +const char* parse_assign_expr( + ecs_world_t *world, + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) { - ecs_assert(parent != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(sub != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(parent->subqueries != NULL, ECS_INTERNAL_ERROR, NULL); + (void)world; + + if (!state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "unexpected value outside of assignment statement"); + return NULL; + } - int32_t i, count = ecs_vector_count(parent->subqueries); - ecs_query_t **sq = ecs_vector_first(parent->subqueries, ecs_query_t*); + ecs_id_t assign_id = state->last_assign_id; + if (!assign_id) { + ecs_parser_error(name, expr, ptr - expr, + "missing type for assignment statement"); + return NULL; + } - for (i = 0; i < count; i ++) { - if (sq[i] == sub) { - break; - } +#ifndef FLECS_EXPR + ecs_parser_error(name, expr, ptr - expr, + "cannot parse value, missing FLECS_EXPR addon"); + return NULL; +#else + ecs_entity_t assign_to = state->assign_to; + if (!assign_to) { + assign_to = state->last_subject; } - ecs_vector_remove(parent->subqueries, ecs_query_t*, i); -} + if (!assign_to) { + ecs_parser_error(name, expr, ptr - expr, + "missing entity to assign to"); + return NULL; + } -/* -- Private API -- */ + ecs_entity_t type = ecs_get_typeid(world, assign_id); + if (!type) { + char *id_str = ecs_id_str(world, assign_id); + ecs_parser_error(name, expr, ptr - expr, + "invalid assignment, '%s' is not a type", id_str); + ecs_os_free(id_str); + return NULL; + } -void flecs_query_notify( - ecs_world_t *world, - ecs_query_t *query, - ecs_query_event_t *event) -{ - bool notify = true; + void *value_ptr = ecs_get_mut_id( + world, assign_to, assign_id, NULL); - switch(event->kind) { - case EcsQueryTableMatch: - /* Creation of new table */ - if (match_table(world, query, event->table)) { - if (query->subqueries) { - notify_subqueries(world, query, event); - } - } - notify = false; - break; - case EcsQueryTableUnmatch: - /* Deletion of table */ - unmatch_table(query, event->table); - break; - case EcsQueryTableRematch: - /* Rematch tables of query */ - rematch_tables(world, query, event->parent_query); - break; - case EcsQueryOrphan: - ecs_assert(query->flags & EcsQueryIsSubquery, ECS_INTERNAL_ERROR, NULL); - query->flags |= EcsQueryIsOrphaned; - query->parent = NULL; - break; + ptr = ecs_parse_expr(world, ptr, type, value_ptr, + &(ecs_parse_expr_desc_t) { + .name = name, + .expr = expr, + .lookup_action = plecs_lookup_action, + .lookup_ctx = state + }); + if (!ptr) { + return NULL; } - if (notify) { - notify_subqueries(world, query, event); - } + ecs_modified_id(world, assign_to, assign_id); +#endif + + return ptr; } static -void query_order_by( +const char* parse_assign_stmt( ecs_world_t *world, - ecs_query_t *query, - ecs_entity_t order_by_component, - ecs_order_by_action_t order_by) + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) { - ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(!(query->flags & EcsQueryIsOrphaned), ECS_INVALID_PARAMETER, NULL); - ecs_check(query->flags & EcsQueryNeedsTables, ECS_INVALID_PARAMETER, NULL); + (void)world; - query->order_by_component = order_by_component; - query->order_by = order_by; + state->isa_stmt = false; - ecs_vector_free(query->table_slices); - query->table_slices = NULL; + /* Component scope (add components to entity) */ + if (!state->last_subject) { + ecs_parser_error(name, expr, ptr - expr, + "missing entity to assign to"); + return NULL; + } - sort_tables(world, query); + if (state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid assign statement in assign statement"); + return NULL; + } - if (!query->table_slices) { - build_sorted_tables(query); + if (!state->scope_assign_stmt) { + state->assign_to = state->last_subject; } -error: - return; -} -static -void query_group_by( - ecs_query_t *query, - ecs_entity_t sort_component, - ecs_group_by_action_t group_by) -{ - /* Cannot change grouping once a query has been created */ - ecs_check(query->group_by_id == 0, ECS_INVALID_OPERATION, NULL); - ecs_check(query->group_by == 0, ECS_INVALID_OPERATION, NULL); + state->assign_stmt = true; + + /* Assignment without a preceding component */ + if (ptr[0] == '{') { + ecs_entity_t type = 0; - query->group_by_id = sort_component; - query->group_by = group_by; - ecs_map_init(&query->groups, ecs_query_table_list_t, 16); -error: - return; -} + if (state->scope_assign_stmt) { + ecs_assert(state->assign_to == ecs_get_scope(world), + ECS_INTERNAL_ERROR, NULL); + } -/* Implementation for iterable mixin */ -static -void query_iter_init( - const ecs_world_t *world, - const ecs_poly_t *poly, - ecs_iter_t *iter, - ecs_term_t *filter) -{ - ecs_poly_assert(poly, ecs_query_t); + /* If we're in a scope & last_subject is a type, assign to scope */ + if (ecs_get_scope(world) != 0) { + type = ecs_get_typeid(world, state->last_subject); + if (type != 0) { + type = state->last_subject; + } + } - if (filter) { - iter[1] = ecs_query_iter(world, (ecs_query_t*)poly); - iter[0] = ecs_term_chain_iter(&iter[1], filter); - } else { - iter[0] = ecs_query_iter(world, (ecs_query_t*)poly); + /* If type hasn't been set yet, check if scope has default type */ + if (!type && !state->scope_assign_stmt) { + type = state->default_scope_type[state->sp]; + } + + /* If no type has been found still, check if last with id is a type */ + if (!type && !state->scope_assign_stmt) { + int32_t with_frame_count = state->with_frames[state->sp]; + if (with_frame_count) { + type = state->with[with_frame_count - 1]; + } + } + + if (!type) { + ecs_parser_error(name, expr, ptr - expr, + "missing type for assignment"); + return NULL; + } + + state->last_assign_id = type; } + + return ptr; } static -void query_on_event( - ecs_iter_t *it) -{ - /* Because this is the observer::run callback, checking if this is event is - * already handled is not done for us. */ - ecs_world_t *world = it->world; - ecs_observer_t *o = it->ctx; - if (o->last_event_id == world->event_id) { - return; +const char* parse_using_stmt( + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) +{ + if (state->isa_stmt || state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid usage of using keyword"); + return NULL; } - o->last_event_id = world->event_id; - ecs_query_t *query = o->ctx; - ecs_table_t *table = it->table; + /* Add following expressions to using list */ + state->using_stmt = true; - ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); + return ptr + 5; +} - /* The observer isn't doing the matching because the query can do it more - * efficiently by checking the table with the query cache. */ - if (ecs_table_cache_get(&query->cache, table) == NULL) { - return; +static +const char* parse_with_stmt( + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) +{ + if (state->isa_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid with after inheritance"); + return NULL; } - ecs_entity_t event = it->event; - if (event == EcsOnTableEmpty) { - update_table(query, table, true); - } else - if (event == EcsOnTableFill) { - update_table(query, table, false); + if (state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid with in assign_stmt"); + return NULL; } -} - -/* -- Public API -- */ + /* Add following expressions to with list */ + state->with_stmt = true; + return ptr + 5; +} -ecs_query_t* ecs_query_init( +static +const char* parse_scope_open( ecs_world_t *world, - const ecs_query_desc_t *desc) + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) { - ecs_query_t *result = NULL; - ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); - - /* Ensure that while initially populating the query with tables, they are - * in the right empty/non-empty list. This ensures the query won't miss - * empty/non-empty events for tables that are currently out of sync, but - * change back to being in sync before processing pending events. */ - ecs_force_aperiodic(world); + state->isa_stmt = false; - result = flecs_sparse_add(world->queries, ecs_query_t); - ecs_poly_init(result, ecs_query_t); - result->id = flecs_sparse_last_id(world->queries); + if (state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid scope in assign_stmt"); + return NULL; + } - ecs_observer_desc_t observer_desc = { .filter = desc->filter }; - observer_desc.filter.match_empty_tables = true; + state->sp ++; - if (ecs_filter_init(world, &result->filter, &observer_desc.filter)) { - goto error; - } + ecs_entity_t scope = 0; + ecs_entity_t default_scope_type = 0; - if (result->filter.term_count) { - observer_desc.run = query_on_event; - observer_desc.ctx = result; - observer_desc.events[0] = EcsOnTableEmpty; - observer_desc.events[1] = EcsOnTableFill; - observer_desc.filter.filter = true; + if (!state->with_stmt) { + if (state->last_subject) { + scope = state->last_subject; + ecs_set_scope(world, state->last_subject); - /* ecs_filter_init could have moved away resources from the terms array - * in the descriptor, so use the terms array from the filter. */ - observer_desc.filter.terms_buffer = result->filter.terms; - observer_desc.filter.terms_buffer_count = result->filter.term_count; - observer_desc.filter.expr = NULL; /* Already parsed */ + /* Check if scope has a default child component */ + ecs_entity_t def_type_src = ecs_get_object_for_id(world, scope, + 0, ecs_pair(EcsDefaultChildComponent, EcsWildcard)); - result->observer = ecs_observer_init(world, &observer_desc); - if (!result->observer) { - goto error; + if (def_type_src) { + default_scope_type = ecs_get_object( + world, def_type_src, EcsDefaultChildComponent, 0); + } + } else { + if (state->last_object) { + scope = ecs_pair( + state->last_predicate, state->last_object); + ecs_set_with(world, scope); + } else { + if (state->last_predicate) { + scope = ecs_pair(EcsChildOf, state->last_predicate); + } + ecs_set_scope(world, state->last_predicate); + } } - } - ecs_table_cache_init(&result->cache); + state->scope[state->sp] = scope; + state->default_scope_type[state->sp] = default_scope_type; + } else { + state->scope[state->sp] = state->scope[state->sp - 1]; + state->default_scope_type[state->sp] = + state->default_scope_type[state->sp - 1]; + } - result->world = world; - result->iterable.init = query_iter_init; - result->system = desc->system; - result->prev_match_count = -1; + state->using_frames[state->sp] = state->using_frame; + state->with_frames[state->sp] = state->with_frame; + state->with_stmt = false; - process_signature(world, result); + return ptr; +} - /* Group before matching so we won't have to move tables around later */ - int32_t cascade_by = result->cascade_by; - if (cascade_by) { - query_group_by(result, result->filter.terms[cascade_by - 1].id, - group_by_cascade); - result->group_by_ctx = &result->filter.terms[cascade_by - 1]; +static +const char* parse_scope_close( + ecs_world_t *world, + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) +{ + if (state->isa_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "invalid '}' after inheritance statement"); + return NULL; } - if (desc->group_by) { - /* Can't have a cascade term and group by at the same time, as cascade - * uses the group_by mechanism */ - ecs_check(!result->cascade_by, ECS_INVALID_PARAMETER, NULL); - query_group_by(result, desc->group_by_id, desc->group_by); - result->group_by_ctx = desc->group_by_ctx; - result->group_by_ctx_free = desc->group_by_ctx_free; + if (state->assign_stmt) { + ecs_parser_error(name, expr, ptr - expr, + "unfinished assignment before }"); + return NULL; } - if (desc->parent != NULL) { - result->flags |= EcsQueryIsSubquery; + state->scope[state->sp] = 0; + state->default_scope_type[state->sp] = 0; + state->sp --; + + if (state->sp < 0) { + ecs_parser_error(name, expr, ptr - expr, "invalid } without a {"); + return NULL; } - /* If a system is specified, ensure that if there are any subjects in the - * filter that refer to the system, the component is added */ - if (desc->system) { - int32_t t, term_count = result->filter.term_count; - ecs_term_t *terms = result->filter.terms; + ecs_id_t id = state->scope[state->sp]; - for (t = 0; t < term_count; t ++) { - ecs_term_t *term = &terms[t]; - if (term->subj.entity == desc->system) { - ecs_add_id(world, desc->system, term->id); - } - } + if (!id || ECS_HAS_ROLE(id, PAIR)) { + ecs_set_with(world, id); } - if (ecs_should_log_1()) { - char *filter_expr = ecs_filter_str(world, &result->filter); - ecs_dbg_1("#[green]query#[normal] [%s] created", filter_expr); - ecs_os_free(filter_expr); + if (!id || !ECS_HAS_ROLE(id, PAIR)) { + ecs_set_scope(world, id); } - ecs_log_push_1(); + state->with_frame = state->with_frames[state->sp]; + state->using_frame = state->using_frames[state->sp]; + state->last_subject = 0; + state->assign_stmt = false; - if (!desc->parent) { - if (result->flags & EcsQueryNeedsTables) { - match_tables(world, result); - } else { - /* Add stub table that resolves references (if any) so everything is - * preprocessed when the query is evaluated. */ - add_table(world, result, NULL); - } - } else { - add_subquery(world, desc->parent, result); - result->parent = desc->parent; - } + return ptr; +} - if (desc->order_by) { - query_order_by( - world, result, desc->order_by_component, desc->order_by); - } +static +const char *parse_plecs_term( + ecs_world_t *world, + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) +{ + ecs_term_t term = {0}; + ecs_entity_t scope = ecs_get_scope(world); - result->constraints_satisfied = satisfy_constraints(world, &result->filter); + /* If first character is a (, this should be interpreted as an id assigned + * to the current scope if: + * - this is not already an assignment: "Foo = (Hello, World)" + * - this is in a scope + */ + bool scope_assignment = (ptr[0] == '(') && !state->assign_stmt && scope != 0; - ecs_log_pop_1(); + ptr = ecs_parse_term(world, name, expr, ptr, &term); + if (!ptr) { + return NULL; + } - return result; -error: - if (result) { - ecs_filter_fini(&result->filter); - if (result->observer) { - ecs_delete(world, result->observer); - } - flecs_sparse_remove(world->queries, result->id); + if (!ecs_term_is_initialized(&term)) { + ecs_parser_error(name, expr, ptr - expr, "expected identifier"); + return NULL; /* No term found */ } - return NULL; -} -static -void table_cache_free( - ecs_query_t *query) -{ - ecs_table_cache_iter_t it; - ecs_query_table_t *qt; + /* Lookahead to check if this is an implicit scope assignment (no parens) */ + if (ptr[0] == '=') { + const char *tptr = ecs_parse_fluff(ptr + 1, NULL); + if (tptr[0] == '{') { + ecs_entity_t pred = plecs_lookup( + world, term.pred.name, state, false); + ecs_entity_t obj = plecs_lookup( + world, term.obj.name, state, false); + ecs_id_t id = 0; + if (pred && obj) { + id = ecs_pair(pred, obj); + } else if (pred) { + id = pred; + } - if (flecs_table_cache_iter(&query->cache, &it)) { - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - query_table_free(query, qt); - } + if (id && (ecs_get_typeid(world, id) != 0)) { + scope_assignment = true; + } + } } - if (flecs_table_cache_empty_iter(&query->cache, &it)) { - while ((qt = flecs_table_cache_next(&it, ecs_query_table_t))) { - query_table_free(query, qt); - } + bool prev = state->assign_stmt; + if (scope_assignment) { + state->assign_stmt = true; + state->assign_to = scope; + } + if (create_term(world, &term, name, expr, (ptr - expr), state)) { + ecs_term_fini(&term); + return NULL; /* Failed to create term */ + } + if (scope_assignment) { + state->last_subject = state->last_assign_id; + state->scope_assign_stmt = true; } + state->assign_stmt = prev; - ecs_table_cache_fini(&query->cache); + ecs_term_fini(&term); + + return ptr; } -void ecs_query_fini( - ecs_query_t *query) +static +const char* parse_stmt( + ecs_world_t *world, + const char *name, + const char *expr, + const char *ptr, + plecs_state_t *state) { - ecs_poly_assert(query, ecs_query_t); - ecs_world_t *world = query->world; - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + state->assign_stmt = false; + state->scope_assign_stmt = false; + state->isa_stmt = false; + state->with_stmt = false; + state->using_stmt = false; + state->last_subject = 0; + state->last_predicate = 0; + state->last_object = 0; - if (!world->is_fini) { - ecs_delete(world, query->observer); - } + ptr = parse_fluff(expr, ptr, state); - if (query->group_by_ctx_free) { - if (query->group_by_ctx) { - query->group_by_ctx_free(query->group_by_ctx); - } - } + char ch = ptr[0]; - if ((query->flags & EcsQueryIsSubquery) && - !(query->flags & EcsQueryIsOrphaned)) - { - remove_subquery(query->parent, query); + if (!ch) { + goto done; + } else if (ch == '{') { + ptr = parse_fluff(expr, ptr + 1, state); + goto scope_open; + } else if (ch == '}') { + ptr = parse_fluff(expr, ptr + 1, state); + goto scope_close; + } else if (ch == '(') { + goto term_expr; + } else if (!ecs_os_strncmp(ptr, TOK_USING " ", 5)) { + ptr = parse_using_stmt(name, expr, ptr, state); + if (!ptr) goto error; + goto term_expr; + } else if (!ecs_os_strncmp(ptr, TOK_WITH " ", 5)) { + ptr = parse_with_stmt(name, expr, ptr, state); + if (!ptr) goto error; + goto term_expr; + } else { + goto term_expr; } - notify_subqueries(world, query, &(ecs_query_event_t){ - .kind = EcsQueryOrphan - }); - - unregister_monitors(world, query); - - table_cache_free(query); +term_expr: + if (!ptr[0]) { + goto done; + } - ecs_map_fini(&query->groups); + if (!(ptr = parse_plecs_term(world, name, ptr, ptr, state))) { + goto error; + } - ecs_vector_free(query->subqueries); - ecs_vector_free(query->table_slices); - ecs_filter_fini(&query->filter); + ptr = parse_fluff(expr, ptr, state); - ecs_poly_fini(query, ecs_query_t); - - /* Remove query from storage */ - flecs_sparse_remove(world->queries, query->id); -error: - return; -} + if (ptr[0] == '{' && !isspace(ptr[-1])) { + /* A '{' directly after an identifier (no whitespace) is a literal */ + goto assign_expr; + } -const ecs_filter_t* ecs_query_get_filter( - ecs_query_t *query) -{ - ecs_poly_assert(query, ecs_query_t); - return &query->filter; -} + if (!state->using_stmt) { + if (ptr[0] == ':') { + ptr = parse_fluff(expr, ptr + 1, state); + goto inherit_stmt; + } else if (ptr[0] == '=') { + ptr = parse_fluff(expr, ptr + 1, state); + goto assign_stmt; + } else if (ptr[0] == ',') { + ptr = parse_fluff(expr, ptr + 1, state); + goto term_expr; + } else if (ptr[0] == '{') { + state->assign_stmt = false; + ptr = parse_fluff(expr, ptr + 1, state); + goto scope_open; + } + } -/* Create query iterator */ -ecs_iter_t ecs_query_iter( - const ecs_world_t *stage, - ecs_query_t *query) -{ - ecs_poly_assert(query, ecs_query_t); - ecs_check(!(query->flags & EcsQueryIsOrphaned), - ECS_INVALID_PARAMETER, NULL); + state->assign_stmt = false; + goto done; - query->constraints_satisfied = satisfy_constraints(query->world, &query->filter); +inherit_stmt: + ptr = parse_inherit_stmt(name, expr, ptr, state); + if (!ptr) goto error; - ecs_world_t *world = (ecs_world_t*)ecs_get_world(stage); + /* Expect base identifier */ + goto term_expr; - flecs_process_pending_tables(world); +assign_stmt: + ptr = parse_assign_stmt(world, name, expr, ptr, state); + if (!ptr) goto error; - sort_tables(world, query); + ptr = parse_fluff(expr, ptr, state); - if (!world->is_readonly && query->flags & EcsQueryHasRefs) { - flecs_eval_component_monitors(world); + /* Assignment without a preceding component */ + if (ptr[0] == '{') { + goto assign_expr; } - query->prev_match_count = query->match_count; + /* Expect component identifiers */ + goto term_expr; - int32_t table_count; - if (query->table_slices) { - table_count = ecs_vector_count(query->table_slices); +assign_expr: + ptr = parse_assign_expr(world, name, expr, ptr, state); + if (!ptr) goto error; + + ptr = parse_fluff(expr, ptr, state); + if (ptr[0] == ',') { + ptr ++; + goto term_expr; + } else if (ptr[0] == '{') { + state->assign_stmt = false; + ptr ++; + goto scope_open; } else { - table_count = ecs_query_table_count(query); + state->assign_stmt = false; + goto done; } - ecs_query_iter_t it = { - .query = query, - .node = query->list.first - }; +scope_open: + ptr = parse_scope_open(world, name, expr, ptr, state); + if (!ptr) goto error; + goto done; - if (query->order_by && query->list.count) { - it.node = ecs_vector_first(query->table_slices, ecs_query_table_node_t); - } +scope_close: + ptr = parse_scope_close(world, name, expr, ptr, state); + if (!ptr) goto error; + goto done; - return (ecs_iter_t){ - .real_world = world, - .world = (ecs_world_t*)stage, - .terms = query->filter.terms, - .term_count = query->filter.term_count_actual, - .table_count = table_count, - .is_filter = query->filter.filter, - .is_instanced = query->filter.instanced, - .priv.iter.query = it, - .next = ecs_query_next, - }; +done: + return ptr; error: - return (ecs_iter_t){ 0 }; + return NULL; } -static -int find_smallest_column( - ecs_table_t *table, - ecs_query_table_match_t *table_data, - ecs_vector_t *sparse_columns) +int ecs_plecs_from_str( + ecs_world_t *world, + const char *name, + const char *expr) { - flecs_sparse_column_t *sparse_column_array = - ecs_vector_first(sparse_columns, flecs_sparse_column_t); - int32_t i, count = ecs_vector_count(sparse_columns); - int32_t min = INT_MAX, index = 0; - - for (i = 0; i < count; i ++) { - /* The array with sparse queries for the matched table */ - flecs_sparse_column_t *sparse_column = &sparse_column_array[i]; - - /* Pointer to the switch column struct of the table */ - ecs_sw_column_t *sc = sparse_column->sw_column; + const char *ptr = expr; + ecs_term_t term = {0}; + plecs_state_t state = {0}; - /* If the sparse column pointer hadn't been retrieved yet, do it now */ - if (!sc) { - /* Get the table column index from the signature column index */ - int32_t table_column_index = table_data->columns[ - sparse_column->signature_column_index]; + if (!expr) { + return 0; + } - /* Translate the table column index to switch column index */ - table_column_index -= table->sw_column_offset; - ecs_assert(table_column_index >= 1, ECS_INTERNAL_ERROR, NULL); + state.scope[0] = 0; + ecs_entity_t prev_scope = ecs_set_scope(world, 0); + ecs_entity_t prev_with = ecs_set_with(world, 0); - /* Get the sparse column */ - ecs_data_t *data = &table->storage; - sc = sparse_column->sw_column = - &data->sw_columns[table_column_index - 1]; + do { + expr = ptr = parse_stmt(world, name, expr, ptr, &state); + if (!ptr) { + goto error; } - /* Find the smallest column */ - ecs_switch_t *sw = sc->data; - int32_t case_count = flecs_switch_case_count(sw, sparse_column->sw_case); - if (case_count < min) { - min = case_count; - index = i + 1; + if (!ptr[0]) { + break; /* End of expression */ } - } - - return index; -} - -typedef struct { - int32_t first; - int32_t count; -} query_iter_cursor_t; + } while (true); -static -int sparse_column_next( - ecs_table_t *table, - ecs_query_table_match_t *matched_table, - ecs_vector_t *sparse_columns, - ecs_query_iter_t *iter, - query_iter_cursor_t *cur, - bool filter) -{ - bool first_iteration = false; - int32_t sparse_smallest; + ecs_set_scope(world, prev_scope); + ecs_set_with(world, prev_with); + + clear_comment(expr, ptr, &state); - if (!(sparse_smallest = iter->sparse_smallest)) { - sparse_smallest = iter->sparse_smallest = find_smallest_column( - table, matched_table, sparse_columns); - first_iteration = true; + if (state.sp != 0) { + ecs_parser_error(name, expr, 0, "missing end of scope"); + goto error; } - sparse_smallest -= 1; - - flecs_sparse_column_t *columns = ecs_vector_first( - sparse_columns, flecs_sparse_column_t); - flecs_sparse_column_t *column = &columns[sparse_smallest]; - ecs_switch_t *sw, *sw_smallest = column->sw_column->data; - ecs_entity_t case_smallest = column->sw_case; - - /* Find next entity to iterate in sparse column */ - int32_t first, sparse_first = iter->sparse_first; - - if (!filter) { - if (first_iteration) { - first = flecs_switch_first(sw_smallest, case_smallest); - } else { - first = flecs_switch_next(sw_smallest, sparse_first); - } - } else { - int32_t cur_first = cur->first, cur_count = cur->count; - first = cur_first; - while (flecs_switch_get(sw_smallest, first) != case_smallest) { - first ++; - if (first >= (cur_first + cur_count)) { - first = -1; - break; - } - } + if (state.assign_stmt) { + ecs_parser_error(name, expr, 0, "unfinished assignment"); + goto error; } - if (first == -1) { - goto done; + if (state.errors) { + goto error; } - /* Check if entity matches with other sparse columns, if any */ - int32_t i, count = ecs_vector_count(sparse_columns); - do { - for (i = 0; i < count; i ++) { - if (i == sparse_smallest) { - /* Already validated this one */ - continue; - } - - column = &columns[i]; - sw = column->sw_column->data; - - if (flecs_switch_get(sw, first) != column->sw_case) { - first = flecs_switch_next(sw_smallest, first); - if (first == -1) { - goto done; - } - } - } - } while (i != count); - - cur->first = iter->sparse_first = first; - cur->count = 1; - return 0; -done: - /* Iterated all elements in the sparse list, we should move to the - * next matched table. */ - iter->sparse_smallest = 0; - iter->sparse_first = 0; - +error: + ecs_set_scope(world, state.scope[0]); + ecs_set_with(world, prev_with); + ecs_term_fini(&term); return -1; } -#define BS_MAX ((uint64_t)0xFFFFFFFFFFFFFFFF) - -static -int bitset_column_next( - ecs_table_t *table, - ecs_vector_t *bitset_columns, - ecs_query_iter_t *iter, - query_iter_cursor_t *cur) +int ecs_plecs_from_file( + ecs_world_t *world, + const char *filename) { - /* Precomputed single-bit test */ - static const uint64_t bitmask[64] = { - (uint64_t)1 << 0, (uint64_t)1 << 1, (uint64_t)1 << 2, (uint64_t)1 << 3, - (uint64_t)1 << 4, (uint64_t)1 << 5, (uint64_t)1 << 6, (uint64_t)1 << 7, - (uint64_t)1 << 8, (uint64_t)1 << 9, (uint64_t)1 << 10, (uint64_t)1 << 11, - (uint64_t)1 << 12, (uint64_t)1 << 13, (uint64_t)1 << 14, (uint64_t)1 << 15, - (uint64_t)1 << 16, (uint64_t)1 << 17, (uint64_t)1 << 18, (uint64_t)1 << 19, - (uint64_t)1 << 20, (uint64_t)1 << 21, (uint64_t)1 << 22, (uint64_t)1 << 23, - (uint64_t)1 << 24, (uint64_t)1 << 25, (uint64_t)1 << 26, (uint64_t)1 << 27, - (uint64_t)1 << 28, (uint64_t)1 << 29, (uint64_t)1 << 30, (uint64_t)1 << 31, - (uint64_t)1 << 32, (uint64_t)1 << 33, (uint64_t)1 << 34, (uint64_t)1 << 35, - (uint64_t)1 << 36, (uint64_t)1 << 37, (uint64_t)1 << 38, (uint64_t)1 << 39, - (uint64_t)1 << 40, (uint64_t)1 << 41, (uint64_t)1 << 42, (uint64_t)1 << 43, - (uint64_t)1 << 44, (uint64_t)1 << 45, (uint64_t)1 << 46, (uint64_t)1 << 47, - (uint64_t)1 << 48, (uint64_t)1 << 49, (uint64_t)1 << 50, (uint64_t)1 << 51, - (uint64_t)1 << 52, (uint64_t)1 << 53, (uint64_t)1 << 54, (uint64_t)1 << 55, - (uint64_t)1 << 56, (uint64_t)1 << 57, (uint64_t)1 << 58, (uint64_t)1 << 59, - (uint64_t)1 << 60, (uint64_t)1 << 61, (uint64_t)1 << 62, (uint64_t)1 << 63 - }; - - /* Precomputed test to verify if remainder of block is set (or not) */ - static const uint64_t bitmask_remain[64] = { - BS_MAX, BS_MAX - (BS_MAX >> 63), BS_MAX - (BS_MAX >> 62), - BS_MAX - (BS_MAX >> 61), BS_MAX - (BS_MAX >> 60), BS_MAX - (BS_MAX >> 59), - BS_MAX - (BS_MAX >> 58), BS_MAX - (BS_MAX >> 57), BS_MAX - (BS_MAX >> 56), - BS_MAX - (BS_MAX >> 55), BS_MAX - (BS_MAX >> 54), BS_MAX - (BS_MAX >> 53), - BS_MAX - (BS_MAX >> 52), BS_MAX - (BS_MAX >> 51), BS_MAX - (BS_MAX >> 50), - BS_MAX - (BS_MAX >> 49), BS_MAX - (BS_MAX >> 48), BS_MAX - (BS_MAX >> 47), - BS_MAX - (BS_MAX >> 46), BS_MAX - (BS_MAX >> 45), BS_MAX - (BS_MAX >> 44), - BS_MAX - (BS_MAX >> 43), BS_MAX - (BS_MAX >> 42), BS_MAX - (BS_MAX >> 41), - BS_MAX - (BS_MAX >> 40), BS_MAX - (BS_MAX >> 39), BS_MAX - (BS_MAX >> 38), - BS_MAX - (BS_MAX >> 37), BS_MAX - (BS_MAX >> 36), BS_MAX - (BS_MAX >> 35), - BS_MAX - (BS_MAX >> 34), BS_MAX - (BS_MAX >> 33), BS_MAX - (BS_MAX >> 32), - BS_MAX - (BS_MAX >> 31), BS_MAX - (BS_MAX >> 30), BS_MAX - (BS_MAX >> 29), - BS_MAX - (BS_MAX >> 28), BS_MAX - (BS_MAX >> 27), BS_MAX - (BS_MAX >> 26), - BS_MAX - (BS_MAX >> 25), BS_MAX - (BS_MAX >> 24), BS_MAX - (BS_MAX >> 23), - BS_MAX - (BS_MAX >> 22), BS_MAX - (BS_MAX >> 21), BS_MAX - (BS_MAX >> 20), - BS_MAX - (BS_MAX >> 19), BS_MAX - (BS_MAX >> 18), BS_MAX - (BS_MAX >> 17), - BS_MAX - (BS_MAX >> 16), BS_MAX - (BS_MAX >> 15), BS_MAX - (BS_MAX >> 14), - BS_MAX - (BS_MAX >> 13), BS_MAX - (BS_MAX >> 12), BS_MAX - (BS_MAX >> 11), - BS_MAX - (BS_MAX >> 10), BS_MAX - (BS_MAX >> 9), BS_MAX - (BS_MAX >> 8), - BS_MAX - (BS_MAX >> 7), BS_MAX - (BS_MAX >> 6), BS_MAX - (BS_MAX >> 5), - BS_MAX - (BS_MAX >> 4), BS_MAX - (BS_MAX >> 3), BS_MAX - (BS_MAX >> 2), - BS_MAX - (BS_MAX >> 1) - }; - - int32_t i, count = ecs_vector_count(bitset_columns); - flecs_bitset_column_t *columns = ecs_vector_first( - bitset_columns, flecs_bitset_column_t); - int32_t bs_offset = table->bs_column_offset; - - int32_t first = iter->bitset_first; - int32_t last = 0; - - for (i = 0; i < count; i ++) { - flecs_bitset_column_t *column = &columns[i]; - ecs_bs_column_t *bs_column = columns[i].bs_column; - - if (!bs_column) { - int32_t index = column->column_index; - ecs_assert((index - bs_offset >= 0), ECS_INTERNAL_ERROR, NULL); - bs_column = &table->storage.bs_columns[index - bs_offset]; - columns[i].bs_column = bs_column; - } - - ecs_bitset_t *bs = &bs_column->data; - int32_t bs_elem_count = bs->count; - int32_t bs_block = first >> 6; - int32_t bs_block_count = ((bs_elem_count - 1) >> 6) + 1; - - if (bs_block >= bs_block_count) { - goto done; - } + FILE* file; + char* content = NULL; + int32_t bytes; + size_t size; - uint64_t *data = bs->data; - int32_t bs_start = first & 0x3F; + /* Open file for reading */ + ecs_os_fopen(&file, filename, "r"); + if (!file) { + ecs_err("%s (%s)", ecs_os_strerror(errno), filename); + goto error; + } - /* Step 1: find the first non-empty block */ - uint64_t v = data[bs_block]; - uint64_t remain = bitmask_remain[bs_start]; - while (!(v & remain)) { - /* If no elements are remaining, move to next block */ - if ((++bs_block) >= bs_block_count) { - /* No non-empty blocks left */ - goto done; - } + /* Determine file size */ + fseek(file, 0 , SEEK_END); + bytes = (int32_t)ftell(file); + if (bytes == -1) { + goto error; + } + rewind(file); - bs_start = 0; - remain = BS_MAX; /* Test the full block */ - v = data[bs_block]; - } + /* Load contents in memory */ + content = ecs_os_malloc(bytes + 1); + size = (size_t)bytes; + if (!(size = fread(content, 1, size, file)) && bytes) { + ecs_err("%s: read zero bytes instead of %d", filename, size); + ecs_os_free(content); + content = NULL; + goto error; + } else { + content[size] = '\0'; + } - /* Step 2: find the first non-empty element in the block */ - while (!(v & bitmask[bs_start])) { - bs_start ++; + fclose(file); - /* Block was not empty, so bs_start must be smaller than 64 */ - ecs_assert(bs_start < 64, ECS_INTERNAL_ERROR, NULL); - } - - /* Step 3: Find number of contiguous enabled elements after start */ - int32_t bs_end = bs_start, bs_block_end = bs_block; - - remain = bitmask_remain[bs_end]; - while ((v & remain) == remain) { - bs_end = 0; - bs_block_end ++; + int result = ecs_plecs_from_str(world, filename, content); + ecs_os_free(content); + return result; +error: + ecs_os_free(content); + return -1; +} - if (bs_block_end == bs_block_count) { - break; - } +#endif - v = data[bs_block_end]; - remain = BS_MAX; /* Test the full block */ - } - /* Step 4: find remainder of enabled elements in current block */ - if (bs_block_end != bs_block_count) { - while ((v & bitmask[bs_end])) { - bs_end ++; - } - } +#ifdef FLECS_PIPELINE - /* Block was not 100% occupied, so bs_start must be smaller than 64 */ - ecs_assert(bs_end < 64, ECS_INTERNAL_ERROR, NULL); +/* Worker thread */ +static +void* worker(void *arg) { + ecs_stage_t *stage = arg; + ecs_world_t *world = stage->world; - /* Step 5: translate to element start/end and make sure that each column - * range is a subset of the previous one. */ - first = bs_block * 64 + bs_start; - int32_t cur_last = bs_block_end * 64 + bs_end; - - /* No enabled elements found in table */ - if (first == cur_last) { - goto done; - } + /* Start worker thread, increase counter so main thread knows how many + * workers are ready */ + ecs_os_mutex_lock(world->sync_mutex); + world->workers_running ++; - /* If multiple bitsets are evaluated, make sure each subsequent range - * is equal or a subset of the previous range */ - if (i) { - /* If the first element of a subsequent bitset is larger than the - * previous last value, start over. */ - if (first >= last) { - i = -1; - continue; - } + if (!world->quit_workers) { + ecs_os_cond_wait(world->worker_cond, world->sync_mutex); + } - /* Make sure the last element of the range doesn't exceed the last - * element of the previous range. */ - if (cur_last > last) { - cur_last = last; - } - } + ecs_os_mutex_unlock(world->sync_mutex); - last = cur_last; - int32_t elem_count = last - first; + while (!world->quit_workers) { + ecs_entity_t old_scope = ecs_set_scope((ecs_world_t*)stage, 0); + + ecs_run_pipeline( + (ecs_world_t*)stage, + world->pipeline, + world->stats.delta_time); - /* Make sure last element doesn't exceed total number of elements in - * the table */ - if (elem_count > (bs_elem_count - first)) { - elem_count = (bs_elem_count - first); - if (!elem_count) { - iter->bitset_first = 0; - goto done; - } - } - - cur->first = first; - cur->count = elem_count; - iter->bitset_first = first; + ecs_set_scope((ecs_world_t*)stage, old_scope); } - - /* Keep track of last processed element for iteration */ - iter->bitset_first = last; - return 0; -done: - iter->sparse_smallest = 0; - iter->sparse_first = 0; - return -1; + ecs_os_mutex_lock(world->sync_mutex); + world->workers_running --; + ecs_os_mutex_unlock(world->sync_mutex); + + return NULL; } +/* Start threads */ static -void mark_columns_dirty( - ecs_query_t *query, - ecs_query_table_match_t *table_data) +void start_workers( + ecs_world_t *world, + int32_t threads) { - ecs_table_t *table = table_data->table; + ecs_set_stages(world, threads); - if (table && table->dirty_state) { - ecs_term_t *terms = query->filter.terms; - int32_t i, count = query->filter.term_count_actual; - for (i = 0; i < count; i ++) { - ecs_term_t *term = &terms[i]; - int32_t ti = term->index; + ecs_assert(ecs_get_stage_count(world) == threads, ECS_INTERNAL_ERROR, NULL); - if (term->inout == EcsIn || term->inout == EcsInOutFilter) { - /* Don't mark readonly terms dirty */ - continue; - } + int32_t i; + for (i = 0; i < threads; i ++) { + ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); + ecs_assert(stage != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_poly_assert(stage, ecs_stage_t); - if (table_data->subjects[ti] != 0) { - /* Don't mark table dirty if term is not from the table */ - continue; - } + ecs_vector_get(world->worker_stages, ecs_stage_t, i); + stage->thread = ecs_os_thread_new(worker, stage); + ecs_assert(stage->thread != 0, ECS_OPERATION_FAILED, NULL); + } +} - int32_t index = table_data->columns[ti]; - if (index <= 0) { - /* If term is not set, there's nothing to mark dirty */ - continue; - } +/* Wait until all workers are running */ +static +void wait_for_workers( + ecs_world_t *world) +{ + int32_t stage_count = ecs_get_stage_count(world); + bool wait = true; - /* Potential candidate for marking table dirty, if a component */ - int32_t storage_index = ecs_table_type_to_storage_index( - table, index - 1); - if (storage_index >= 0) { - table->dirty_state[storage_index + 1] ++; - } + do { + ecs_os_mutex_lock(world->sync_mutex); + if (world->workers_running == stage_count) { + wait = false; } - } + ecs_os_mutex_unlock(world->sync_mutex); + } while (wait); } -bool ecs_query_next( - ecs_iter_t *it) +/* Synchronize worker threads */ +static +void sync_worker( + ecs_world_t *world) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); + int32_t stage_count = ecs_get_stage_count(world); - if (flecs_iter_next_row(it)) { - return true; + /* Signal that thread is waiting */ + ecs_os_mutex_lock(world->sync_mutex); + if (++ world->workers_waiting == stage_count) { + /* Only signal main thread when all threads are waiting */ + ecs_os_cond_signal(world->sync_cond); } - return flecs_iter_next_instanced(it, ecs_query_next_instanced(it)); -error: - return false; + /* Wait until main thread signals that thread can continue */ + ecs_os_cond_wait(world->worker_cond, world->sync_mutex); + ecs_os_mutex_unlock(world->sync_mutex); } -bool ecs_query_next_instanced( - ecs_iter_t *it) +/* Wait until all threads are waiting on sync point */ +static +void wait_for_sync( + ecs_world_t *world) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); + int32_t stage_count = ecs_get_stage_count(world); - ecs_query_iter_t *iter = &it->priv.iter.query; - ecs_query_t *query = iter->query; - ecs_world_t *world = query->world; - ecs_flags32_t flags = query->flags; - (void)world; + ecs_os_mutex_lock(world->sync_mutex); + if (world->workers_waiting != stage_count) { + ecs_os_cond_wait(world->sync_cond, world->sync_mutex); + } + + /* We should have been signalled unless all workers are waiting on sync */ + ecs_assert(world->workers_waiting == stage_count, + ECS_INTERNAL_ERROR, NULL); - it->is_valid = true; + ecs_os_mutex_unlock(world->sync_mutex); +} - ecs_poly_assert(world, ecs_world_t); +/* Signal workers that they can start/resume work */ +static +void signal_workers( + ecs_world_t *world) +{ + ecs_os_mutex_lock(world->sync_mutex); + ecs_os_cond_broadcast(world->worker_cond); + ecs_os_mutex_unlock(world->sync_mutex); +} - if (!query->constraints_satisfied) { - goto done; - } +/** Stop worker threads */ +static +bool ecs_stop_threads( + ecs_world_t *world) +{ + bool threads_active = false; - query_iter_cursor_t cur; - ecs_query_table_node_t *node, *next, *prev; - if ((prev = iter->prev)) { - /* Match has been iterated, update monitor for change tracking */ - if (flags & EcsQueryHasMonitor) { - sync_match_monitor(query, prev->match); - } - if (flags & EcsQueryHasOutColumns) { - mark_columns_dirty(query, prev->match); + /* Test if threads are created. Cannot use workers_running, since this is + * a potential race if threads haven't spun up yet. */ + ecs_vector_each(world->worker_stages, ecs_stage_t, stage, { + if (stage->thread) { + threads_active = true; + break; } - } - - iter->skip_count = 0; + stage->thread = 0; + }); - for (node = iter->node; node != NULL; node = next) { - ecs_query_table_match_t *match = node->match; - ecs_table_t *table = match->table; + /* If no threads are active, just return */ + if (!threads_active) { + return false; + } - next = node->next; + /* Make sure all threads are running, to ensure they catch the signal */ + wait_for_workers(world); - if (table) { - cur.first = node->offset; - cur.count = node->count; - if (!cur.count) { - cur.count = ecs_table_count(table); + /* Signal threads should quit */ + world->quit_workers = true; + signal_workers(world); - /* List should never contain empty tables */ - ecs_assert(cur.count != 0, ECS_INTERNAL_ERROR, NULL); - } + /* Join all threads with main */ + ecs_stage_t *stages = ecs_vector_first(world->worker_stages, ecs_stage_t); + int32_t i, count = ecs_vector_count(world->worker_stages); + for (i = 0; i < count; i ++) { + ecs_os_thread_join(stages[i].thread); + stages[i].thread = 0; + } - ecs_vector_t *bitset_columns = match->bitset_columns; - ecs_vector_t *sparse_columns = match->sparse_columns; + world->quit_workers = false; + ecs_assert(world->workers_running == 0, ECS_INTERNAL_ERROR, NULL); - if (bitset_columns || sparse_columns) { - bool found = false; + /* Deinitialize stages */ + ecs_set_stages(world, 0); - do { - found = false; + return true; +} - if (bitset_columns) { - if (bitset_column_next(table, bitset_columns, iter, - &cur) == -1) - { - /* No more enabled components for table */ - iter->bitset_first = 0; - break; - } else { - found = true; - next = node; - } - } +/* -- Private functions -- */ - if (sparse_columns) { - if (sparse_column_next(table, match, - sparse_columns, iter, &cur, found) == -1) - { - /* No more elements in sparse column */ - if (found) { - /* Try again */ - next = node->next; - found = false; - } else { - /* Nothing found */ - iter->bitset_first = 0; - break; - } - } else { - found = true; - next = node; - iter->bitset_first = cur.first + cur.count; - } - } - } while (!found); +void ecs_worker_begin( + ecs_world_t *world) +{ + flecs_stage_from_world(&world); + int32_t stage_count = ecs_get_stage_count(world); + ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); + + if (stage_count == 1) { + ecs_entity_t pipeline = world->pipeline; + const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); + ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - if (!found) { - continue; - } - } - } else { - cur.count = 0; - cur.first = 0; + ecs_pipeline_op_t *op = ecs_vector_first(pq->ops, ecs_pipeline_op_t); + if (!op || !op->no_staging) { + ecs_staging_begin(world); } - - it->ids = match->ids; - it->columns = match->columns; - it->subjects = match->subjects; - it->sizes = match->sizes; - it->references = match->references; - it->instance_count = 0; - - flecs_iter_init(it); - flecs_iter_populate_data(world, it, match->table, cur.first, cur.count, - it->ptrs, NULL); - - iter->node = next; - iter->prev = node; - goto yield; } - -done: -error: - ecs_iter_fini(it); - return false; - -yield: - return true; } -bool ecs_query_changed( - ecs_query_t *query, - const ecs_iter_t *it) +int32_t ecs_worker_sync( + ecs_world_t *world, + const EcsPipelineQuery *pq, + ecs_iter_t *it, + int32_t i, + ecs_pipeline_op_t **op_out, + ecs_pipeline_op_t **last_op_out) { - if (it) { - ecs_check(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - - ecs_query_table_match_t *qt = - (ecs_query_table_match_t*)it->priv.iter.query.prev; - ecs_assert(qt != NULL, ECS_INVALID_PARAMETER, NULL); + int32_t stage_count = ecs_get_stage_count(world); + ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); + int32_t build_count = world->stats.pipeline_build_count_total; - if (!query) { - query = it->priv.iter.query.query; - } else { - ecs_check(query == it->priv.iter.query.query, - ECS_INVALID_PARAMETER, NULL); + /* If there are no threads, merge in place */ + if (stage_count == 1) { + if (!op_out[0]->no_staging) { + ecs_staging_end(world); } - ecs_check(query != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_poly_assert(query, ecs_query_t); - - flecs_process_pending_tables(it->real_world); + ecs_pipeline_update(world, world->pipeline, false); - return check_match_monitor(query, qt); + /* Synchronize all workers. The last worker to reach the sync point will + * signal the main thread, which will perform the merge. */ + } else { + sync_worker(world); } - ecs_poly_assert(query, ecs_query_t); - ecs_check(!(query->flags & EcsQueryIsOrphaned), - ECS_INVALID_PARAMETER, NULL); - - flecs_process_pending_tables(query->world); - - if (!(query->flags & EcsQueryHasMonitor)) { - query->flags |= EcsQueryHasMonitor; - init_query_monitors(query); - return true; /* Monitors didn't exist yet */ + if (build_count != world->stats.pipeline_build_count_total) { + i = ecs_pipeline_reset_iter(world, pq, it, op_out, last_op_out); + } else { + op_out[0] ++; } - if (query->match_count != query->prev_match_count) { - return true; + if (stage_count == 1) { + if (!op_out[0]->no_staging) { + ecs_staging_begin(world); + } } - return check_query_monitor(query); -error: - return false; + return i; } -void ecs_query_skip( - ecs_iter_t *it) +void ecs_worker_end( + ecs_world_t *world) { - ecs_assert(it->next == ecs_query_next, ECS_INVALID_PARAMETER, NULL); - ecs_assert(it->is_valid, ECS_INVALID_PARAMETER, NULL); + flecs_stage_from_world(&world); - if (it->instance_count > it->count) { - it->priv.iter.query.skip_count ++; - if (it->priv.iter.query.skip_count == it->instance_count) { - /* For non-instanced queries, make sure all entities are skipped */ - it->priv.iter.query.prev = NULL; + int32_t stage_count = ecs_get_stage_count(world); + ecs_assert(stage_count != 0, ECS_INTERNAL_ERROR, NULL); + + /* If there are no threads, merge in place */ + if (stage_count == 1) { + if (ecs_stage_is_readonly(world)) { + ecs_staging_end(world); } + + /* Synchronize all workers. The last worker to reach the sync point will + * signal the main thread, which will perform the merge. */ } else { - it->priv.iter.query.prev = NULL; + sync_worker(world); } } -bool ecs_query_orphaned( - ecs_query_t *query) +void ecs_workers_progress( + ecs_world_t *world, + ecs_entity_t pipeline, + FLECS_FLOAT delta_time) { - ecs_poly_assert(query, ecs_query_t); - return query->flags & EcsQueryIsOrphaned; -} + ecs_poly_assert(world, ecs_world_t); + int32_t stage_count = ecs_get_stage_count(world); -#include + ecs_time_t start = {0}; + if (world->measure_frame_time) { + ecs_time_measure(&start); + } -/* Marker object used to differentiate a component vs. a tag edge */ -static ecs_table_diff_t ecs_table_edge_is_component; + if (stage_count == 1) { + ecs_pipeline_update(world, pipeline, true); + ecs_entity_t old_scope = ecs_set_scope(world, 0); + ecs_world_t *stage = ecs_get_stage(world, 0); + ecs_run_pipeline(stage, pipeline, delta_time); + ecs_set_scope(world, old_scope); + } else { + ecs_pipeline_update(world, pipeline, true); -static -uint64_t ids_hash(const void *ptr) { - const ecs_ids_t *type = ptr; - ecs_id_t *ids = type->array; - int32_t count = type->count; - uint64_t hash = flecs_hash(ids, count * ECS_SIZEOF(ecs_id_t)); - return hash; -} + const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); + ecs_vector_t *ops = pq->ops; + ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); + ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); -static -int ids_compare(const void *ptr_1, const void *ptr_2) { - const ecs_ids_t *type_1 = ptr_1; - const ecs_ids_t *type_2 = ptr_2; + /* Make sure workers are running and ready */ + wait_for_workers(world); - int32_t count_1 = type_1->count; - int32_t count_2 = type_2->count; + /* Synchronize n times for each op in the pipeline */ + for (; op <= op_last; op ++) { + if (!op->no_staging) { + ecs_staging_begin(world); + } - if (count_1 != count_2) { - return (count_1 > count_2) - (count_1 < count_2); - } + /* Signal workers that they should start running systems */ + world->workers_waiting = 0; + signal_workers(world); - const ecs_id_t *ids_1 = type_1->array; - const ecs_id_t *ids_2 = type_2->array; - - int32_t i; - for (i = 0; i < count_1; i ++) { - ecs_id_t id_1 = ids_1[i]; - ecs_id_t id_2 = ids_2[i]; + /* Wait until all workers are waiting on sync point */ + wait_for_sync(world); - if (id_1 != id_2) { - return (id_1 > id_2) - (id_1 < id_2); + /* Merge */ + if (!op->no_staging) { + ecs_staging_end(world); + } + + if (ecs_pipeline_update(world, pipeline, false)) { + /* Refetch, in case pipeline itself has moved */ + pq = ecs_get(world, pipeline, EcsPipelineQuery); + + /* Pipeline has changed, reset position in pipeline */ + ecs_iter_t it; + ecs_pipeline_reset_iter(world, pq, &it, &op, &op_last); + op --; + } } } - return 0; + if (world->measure_frame_time) { + world->stats.system_time_total += (float)ecs_time_measure(&start); + } } -void flecs_table_hashmap_init(ecs_hashmap_t *hm) { - flecs_hashmap_init(hm, ecs_ids_t, ecs_table_t*, ids_hash, ids_compare); -} +/* -- Public functions -- */ -const EcsComponent* flecs_component_from_id( - const ecs_world_t *world, - ecs_entity_t e) +void ecs_set_threads( + ecs_world_t *world, + int32_t threads) { - ecs_entity_t pair = 0; + ecs_assert(threads <= 1 || ecs_os_has_threading(), ECS_MISSING_OS_API, NULL); - /* If this is a pair, get the pair component from the identifier */ - if (ECS_HAS_ROLE(e, PAIR)) { - pair = e; - e = ecs_get_alive(world, ECS_PAIR_FIRST(e)); + int32_t stage_count = ecs_get_stage_count(world); - if (ecs_has_id(world, e, EcsTag)) { - return NULL; + if (stage_count != threads) { + /* Stop existing threads */ + if (stage_count > 1) { + if (ecs_stop_threads(world)) { + ecs_os_cond_free(world->worker_cond); + ecs_os_cond_free(world->sync_cond); + ecs_os_mutex_free(world->sync_mutex); + } } - } - if (e & ECS_ROLE_MASK) { - return NULL; + /* Start threads if number of threads > 1 */ + if (threads > 1) { + world->worker_cond = ecs_os_cond_new(); + world->sync_cond = ecs_os_cond_new(); + world->sync_mutex = ecs_os_mutex_new(); + start_workers(world, threads); + } } +} - const EcsComponent *component = ecs_get(world, e, EcsComponent); - if ((!component || !component->size) && pair) { - /* If this is a pair column and the pair is not a component, use - * the component type of the component the pair is applied to. */ - e = ECS_PAIR_SECOND(pair); +#endif - /* Because generations are not stored in the pair, get the currently - * alive id */ - e = ecs_get_alive(world, e); - /* If a pair is used with a not alive id, the pair is not valid */ - ecs_assert(e != 0, ECS_INTERNAL_ERROR, NULL); +#ifdef FLECS_PIPELINE - component = ecs_get(world, e, EcsComponent); - } +static ECS_DTOR(EcsPipelineQuery, ptr, { + ecs_vector_free(ptr->ops); +}) - return component; +static +int compare_entity( + ecs_entity_t e1, + const void *ptr1, + ecs_entity_t e2, + const void *ptr2) +{ + (void)ptr1; + (void)ptr2; + return (e1 > e2) - (e1 < e2); } -/* Ensure the ids used in the columns exist */ static -int32_t ensure_columns( +uint64_t group_by_phase( ecs_world_t *world, - ecs_table_t *table) + ecs_type_t type, + ecs_entity_t pipeline, + void *ctx) { - int32_t i, count = ecs_vector_count(table->type); - ecs_id_t* ids = ecs_vector_first(table->type, ecs_id_t); + (void)ctx; + + const EcsType *pt = ecs_get(world, pipeline, EcsType); + ecs_assert(pt != NULL, ECS_INTERNAL_ERROR, NULL); - for (i = 0; i < count; i++) { - ecs_ensure_id(world, ids[i]); + /* Find tag in system that belongs to pipeline */ + ecs_entity_t *sys_comps = ecs_vector_first(type, ecs_entity_t); + int32_t c, t, count = ecs_vector_count(type); + + ecs_type_t pipeline_type = NULL; + if (pt->normalized) { + pipeline_type = pt->normalized->type; } - return count; -} + if (!pipeline_type) { + return 0; + } -static -ecs_vector_t* ids_to_vector( - const ecs_ids_t *entities) -{ - if (entities->count) { - ecs_vector_t *result = NULL; - ecs_vector_set_count(&result, ecs_entity_t, entities->count); - ecs_entity_t *array = ecs_vector_first(result, ecs_entity_t); - ecs_os_memcpy_n(array, entities->array, ecs_entity_t, entities->count); - return result; - } else { - return NULL; + ecs_entity_t *tags = ecs_vector_first(pipeline_type, ecs_entity_t); + int32_t tag_count = ecs_vector_count(pipeline_type); + + ecs_entity_t result = 0; + + for (c = 0; c < count; c ++) { + ecs_entity_t comp = sys_comps[c]; + for (t = 0; t < tag_count; t ++) { + if (comp == tags[t]) { + result = comp; + break; + } + } + if (result) { + break; + } } -} -static -void table_diff_free( - ecs_table_diff_t *diff) -{ - ecs_os_free(diff->added.array); - ecs_os_free(diff->removed.array); - ecs_os_free(diff->on_set.array); - ecs_os_free(diff->un_set.array); - ecs_os_free(diff); + ecs_assert(result != 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(result < INT_MAX, ECS_INTERNAL_ERROR, NULL); + + return result; } +typedef enum ComponentWriteState { + NotWritten = 0, + WriteToMain, + WriteToStage +} ComponentWriteState; + +typedef struct write_state_t { + ecs_map_t *components; + bool wildcard; +} write_state_t; + static -ecs_graph_edge_t* graph_edge_new( - ecs_world_t *world) +int32_t get_write_state( + ecs_map_t *write_state, + ecs_entity_t component) { - ecs_graph_edge_t *result = (ecs_graph_edge_t*)world->store.first_free; - if (result) { - world->store.first_free = result->hdr.next; - ecs_os_zeromem(result); + int32_t *ptr = ecs_map_get(write_state, int32_t, component); + if (ptr) { + return *ptr; } else { - result = ecs_os_calloc_t(ecs_graph_edge_t); + return 0; } - return result; } static -void graph_edge_free( - ecs_world_t *world, - ecs_graph_edge_t *edge) +void set_write_state( + write_state_t *write_state, + ecs_entity_t component, + int32_t value) { - if (world->is_fini) { - ecs_os_free(edge); + if (component == EcsWildcard) { + ecs_assert(value == WriteToStage, ECS_INTERNAL_ERROR, NULL); + write_state->wildcard = true; } else { - edge->hdr.next = world->store.first_free; - world->store.first_free = &edge->hdr; + ecs_map_set(write_state->components, component, &value); } } static -ecs_graph_edge_t* ensure_hi_edge( - ecs_world_t *world, - ecs_graph_edges_t *edges, - ecs_id_t id) +void reset_write_state( + write_state_t *write_state) { - if (!ecs_map_is_initialized(&edges->hi)) { - ecs_map_init(&edges->hi, ecs_graph_edge_t*, 1); - } - - ecs_graph_edge_t **ep = ecs_map_ensure(&edges->hi, ecs_graph_edge_t*, id); - ecs_graph_edge_t *edge = ep[0]; - if (edge) { - return edge; - } - - if (id < ECS_HI_COMPONENT_ID) { - edge = &edges->lo[id]; - } else { - edge = graph_edge_new(world); - } - - ep[0] = edge; - return edge; + ecs_map_clear(write_state->components); + write_state->wildcard = false; } static -ecs_graph_edge_t* ensure_edge( - ecs_world_t *world, - ecs_graph_edges_t *edges, - ecs_id_t id) +int32_t get_any_write_state( + write_state_t *write_state) { - ecs_graph_edge_t *edge; - - if (id < ECS_HI_COMPONENT_ID) { - if (!edges->lo) { - edges->lo = ecs_os_calloc_n(ecs_graph_edge_t, ECS_HI_COMPONENT_ID); - } - edge = &edges->lo[id]; - } else { - if (!ecs_map_is_initialized(&edges->hi)) { - ecs_map_init(&edges->hi, ecs_graph_edge_t*, 1); + if (write_state->wildcard) { + return WriteToStage; + } + + ecs_map_iter_t it = ecs_map_iter(write_state->components); + int32_t *elem; + while ((elem = ecs_map_next(&it, int32_t, NULL))) { + if (*elem == WriteToStage) { + return WriteToStage; } - edge = ensure_hi_edge(world, edges, id); } - return edge; + return 0; } static -void disconnect_edge( - ecs_world_t *world, - ecs_id_t id, - ecs_graph_edge_t *edge) +bool check_term_component( + ecs_term_t *term, + bool is_active, + ecs_entity_t component, + write_state_t *write_state) { - ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->id == id, ECS_INTERNAL_ERROR, NULL); - (void)id; + int32_t state = get_write_state(write_state->components, component); - /* Remove backref from destination table */ - ecs_graph_edge_hdr_t *next = edge->hdr.next; - ecs_graph_edge_hdr_t *prev = edge->hdr.prev; + ecs_term_id_t *subj = &term->subj; - if (next) { - next->prev = prev; - } - if (prev) { - prev->next = next; - } + if ((subj->set.mask & EcsSelf) && subj->entity == EcsThis && term->oper != EcsNot) { + switch(term->inout) { + case EcsInOutFilter: + /* Ignore terms that aren't read/written */ + break; + case EcsInOutDefault: + case EcsInOut: + case EcsIn: + if (state == WriteToStage || write_state->wildcard) { + return true; + } + // fall through + case EcsOut: + if (is_active && term->inout != EcsIn) { + set_write_state(write_state, component, WriteToMain); + } + }; - /* Remove data associated with edge */ - ecs_table_diff_t *diff = edge->diff; - if (diff && diff != &ecs_table_edge_is_component) { - table_diff_free(diff); - } + } else if (!subj->entity || term->oper == EcsNot) { + bool needs_merge = false; - /* If edge id is low, clear it from fast lookup array */ - if (id < ECS_HI_COMPONENT_ID) { - edge->from = NULL; - } else { - graph_edge_free(world, edge); + switch(term->inout) { + case EcsInOutDefault: + case EcsIn: + case EcsInOut: + if (state == WriteToStage) { + needs_merge = true; + } + if (component == EcsWildcard) { + if (get_any_write_state(write_state) == WriteToStage) { + needs_merge = true; + } + } + break; + default: + break; + }; + + switch(term->inout) { + case EcsInOutDefault: + if ((!(subj->set.mask & EcsSelf) || (subj->entity != EcsThis)) && (subj->set.mask != EcsNothing)) { + /* Default inout behavior is [inout] for This terms, and [in] + * for terms that match other entities */ + break; + } + // fall through + case EcsInOut: + case EcsOut: + if (is_active) { + set_write_state(write_state, component, WriteToStage); + } + break; + default: + break; + }; + + if (needs_merge) { + return true; + } } -} -static -void remove_edge( - ecs_world_t *world, - ecs_graph_edges_t *edges, - ecs_id_t id, - ecs_graph_edge_t *edge) -{ - ecs_assert(edges != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ecs_map_is_initialized(&edges->hi), ECS_INTERNAL_ERROR, NULL); - disconnect_edge(world, id, edge); - ecs_map_remove(&edges->hi, id); + return false; } static -void init_edges( - ecs_graph_edges_t *edges) +bool check_term( + ecs_term_t *term, + bool is_active, + write_state_t *write_state) { - edges->lo = NULL; - ecs_os_zeromem(&edges->hi); -} + if (term->oper != EcsOr) { + return check_term_component( + term, is_active, term->id, write_state); + } -static -void init_node( - ecs_graph_node_t *node) -{ - init_edges(&node->add); - init_edges(&node->remove); + return false; } -typedef struct { - int32_t first; - int32_t count; -} id_first_count_t; - static -void set_trigger_flags_for_id( - ecs_world_t *world, - ecs_table_t *table, - ecs_id_t id) +bool check_terms( + ecs_filter_t *filter, + bool is_active, + write_state_t *ws) { - /* Set flags if triggers are registered for table */ - if (flecs_check_triggers_for_event(world, id, EcsOnAdd)) { - table->flags |= EcsTableHasOnAdd; - } - if (flecs_check_triggers_for_event(world, id, EcsOnRemove)) { - table->flags |= EcsTableHasOnRemove; - } - if (flecs_check_triggers_for_event(world, id, EcsOnSet)) { - table->flags |= EcsTableHasOnSet; + bool needs_merge = false; + ecs_term_t *terms = filter->terms; + int32_t t, term_count = filter->term_count; + + /* Check This terms first. This way if a term indicating writing to a stage + * was added before the term, it won't cause merging. */ + for (t = 0; t < term_count; t ++) { + ecs_term_t *term = &terms[t]; + if (term->subj.entity == EcsThis) { + needs_merge |= check_term(term, is_active, ws); + } } - if (flecs_check_triggers_for_event(world, id, EcsUnSet)) { - table->flags |= EcsTableHasUnSet; + + /* Now check staged terms */ + for (t = 0; t < term_count; t ++) { + ecs_term_t *term = &terms[t]; + if (term->subj.entity != EcsThis) { + needs_merge |= check_term(term, is_active, ws); + } } + + return needs_merge; } static -void register_table_for_id( +bool build_pipeline( ecs_world_t *world, - ecs_table_t *table, - ecs_id_t id, - int32_t column, - int32_t count, - ecs_table_record_t *tr) + ecs_entity_t pipeline, + EcsPipelineQuery *pq) { - id = ecs_strip_generation(id); + (void)pipeline; - ecs_id_record_t *idr = flecs_ensure_id_record(world, id); - ecs_table_cache_insert(&idr->cache, table, &tr->hdr); - tr->column = column; - tr->count = count; - tr->id = id; - set_trigger_flags_for_id(world, table, id); - ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL); -} + ecs_query_iter(world, pq->query); -static -void flecs_table_records_register( - ecs_world_t *world, - ecs_table_t *table) -{ - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - int32_t count = ecs_vector_count(table->type); + if (pq->match_count == pq->query->match_count) { + /* No need to rebuild the pipeline */ + return false; + } - if (!count) { - return; + world->stats.pipeline_build_count_total ++; + pq->rebuild_count ++; + + write_state_t ws = { + .components = ecs_map_new(int32_t, ECS_HI_COMPONENT_ID), + .wildcard = false + }; + + ecs_pipeline_op_t *op = NULL; + ecs_vector_t *ops = NULL; + ecs_query_t *query = pq->build_query; + + if (pq->ops) { + ecs_vector_free(pq->ops); } - /* Count number of unique ids, pairs, relations and objects so we can figure - * out how many table records are needed for this table. */ - int32_t id_count = 0, pair_count = 0, type_flag_count = 0; - int32_t first_id = -1, first_pair = -1; - ecs_map_t relations = ECS_MAP_INIT(0), objects = ECS_MAP_INIT(0); - bool has_childof = false; + bool multi_threaded = false; + bool no_staging = false; + bool first = true; - int32_t i; - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; - ecs_entity_t rel = 0, obj = 0; + /* Iterate systems in pipeline, add ops for running / merging */ + ecs_iter_t it = ecs_query_iter(world, query); + while (ecs_query_next(&it)) { + EcsSystem *sys = ecs_term(&it, EcsSystem, 1); - if (ECS_HAS_ROLE(id, PAIR)) { - id_first_count_t *r; + int i; + for (i = 0; i < it.count; i ++) { + ecs_query_t *q = sys[i].query; + if (!q) { + continue; + } - rel = ECS_PAIR_FIRST(id); - obj = ECS_PAIR_SECOND(id); + bool needs_merge = false; + bool is_active = !ecs_has_id( + world, it.entities[i], EcsInactive); + needs_merge = check_terms(&q->filter, is_active, &ws); + + if (is_active) { + if (first) { + multi_threaded = sys[i].multi_threaded; + no_staging = sys[i].no_staging; + first = false; + } + + if (sys[i].multi_threaded != multi_threaded) { + needs_merge = true; + multi_threaded = sys[i].multi_threaded; + } + if (sys[i].no_staging != no_staging) { + needs_merge = true; + no_staging = sys[i].no_staging; + } + } + + if (needs_merge) { + /* After merge all components will be merged, so reset state */ + reset_write_state(&ws); + op = NULL; + + /* Re-evaluate columns to set write flags if system is active. + * If system is inactive, it can't write anything and so it + * should not insert unnecessary merges. */ + needs_merge = false; + if (is_active) { + needs_merge = check_terms(&q->filter, true, &ws); + } - if (0 == pair_count ++) { - first_pair = i; + /* The component states were just reset, so if we conclude that + * another merge is needed something is wrong. */ + ecs_assert(needs_merge == false, ECS_INTERNAL_ERROR, NULL); } - if (rel == EcsChildOf) { - has_childof = true; + if (!op) { + op = ecs_vector_add(&ops, ecs_pipeline_op_t); + op->count = 0; + op->multi_threaded = false; + op->no_staging = false; } - if (!ecs_map_is_initialized(&relations)) { - ecs_map_init(&relations, id_first_count_t, count); - ecs_map_init(&objects, id_first_count_t, count); + /* Don't increase count for inactive systems, as they are ignored by + * the query used to run the pipeline. */ + if (is_active) { + if (!op->count) { + op->multi_threaded = multi_threaded; + op->no_staging = no_staging; + } + op->count ++; } + } + } - r = ecs_map_ensure(&relations, id_first_count_t, rel); - if ((++r->count) == 1) { - r->first = i; - } + ecs_map_free(ws.components); - r = ecs_map_ensure(&objects, id_first_count_t, obj); - if ((++r->count) == 1) { - r->first = i; + /* Find the system ran last this frame (helps workers reset iter) */ + ecs_entity_t last_system = 0; + op = ecs_vector_first(ops, ecs_pipeline_op_t); + int32_t i, ran_since_merge = 0, op_index = 0; + + ecs_assert(op != NULL, ECS_INTERNAL_ERROR, NULL); + + /* Add schedule to debug tracing */ + ecs_dbg("#[green]pipeline#[reset] rebuild:"); + ecs_log_push_1(); + + ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", + op->multi_threaded, !op->no_staging); + ecs_log_push_1(); + + it = ecs_query_iter(world, pq->query); + while (ecs_query_next(&it)) { + EcsSystem *sys = ecs_term(&it, EcsSystem, 1); + for (i = 0; i < it.count; i ++) { + if (ecs_should_log_1()) { + char *path = ecs_get_fullpath(world, it.entities[i]); + ecs_dbg("#[green]system#[reset] %s", path); + ecs_os_free(path); } - } else { - rel = id & ECS_COMPONENT_MASK; - if (rel != id) { - type_flag_count ++; + + ran_since_merge ++; + if (ran_since_merge == op[op_index].count) { + ecs_dbg("#[magenta]merge#[reset]"); + ecs_log_pop_1(); + ran_since_merge = 0; + op_index ++; + if (op_index < ecs_vector_count(ops)) { + ecs_dbg("#[green]schedule#[reset]: threading: %d, staging: %d:", + op[op_index].multi_threaded, !op[op_index].no_staging); + } + ecs_log_push_1(); } - if (0 == id_count ++) { - first_id = i; + if (sys[i].last_frame == (world->stats.frame_count_total + 1)) { + last_system = it.entities[i]; + + /* Can't break from loop yet. It's possible that previously + * inactive systems that ran before the last ran system are now + * active. */ } } } - int32_t record_count = count + type_flag_count + (id_count != 0) + - (pair_count != 0) + ecs_map_count(&relations) + ecs_map_count(&objects) - + 1 /* for any */; - int32_t r = 0; + ecs_log_pop_1(); + ecs_log_pop_1(); - if (!has_childof) { - record_count ++; - } + /* Force sort of query as this could increase the match_count */ + pq->match_count = pq->query->match_count; + pq->ops = ops; + pq->last_system = last_system; - table->records = ecs_os_calloc_n(ecs_table_record_t, record_count); - table->record_count = record_count; + return true; +} - /* First initialize records for regular (non-wildcard) ids */ - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; - register_table_for_id(world, table, id, i, 1, &table->records[r]); - r ++; - - ecs_entity_t role = id & ECS_ROLE_MASK; - if (role && role != ECS_PAIR) { - id &= ECS_COMPONENT_MASK; - id = ecs_pair(id, EcsWildcard); - register_table_for_id(world, table, id, i, 1, &table->records[r]); - r ++; - } - } +int32_t ecs_pipeline_reset_iter( + ecs_world_t *world, + const EcsPipelineQuery *pq, + ecs_iter_t *iter_out, + ecs_pipeline_op_t **op_out, + ecs_pipeline_op_t **last_op_out) +{ + ecs_pipeline_op_t *op = ecs_vector_first(pq->ops, ecs_pipeline_op_t); + int32_t i, ran_since_merge = 0, op_index = 0; - /* Initialize records for relation wildcards */ - ecs_map_iter_t mit = ecs_map_iter(&relations); - id_first_count_t *elem; - uint64_t key; - while ((elem = ecs_map_next(&mit, id_first_count_t, &key))) { - ecs_id_t id = ecs_pair(key, EcsWildcard); - register_table_for_id(world, table, id, elem->first, elem->count, - &table->records[r]); - r ++; + if (!pq->last_system) { + /* It's possible that all systems that were ran were removed entirely + * from the pipeline (they could have been deleted or disabled). In that + * case (which should be very rare) the pipeline can't make assumptions + * about where to continue, so end frame. */ + return -1; } - /* Initialize records for object wildcards */ - mit = ecs_map_iter(&objects); - while ((elem = ecs_map_next(&mit, id_first_count_t, &key))) { - ecs_id_t id = ecs_pair(EcsWildcard, key); - register_table_for_id(world, table, id, elem->first, elem->count, - &table->records[r]); - r ++; - } + /* Move iterator to last ran system */ + *iter_out = ecs_query_iter(world, pq->query); + while (ecs_query_next(iter_out)) { + for (i = 0; i < iter_out->count; i ++) { + ran_since_merge ++; + if (ran_since_merge == op[op_index].count) { + ran_since_merge = 0; + op_index ++; + } - /* Initialize records for all wildcards ids */ - if (id_count) { - register_table_for_id(world, table, EcsWildcard, - first_id, id_count, &table->records[r]); - r ++; - } - if (pair_count) { - register_table_for_id(world, table, ecs_pair(EcsWildcard, EcsWildcard), - first_pair, pair_count, &table->records[r]); - r ++; - } - if (count) { - register_table_for_id(world, table, EcsAny, 0, 1, &table->records[r]); - r ++; + if (iter_out->entities[i] == pq->last_system) { + *op_out = &op[op_index]; + *last_op_out = ecs_vector_last(pq->ops, ecs_pipeline_op_t); + return i; + } + } } - /* Insert into (ChildOf, 0) (root) if table doesn't have childof */ - if (!has_childof && count) { - register_table_for_id(world, table, ecs_pair(EcsChildOf, 0), - 0, 1, &table->records[r]); - } + ecs_abort(ECS_INTERNAL_ERROR, NULL); - ecs_map_fini(&relations); - ecs_map_fini(&objects); + return -1; } -void flecs_table_records_unregister( +bool ecs_pipeline_update( ecs_world_t *world, - ecs_table_t *table) + ecs_entity_t pipeline, + bool start_of_frame) { - int32_t i, count = table->record_count; - for (i = 0; i < count; i ++) { - ecs_table_record_t *tr = &table->records[i]; - ecs_table_cache_t *cache = tr->hdr.cache; - ecs_id_t id = tr->id; + ecs_poly_assert(world, ecs_world_t); + ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); + ecs_assert(pipeline != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(tr->hdr.cache == cache, ECS_INTERNAL_ERROR, NULL); - ecs_assert(tr->hdr.table == table, ECS_INTERNAL_ERROR, NULL); - ecs_assert(flecs_get_id_record(world, id) == (ecs_id_record_t*)cache, - ECS_INTERNAL_ERROR, NULL); + /* If any entity mutations happened that could have affected query matching + * notify appropriate queries so caches are up to date. This includes the + * pipeline query. */ + if (start_of_frame) { + ecs_force_aperiodic(world); + } - ecs_table_cache_remove(cache, table, &tr->hdr); + bool added = false; + EcsPipelineQuery *pq = ecs_get_mut(world, pipeline, EcsPipelineQuery, &added); + ecs_assert(added == false, ECS_INTERNAL_ERROR, NULL); + ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL); - if (ecs_table_cache_is_empty(cache)) { - ecs_id_record_t *idr = (ecs_id_record_t*)cache; - flecs_remove_id_record(world, id, idr); - } - } - - ecs_os_free(table->records); + return build_pipeline(world, pipeline, pq); } -bool flecs_table_records_update_empty( - ecs_table_t *table) +void ecs_run_pipeline( + ecs_world_t *world, + ecs_entity_t pipeline, + FLECS_FLOAT delta_time) { - bool result = false; - bool is_empty = ecs_table_count(table) == 0; + ecs_assert(world != NULL, ECS_INVALID_OPERATION, NULL); - int32_t i, count = table->record_count; - for (i = 0; i < count; i ++) { - ecs_table_record_t *tr = &table->records[i]; - ecs_table_cache_t *cache = tr->hdr.cache; - result |= ecs_table_cache_set_empty(cache, table, is_empty); + if (!pipeline) { + pipeline = world->pipeline; } - return result; -} + ecs_assert(pipeline != 0, ECS_INVALID_PARAMETER, NULL); -static -void init_flags( - ecs_world_t *world, - ecs_table_t *table) -{ - ecs_id_t *ids = ecs_vector_first(table->type, ecs_id_t); - int32_t count = ecs_vector_count(table->type); + /* If the world is passed to ecs_run_pipeline, the function will take care + * of staging, so the world should not be in staged mode when called. */ + if (ecs_poly_is(world, ecs_world_t)) { + ecs_assert(!world->is_readonly, ECS_INVALID_OPERATION, NULL); - /* Iterate components to initialize table flags */ - int32_t i; - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; + /* Forward to worker_progress. This function handles staging, threading + * and synchronization across workers. */ + ecs_workers_progress(world, pipeline, delta_time); + return; - /* As we're iterating over the table components, also set the table - * flags. These allow us to quickly determine if the table contains - * data that needs to be handled in a special way, like prefabs or - * containers */ - if (id <= EcsLastInternalComponentId) { - table->flags |= EcsTableHasBuiltins; - } + /* If a stage is passed, the function could be ran from a worker thread. In + * that case the main thread should manage staging, and staging should be + * enabled. */ + } else { + ecs_poly_assert(world, ecs_stage_t); + } - if (id == EcsModule) { - table->flags |= EcsTableHasBuiltins; - table->flags |= EcsTableHasModule; - } + ecs_stage_t *stage = flecs_stage_from_world(&world); + + const EcsPipelineQuery *pq = ecs_get(world, pipeline, EcsPipelineQuery); + ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(pq->query != NULL, ECS_INTERNAL_ERROR, NULL); - if (id == EcsPrefab) { - table->flags |= EcsTableIsPrefab; - } + ecs_vector_t *ops = pq->ops; + ecs_pipeline_op_t *op = ecs_vector_first(ops, ecs_pipeline_op_t); + ecs_pipeline_op_t *op_last = ecs_vector_last(ops, ecs_pipeline_op_t); + int32_t ran_since_merge = 0; - /* If table contains disabled entities, mark it as disabled */ - if (id == EcsDisabled) { - table->flags |= EcsTableIsDisabled; - } + int32_t stage_index = ecs_get_stage_id(stage->thread_ctx); + int32_t stage_count = ecs_get_stage_count(world); - /* Does table have exclusive or columns */ - if (ECS_HAS_ROLE(id, XOR)) { - table->flags |= EcsTableHasXor; - } + ecs_worker_begin(stage->thread_ctx); - /* Does the table have pairs */ - if (ECS_HAS_ROLE(id, PAIR)) { - table->flags |= EcsTableHasPairs; - } + ecs_iter_t it = ecs_query_iter(world, pq->query); + while (ecs_query_next(&it)) { + EcsSystem *sys = ecs_term(&it, EcsSystem, 1); - /* Does table have IsA relations */ - if (ECS_HAS_RELATION(id, EcsIsA)) { - table->flags |= EcsTableHasIsA; - } + int32_t i; + for(i = 0; i < it.count; i ++) { + ecs_entity_t e = it.entities[i]; - /* Does table have ChildOf relations */ - if (ECS_HAS_RELATION(id, EcsChildOf)) { - table->flags |= EcsTableHasChildOf; - } + if (!stage_index) { + ecs_dbg_3("pipeline: run system %s", ecs_get_name(world, e)); + } - /* Does table have switch columns */ - if (ECS_HAS_ROLE(id, SWITCH)) { - table->flags |= EcsTableHasSwitch; - } + if (!stage_index || op->multi_threaded) { + ecs_stage_t *s = NULL; + if (!op->no_staging) { + s = stage; + } - /* Does table support component disabling */ - if (ECS_HAS_ROLE(id, DISABLED)) { - table->flags |= EcsTableHasDisabled; - } + ecs_run_intern(world, s, e, &sys[i], stage_index, + stage_count, delta_time, 0, 0, NULL); + } - if (ECS_HAS_RELATION(id, EcsChildOf)) { - ecs_poly_assert(world, ecs_world_t); - ecs_entity_t obj = ecs_pair_second(world, id); - ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); + sys[i].last_frame = world->stats.frame_count_total + 1; - if (obj == EcsFlecs || obj == EcsFlecsCore || - ecs_has_id(world, obj, EcsModule)) - { - /* If table contains entities that are inside one of the builtin - * modules, it contains builtin entities */ - table->flags |= EcsTableHasBuiltins; - table->flags |= EcsTableHasModule; + ran_since_merge ++; + world->stats.systems_ran_frame ++; + + if (op != op_last && ran_since_merge == op->count) { + ran_since_merge = 0; + + if (!stage_index) { + ecs_dbg_3("merge"); + } + + /* If the set of matched systems changed as a result of the + * merge, we have to reset the iterator and move it to our + * current position (system). If there are a lot of systems + * in the pipeline this can be an expensive operation, but + * should happen infrequently. */ + i = ecs_worker_sync(world, pq, &it, i, &op, &op_last); + sys = ecs_term(&it, EcsSystem, 1); } - } + } } + + ecs_worker_end(stage->thread_ctx); } static -void init_table( +void add_pipeline_tags_to_sig( ecs_world_t *world, - ecs_table_t *table) + ecs_term_t *terms, + ecs_type_t type) { - table->type_info = NULL; - table->flags = 0; - table->dirty_state = NULL; - table->alloc_count = 0; - table->lock = 0; - table->refcount = 1; - - /* Ensure the component ids for the table exist */ - ensure_columns(world, table); + (void)world; + + int32_t i, count = ecs_vector_count(type); + ecs_entity_t *entities = ecs_vector_first(type, ecs_entity_t); - init_node(&table->node); - init_flags(world, table); - flecs_table_records_register(world, table); - flecs_table_init_data(world, table); + for (i = 0; i < count; i ++) { + terms[i] = (ecs_term_t){ + .inout = EcsIn, + .oper = EcsOr, + .pred.entity = entities[i], + .subj = { + .entity = EcsThis, + .set.mask = EcsSelf | EcsSuperSet + } + }; + } } static -ecs_table_t *create_table( +ecs_query_t* build_pipeline_query( ecs_world_t *world, - ecs_vector_t *type, - flecs_hashmap_result_t table_elem) + ecs_entity_t pipeline, + const char *name, + bool not_inactive) { - ecs_table_t *result = flecs_sparse_add(&world->store.tables, ecs_table_t); - ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_vector_reclaim(&type, ecs_id_t); - - result->id = flecs_sparse_last_id(&world->store.tables); - result->type = type; + const EcsType *type_ptr = ecs_get(world, pipeline, EcsType); + ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_type_t type = NULL; + if (type_ptr->normalized) { + type = type_ptr->normalized->type; + } - init_table(world, result); + int32_t type_count = ecs_vector_count(type); + int32_t term_count = 1; - if (ecs_should_log_2()) { - char *expr = ecs_type_str(world, result->type); - ecs_dbg_2( - "#[green]table#[normal] [%s] #[green]created#[normal] with id %d", - expr, result->id); - ecs_os_free(expr); + if (not_inactive) { + term_count ++; } - ecs_log_push_2(); - - /* Store table in table hashmap */ - *(ecs_table_t**)table_elem.value = result; + ecs_term_t *terms = ecs_os_malloc( + (type_count + term_count) * ECS_SIZEOF(ecs_term_t)); - /* Set keyvalue to one that has the same lifecycle as the table */ - ecs_ids_t key = { - .array = ecs_vector_first(result->type, ecs_id_t), - .count = ecs_vector_count(result->type) + terms[0] = (ecs_term_t){ + .inout = EcsIn, + .oper = EcsAnd, + .pred.entity = ecs_id(EcsSystem), + .subj = { + .entity = EcsThis, + .set.mask = EcsSelf | EcsSuperSet + } }; - *(ecs_ids_t*)table_elem.key = key; - flecs_notify_queries(world, &(ecs_query_event_t) { - .kind = EcsQueryTableMatch, - .table = result + if (not_inactive) { + terms[1] = (ecs_term_t){ + .inout = EcsIn, + .oper = EcsNot, + .pred.entity = EcsInactive, + .subj = { + .entity = EcsThis, + .set.mask = EcsSelf | EcsSuperSet + } + }; + } + + add_pipeline_tags_to_sig(world, &terms[term_count], type); + + ecs_query_t *result = ecs_query_init(world, &(ecs_query_desc_t){ + .filter = { + .name = name, + .terms_buffer = terms, + .terms_buffer_count = term_count + type_count + }, + .order_by = compare_entity, + .group_by = group_by_phase, + .group_by_id = pipeline }); - ecs_log_pop_2(); + ecs_assert(result != NULL, ECS_INTERNAL_ERROR, NULL); + + ecs_os_free(terms); return result; } -static -ecs_table_t* find_or_create( - ecs_world_t *world, - const ecs_ids_t *ids, - ecs_vector_t *type) -{ - ecs_poly_assert(world, ecs_world_t); +static +void OnUpdatePipeline( + ecs_iter_t *it) +{ + ecs_world_t *world = it->world; + ecs_entity_t *entities = it->entities; + + int32_t i; + for (i = it->count - 1; i >= 0; i --) { + ecs_entity_t pipeline = entities[i]; + + ecs_trace("#[green]pipeline#[reset] %s created", + ecs_get_name(world, pipeline)); + ecs_log_push(); + + /* Build signature for pipeline query that matches EcsSystems, has the + * pipeline phases as OR columns, and ignores systems with EcsInactive. + * Note that EcsDisabled is automatically ignored + * by the regular query matching */ + ecs_query_t *query = build_pipeline_query( + world, pipeline, "BuiltinPipelineQuery", true); + ecs_assert(query != NULL, ECS_INTERNAL_ERROR, NULL); + + /* Build signature for pipeline build query. The build query includes + * systems that are inactive, as an inactive system may become active as + * a result of another system, and as a result the correct merge + * operations need to be put in place. */ + ecs_query_t *build_query = build_pipeline_query( + world, pipeline, "BuiltinPipelineBuildQuery", false); + ecs_assert(build_query != NULL, ECS_INTERNAL_ERROR, NULL); - /* Make sure array is ordered and does not contain duplicates */ - int32_t id_count = ids->count; + bool added = false; + EcsPipelineQuery *pq = ecs_get_mut( + world, pipeline, EcsPipelineQuery, &added); + ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - if (!id_count) { - return &world->store.root; - } + if (added) { + /* Should not modify pipeline after it has been used */ + ecs_assert(pq->ops == NULL, ECS_INVALID_OPERATION, NULL); - ecs_table_t *table; - flecs_hashmap_result_t elem = flecs_hashmap_ensure( - &world->store.table_map, ids, ecs_table_t*); - if ((table = *(ecs_table_t**)elem.value)) { - if (type) { - ecs_vector_free(type); + if (pq->query) { + ecs_query_fini(pq->query); + } + if (pq->build_query) { + ecs_query_fini(pq->build_query); + } } - return table; - } - - if (!type) { - type = ids_to_vector(ids); - } - /* If we get here, table needs to be created which is only allowed when the - * application is not currently in progress */ - ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); + pq->query = query; + pq->build_query = build_query; + pq->match_count = -1; + pq->ops = NULL; + pq->last_system = 0; - /* If we get here, the table has not been found, so create it. */ - return create_table(world, type, elem); + ecs_log_pop(); + } } -static -void add_id_to_ids( - ecs_vector_t **idv, - ecs_entity_t add, - ecs_entity_t r_exclusive) +/* -- Public API -- */ + +bool ecs_progress( + ecs_world_t *world, + FLECS_FLOAT user_delta_time) { - int32_t i, count = ecs_vector_count(idv[0]); - ecs_id_t *array = ecs_vector_first(idv[0], ecs_id_t); + float delta_time = ecs_frame_begin(world, user_delta_time); - for (i = 0; i < count; i ++) { - ecs_id_t e = array[i]; + ecs_dbg_3("#[normal]begin progress(dt = %.2f)", (double)delta_time); - if (e == add) { - return; - } + ecs_run_pipeline(world, 0, delta_time); - if (r_exclusive && ECS_HAS_ROLE(e, PAIR)) { - if (ECS_PAIR_FIRST(e) == r_exclusive) { - array[i] = add; /* Replace */ - return; - } - } + ecs_dbg_3("#[normal]end progress"); - if (e >= add) { - if (e != add) { - ecs_id_t *ptr = ecs_vector_insert_at(idv, ecs_id_t, i); - ptr[0] = add; - return; - } - } - } + ecs_frame_end(world); - ecs_id_t *ptr = ecs_vector_add(idv, ecs_id_t); - ptr[0] = add; + return !world->should_quit; } -static -void remove_id_from_ids( - ecs_type_t type, - ecs_id_t remove, - ecs_ids_t *out) +void ecs_set_time_scale( + ecs_world_t *world, + FLECS_FLOAT scale) { - int32_t count = ecs_vector_count(type); - ecs_id_t *array = ecs_vector_first(type, ecs_id_t); - int32_t i, el = 0; - - if (ecs_id_is_wildcard(remove)) { - for (i = 0; i < count; i ++) { - ecs_id_t id = array[i]; - if (!ecs_id_match(id, remove)) { - out->array[el ++] = id; - ecs_assert(el <= count, ECS_INTERNAL_ERROR, NULL); - } - } - } else { - for (i = 0; i < count; i ++) { - ecs_id_t id = array[i]; - if (id != remove) { - out->array[el ++] = id; - ecs_assert(el <= count, ECS_INTERNAL_ERROR, NULL); - } - } - } - - out->count = el; + world->stats.time_scale = scale; } -int32_t flecs_table_switch_from_case( - const ecs_world_t *world, - const ecs_table_t *table, - ecs_entity_t add) +void ecs_reset_clock( + ecs_world_t *world) { - ecs_type_t type = table->type; - ecs_entity_t *array = ecs_vector_first(type, ecs_entity_t); + world->stats.world_time_total = 0; + world->stats.world_time_total_raw = 0; +} - int32_t i, count = table->sw_column_count; - ecs_assert(count != 0, ECS_INTERNAL_ERROR, NULL); +void ecs_deactivate_systems( + ecs_world_t *world) +{ + ecs_assert(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); - add = add & ECS_COMPONENT_MASK; + ecs_entity_t pipeline = world->pipeline; + const EcsPipelineQuery *pq = ecs_get( world, pipeline, EcsPipelineQuery); + ecs_assert(pq != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_sw_column_t *sw_columns = NULL; + /* Iterate over all systems, add EcsInvalid tag if queries aren't matched + * with any tables */ + ecs_iter_t it = ecs_query_iter(world, pq->build_query); - if ((sw_columns = table->storage.sw_columns)) { - /* Fast path, we can get the switch type from the column data */ - for (i = 0; i < count; i ++) { - ecs_table_t *sw_type = sw_columns[i].type; - if (ecs_search(world, sw_type, add, 0) != -1) { - return i; - } - } - } else { - /* Slow path, table is empty, so we'll have to get the switch types by - * actually inspecting the switch type entities. */ - for (i = 0; i < count; i ++) { - ecs_entity_t e = array[i + table->sw_column_offset]; - ecs_assert(ECS_HAS_ROLE(e, SWITCH), ECS_INTERNAL_ERROR, NULL); - e = e & ECS_COMPONENT_MASK; + /* Make sure that we defer adding the inactive tags until after iterating + * the query */ + flecs_defer_none(world, &world->stage); - const EcsType *type_ptr = ecs_get(world, e, EcsType); - ecs_assert(type_ptr != NULL, ECS_INTERNAL_ERROR, NULL); + while( ecs_query_next(&it)) { + EcsSystem *sys = ecs_term(&it, EcsSystem, 1); - if (ecs_search(world, type_ptr->normalized, add, 0) != -1) { - return i; + int32_t i; + for (i = 0; i < it.count; i ++) { + ecs_query_t *query = sys[i].query; + if (query) { + if (!ecs_query_table_count(query)) { + ecs_add_id(world, it.entities[i], EcsInactive); + } } } } - /* If a table was not found, this is an invalid switch case */ - ecs_abort(ECS_TYPE_INVALID_CASE, NULL); + flecs_defer_flush(world, &world->stage); +} - return -1; +void ecs_set_pipeline( + ecs_world_t *world, + ecs_entity_t pipeline) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_check( ecs_get(world, pipeline, EcsPipelineQuery) != NULL, + ECS_INVALID_PARAMETER, "not a pipeline"); + + world->pipeline = pipeline; +error: + return; } -static -void ids_append( - ecs_ids_t *ids, - ecs_id_t id) +ecs_entity_t ecs_get_pipeline( + const ecs_world_t *world) { - ids->array = ecs_os_realloc_n(ids->array, ecs_id_t, ids->count + 1); - ids->array[ids->count ++] = id; + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + world = ecs_get_world(world); + return world->pipeline; +error: + return 0; } +/* -- Module implementation -- */ + static -void diff_insert_isa( +void FlecsPipelineFini( ecs_world_t *world, - ecs_table_t *table, - ecs_table_diff_t *base_diff, - ecs_ids_t *append_to, - ecs_ids_t *append_from, - ecs_id_t add) + void *ctx) { - ecs_entity_t base = ecs_pair_second(world, add); - ecs_table_t *base_table = ecs_get_table(world, base); - if (!base_table) { - return; + (void)ctx; + if (ecs_get_stage_count(world)) { + ecs_set_threads(world, 0); } +} - ecs_type_t base_type = base_table->type, type = table->type; - ecs_table_t *table_wo_base = base_table; +void FlecsPipelineImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsPipeline); - /* If the table does not have a component from the base, it should - * trigger an OnSet */ - ecs_id_t *ids = ecs_vector_first(base_type, ecs_id_t); - int32_t j, i, count = ecs_vector_count(base_type); - for (i = 0; i < count; i ++) { - ecs_id_t id = ids[i]; + ECS_IMPORT(world, FlecsSystem); - if (ECS_HAS_RELATION(id, EcsIsA)) { - /* The base has an IsA relation. Find table without the base, which - * gives us the list of ids the current base inherits and doesn't - * override. This saves us from having to recursively check for each - * base in the hierarchy whether the component is overridden. */ - table_wo_base = flecs_table_traverse_remove( - world, table_wo_base, &id, base_diff); + ecs_set_name_prefix(world, "Ecs"); - /* Because we removed, the ids are stored in un_set vs. on_set */ - for (j = 0; j < append_from->count; j ++) { - ecs_id_t base_id = append_from->array[j]; - /* We still have to make sure the id isn't overridden by the - * current table */ - if (!type || ecs_search(world, table, base_id, NULL) == -1) { - ids_append(append_to, base_id); - } - } + flecs_bootstrap_tag(world, EcsPipeline); + flecs_bootstrap_component(world, EcsPipelineQuery); - continue; - } + /* Phases of the builtin pipeline are regular entities. Names are set so + * they can be resolved by type expressions. */ + flecs_bootstrap_tag(world, EcsPreFrame); + flecs_bootstrap_tag(world, EcsOnLoad); + flecs_bootstrap_tag(world, EcsPostLoad); + flecs_bootstrap_tag(world, EcsPreUpdate); + flecs_bootstrap_tag(world, EcsOnUpdate); + flecs_bootstrap_tag(world, EcsOnValidate); + flecs_bootstrap_tag(world, EcsPostUpdate); + flecs_bootstrap_tag(world, EcsPreStore); + flecs_bootstrap_tag(world, EcsOnStore); + flecs_bootstrap_tag(world, EcsPostFrame); - /* Identifiers are not inherited */ - if (ECS_HAS_RELATION(id, ecs_id(EcsIdentifier))) { - continue; - } + /* Set ctor and dtor for PipelineQuery */ + ecs_set(world, ecs_id(EcsPipelineQuery), EcsComponentLifecycle, { + .ctor = ecs_default_ctor, + .dtor = ecs_dtor(EcsPipelineQuery) + }); - if (!ecs_get_typeid(world, id)) { - continue; - } + /* When the Pipeline tag is added a pipeline will be created */ + ecs_observer_init(world, &(ecs_observer_desc_t) { + .entity.name = "OnUpdatePipeline", + .filter.terms = { + { .id = EcsPipeline }, + { .id = ecs_id(EcsType) } + }, + .events = { EcsOnSet }, + .callback = OnUpdatePipeline + }); - if (!type || ecs_search(world, table, id, NULL) == -1) { - ids_append(append_to, id); - } + /* Create the builtin pipeline */ + world->pipeline = ecs_type_init(world, &(ecs_type_desc_t){ + .entity = { + .name = "BuiltinPipeline", + .add = {EcsPipeline} + }, + .ids = { + EcsPreFrame, EcsOnLoad, EcsPostLoad, EcsPreUpdate, EcsOnUpdate, + EcsOnValidate, EcsPostUpdate, EcsPreStore, EcsOnStore, EcsPostFrame + } + }); + + /* Cleanup thread administration when world is destroyed */ + ecs_atfini(world, FlecsPipelineFini, NULL); +} + +#endif + + +#ifdef FLECS_OS_API_IMPL +#ifdef ECS_TARGET_MSVC +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#include +#include + +static +ecs_os_thread_t win_thread_new( + ecs_os_thread_callback_t callback, + void *arg) +{ + HANDLE *thread = ecs_os_malloc_t(HANDLE); + *thread = CreateThread( + NULL, 0, (LPTHREAD_START_ROUTINE)callback, arg, 0, NULL); + return (ecs_os_thread_t)(uintptr_t)thread; +} + +static +void* win_thread_join( + ecs_os_thread_t thr) +{ + HANDLE *thread = (HANDLE*)(uintptr_t)thr; + DWORD r = WaitForSingleObject(*thread, INFINITE); + if (r == WAIT_FAILED) { + ecs_err("win_thread_join: WaitForSingleObject failed"); } + ecs_os_free(thread); + return NULL; } static -void diff_insert_added_isa( - ecs_world_t *world, - ecs_table_t *table, - ecs_table_diff_t *diff, - ecs_id_t id) +int32_t win_ainc( + int32_t *count) { - ecs_table_diff_t base_diff; - diff_insert_isa(world, table, &base_diff, &diff->on_set, - &base_diff.un_set, id); + return InterlockedIncrement(count); } static -void diff_insert_removed_isa( - ecs_world_t *world, - ecs_table_t *table, - ecs_table_diff_t *diff, - ecs_id_t id) +int32_t win_adec( + int32_t *count) { - ecs_table_diff_t base_diff; - diff_insert_isa(world, table, &base_diff, &diff->un_set, - &base_diff.un_set, id); + return InterlockedDecrement(count); } static -void diff_insert_added( - ecs_world_t *world, - ecs_table_t *table, - ecs_table_diff_t *diff, - ecs_id_t id) +ecs_os_mutex_t win_mutex_new(void) { + CRITICAL_SECTION *mutex = ecs_os_malloc_t(CRITICAL_SECTION); + InitializeCriticalSection(mutex); + return (ecs_os_mutex_t)(uintptr_t)mutex; +} + +static +void win_mutex_free( + ecs_os_mutex_t m) { - diff->added.array[diff->added.count ++] = id; + CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; + DeleteCriticalSection(mutex); + ecs_os_free(mutex); +} - if (ECS_HAS_RELATION(id, EcsIsA)) { - diff_insert_added_isa(world, table, diff, id); - } +static +void win_mutex_lock( + ecs_os_mutex_t m) +{ + CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; + EnterCriticalSection(mutex); } static -void diff_insert_removed( - ecs_world_t *world, - ecs_table_t *table, - ecs_table_diff_t *diff, - ecs_id_t id) +void win_mutex_unlock( + ecs_os_mutex_t m) { - diff->removed.array[diff->removed.count ++] = id; + CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; + LeaveCriticalSection(mutex); +} - if (ECS_HAS_RELATION(id, EcsIsA)) { - /* Removing an IsA relation also "removes" all components from the - * instance. Any id from base that's not overridden should be UnSet. */ - diff_insert_removed_isa(world, table, diff, id); - return; - } +static +ecs_os_cond_t win_cond_new(void) { + CONDITION_VARIABLE *cond = ecs_os_malloc_t(CONDITION_VARIABLE); + InitializeConditionVariable(cond); + return (ecs_os_cond_t)(uintptr_t)cond; +} - if (table->flags & EcsTableHasIsA) { - if (!ecs_get_typeid(world, id)) { - /* Do nothing if id is not a component */ - return; - } +static +void win_cond_free( + ecs_os_cond_t c) +{ + (void)c; +} - /* If next table has a base and component is removed, check if - * the removed component was an override. Removed overrides reexpose the - * base component, thus "changing" the value which requires an OnSet. */ - if (ecs_search_relation(world, table, 0, id, EcsIsA, - 1, -1, NULL, NULL, NULL) != -1) - { - ids_append(&diff->on_set, id); - return; - } - } +static +void win_cond_signal( + ecs_os_cond_t c) +{ + CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; + WakeConditionVariable(cond); +} - if (ecs_get_typeid(world, id) != 0) { - ids_append(&diff->un_set, id); - } +static +void win_cond_broadcast( + ecs_os_cond_t c) +{ + CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; + WakeAllConditionVariable(cond); } -static -void compute_table_diff( - ecs_world_t *world, - ecs_table_t *node, - ecs_table_t *next, - ecs_graph_edge_t *edge, - ecs_id_t id) +static +void win_cond_wait( + ecs_os_cond_t c, + ecs_os_mutex_t m) { - if (node == next) { + CRITICAL_SECTION *mutex = (CRITICAL_SECTION*)(intptr_t)m; + CONDITION_VARIABLE *cond = (CONDITION_VARIABLE*)(intptr_t)c; + SleepConditionVariableCS(cond, mutex, INFINITE); +} + +static bool win_time_initialized; +static double win_time_freq; +static LARGE_INTEGER win_time_start; + +static +void win_time_setup(void) { + if ( win_time_initialized) { return; } + + win_time_initialized = true; - ecs_type_t node_type = node->type; - ecs_type_t next_type = next->type; - - ecs_id_t *ids_node = ecs_vector_first(node_type, ecs_id_t); - ecs_id_t *ids_next = ecs_vector_first(next_type, ecs_id_t); - int32_t i_node = 0, node_count = ecs_vector_count(node_type); - int32_t i_next = 0, next_count = ecs_vector_count(next_type); - int32_t added_count = 0; - int32_t removed_count = 0; - bool trivial_edge = !ECS_HAS_RELATION(id, EcsIsA) && - !(node->flags & EcsTableHasIsA) && !(next->flags & EcsTableHasIsA); + LARGE_INTEGER freq; + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&win_time_start); + win_time_freq = (double)freq.QuadPart / 1000000000.0; +} - /* First do a scan to see how big the diff is, so we don't have to realloc - * or alloc more memory than required. */ - for (; i_node < node_count && i_next < next_count; ) { - ecs_id_t id_node = ids_node[i_node]; - ecs_id_t id_next = ids_next[i_next]; +static +void win_sleep( + int32_t sec, + int32_t nanosec) +{ + HANDLE timer; + LARGE_INTEGER ft; - bool added = id_next < id_node; - bool removed = id_node < id_next; + ft.QuadPart = -((int64_t)sec * 10000000 + (int64_t)nanosec / 100); - trivial_edge &= !added || id_next == id; - trivial_edge &= !removed || id_node == id; + timer = CreateWaitableTimer(NULL, TRUE, NULL); + SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0); + WaitForSingleObject(timer, INFINITE); + CloseHandle(timer); +} - added_count += added; - removed_count += removed; +static double win_time_freq; +static ULONG win_current_resolution; - i_node += id_node <= id_next; - i_next += id_next <= id_node; +static +void win_enable_high_timer_resolution(bool enable) +{ + HMODULE hntdll = GetModuleHandle((LPCTSTR)"ntdll.dll"); + if (!hntdll) { + return; } - added_count += next_count - i_next; - removed_count += node_count - i_node; + LONG (__stdcall *pNtSetTimerResolution)( + ULONG desired, BOOLEAN set, ULONG * current); - trivial_edge &= (added_count + removed_count) <= 1 && - !ecs_id_is_wildcard(id); + pNtSetTimerResolution = (LONG(__stdcall*)(ULONG, BOOLEAN, ULONG*)) + GetProcAddress(hntdll, "NtSetTimerResolution"); - if (trivial_edge) { - /* If edge is trivial there's no need to create a diff element for it. - * Store whether the id is a tag or not, so that we can still tell - * whether an UnSet handler should be called or not. */ - if (node->storage_table != next->storage_table) { - edge->diff = &ecs_table_edge_is_component; - } + if(!pNtSetTimerResolution) { return; } - ecs_table_diff_t *diff = ecs_os_calloc_t(ecs_table_diff_t); - edge->diff = diff; - if (added_count) { - diff->added.array = ecs_os_malloc_n(ecs_id_t, added_count); - diff->added.count = 0; - diff->added.size = added_count; - } - if (removed_count) { - diff->removed.array = ecs_os_malloc_n(ecs_id_t, removed_count); - diff->removed.count = 0; - diff->removed.size = removed_count; - } - - for (i_node = 0, i_next = 0; i_node < node_count && i_next < next_count; ) { - ecs_id_t id_node = ids_node[i_node]; - ecs_id_t id_next = ids_next[i_next]; + ULONG current, resolution = 10000; /* 1 ms */ - if (id_next < id_node) { - diff_insert_added(world, node, diff, id_next); - } else if (id_node < id_next) { - diff_insert_removed(world, next, diff, id_node); - } + if (!enable && win_current_resolution) { + pNtSetTimerResolution(win_current_resolution, 0, ¤t); + win_current_resolution = 0; + return; + } else if (!enable) { + return; + } - i_node += id_node <= id_next; - i_next += id_next <= id_node; + if (resolution == win_current_resolution) { + return; } - for (; i_next < next_count; i_next ++) { - diff_insert_added(world, node, diff, ids_next[i_next]); + if (win_current_resolution) { + pNtSetTimerResolution(win_current_resolution, 0, ¤t); } - for (; i_node < node_count; i_node ++) { - diff_insert_removed(world, next, diff, ids_node[i_node]); + + if (pNtSetTimerResolution(resolution, 1, ¤t)) { + /* Try setting a lower resolution */ + resolution *= 2; + if(pNtSetTimerResolution(resolution, 1, ¤t)) return; } - ecs_assert(diff->added.count == added_count, ECS_INTERNAL_ERROR, NULL); - ecs_assert(diff->removed.count == removed_count, ECS_INTERNAL_ERROR, NULL); + win_current_resolution = resolution; } static -void add_with_ids_to_ids( - ecs_world_t *world, - ecs_vector_t **idv, - ecs_entity_t r, - ecs_entity_t o) -{ - /* Check if component/relation has With pairs, which contain ids - * that need to be added to the table. */ - ecs_table_t *id_table = ecs_get_table(world, r); - if (!id_table) { - return; - } - - ecs_table_record_t *tr = flecs_get_table_record(world, id_table, - ecs_pair(EcsWith, EcsWildcard)); - if (tr) { - int32_t i, with_count = tr->count; - int32_t start = tr->column; - int32_t end = start + with_count; - ecs_id_t *id_ids = ecs_vector_first(id_table->type, ecs_id_t); - - for (i = start; i < end; i ++) { - ecs_assert(ECS_PAIR_FIRST(id_ids[i]) == EcsWith, - ECS_INTERNAL_ERROR, NULL); - ecs_id_t id_r = ECS_PAIR_SECOND(id_ids[i]); - ecs_id_t id = id_r; - if (o) { - id = ecs_pair(id_r, o); - } +uint64_t win_time_now(void) { + uint64_t now; - /* Always make sure vector has room for one more */ - add_id_to_ids(idv, id, 0); + LARGE_INTEGER qpc_t; + QueryPerformanceCounter(&qpc_t); + now = (uint64_t)(qpc_t.QuadPart / win_time_freq); - /* Add recursively in case id also has With pairs */ - add_with_ids_to_ids(world, idv, id_r, o); - } - } + return now; } -static -ecs_table_t* find_or_create_table_with_id( - ecs_world_t *world, - ecs_table_t *node, - ecs_entity_t id) -{ - /* If table has one or more switches and this is a case, return self */ - if (ECS_HAS_ROLE(id, CASE)) { - ecs_assert((node->flags & EcsTableHasSwitch) != 0, - ECS_TYPE_INVALID_CASE, NULL); - return node; - } else { - ecs_type_t type = node->type; - ecs_entity_t r_exclusive = 0; - ecs_entity_t r = 0, o = 0, re = 0; +void ecs_set_os_api_impl(void) { + ecs_os_set_api_defaults(); - if (ECS_HAS_ROLE(id, PAIR)) { - r = ECS_PAIR_FIRST(id); - o = ECS_PAIR_SECOND(id); - re = ecs_get_alive(world, r); - if (re && ecs_has_id(world, re, EcsExclusive)) { - r_exclusive = (uint32_t)re; - } - } else { - r = id & ECS_COMPONENT_MASK; - re = ecs_get_alive(world, r); - } + ecs_os_api_t api = ecs_os_api; - ecs_vector_t *idv = ecs_vector_copy(type, ecs_id_t); - add_id_to_ids(&idv, id, r_exclusive); - if (re) { - add_with_ids_to_ids(world, &idv, re, o); - } + api.thread_new_ = win_thread_new; + api.thread_join_ = win_thread_join; + api.ainc_ = win_ainc; + api.adec_ = win_adec; + api.mutex_new_ = win_mutex_new; + api.mutex_free_ = win_mutex_free; + api.mutex_lock_ = win_mutex_lock; + api.mutex_unlock_ = win_mutex_unlock; + api.cond_new_ = win_cond_new; + api.cond_free_ = win_cond_free; + api.cond_signal_ = win_cond_signal; + api.cond_broadcast_ = win_cond_broadcast; + api.cond_wait_ = win_cond_wait; + api.sleep_ = win_sleep; + api.now_ = win_time_now; + api.enable_high_timer_resolution_ = win_enable_high_timer_resolution; - ecs_ids_t ids = { - .array = ecs_vector_first(idv, ecs_id_t), - .count = ecs_vector_count(idv) - }; + win_time_setup(); - return find_or_create(world, &ids, idv); - } + ecs_os_set_api(&api); } -static -ecs_table_t* find_or_create_table_without_id( - ecs_world_t *world, - ecs_table_t *node, - ecs_entity_t id) -{ - /* If table has one or more switches and this is a case, return self */ - if (ECS_HAS_ROLE(id, CASE)) { - ecs_assert((node->flags & EcsTableHasSwitch) != 0, - ECS_TYPE_INVALID_CASE, NULL); - return node; - } else { - ecs_type_t type = node->type; - int32_t count = ecs_vector_count(type); - - ecs_ids_t ids = { - .array = ecs_os_alloca_n(ecs_id_t, count), - .count = count - }; - - remove_id_from_ids(type, id, &ids); +#else +#include "pthread.h" - return flecs_table_find_or_create(world, &ids);; - } -} +#if defined(__APPLE__) && defined(__MACH__) +#include +#elif defined(__EMSCRIPTEN__) +#include +#else +#include +#endif static -ecs_table_t* find_or_create_table_with_isa( - ecs_world_t *world, - ecs_table_t *node, - ecs_entity_t base) +ecs_os_thread_t posix_thread_new( + ecs_os_thread_callback_t callback, + void *arg) { - ecs_type_t base_type = ecs_get_type(world, base); - ecs_id_t *ids = ecs_vector_first(base_type, ecs_id_t); - int32_t i, count = ecs_vector_count(base_type); - - /* Start from back, as roles have high ids */ - for (i = count - 1; i >= 0; i --) { - ecs_id_t id = ids[i]; - if (!(id & ECS_ROLE_MASK)) { /* early out if we found everything */ - break; - } - - if (ECS_HAS_RELATION(id, EcsIsA)) { - ecs_entity_t base_of_base = ecs_pair_second(world, id); - node = find_or_create_table_with_isa(world, node, base_of_base); - } + pthread_t *thread = ecs_os_malloc(sizeof(pthread_t)); - if (ECS_HAS_ROLE(id, OVERRIDE)) { - /* Override found, add it to table */ - id &= ECS_COMPONENT_MASK; - node = flecs_table_traverse_add(world, node, &id, NULL); - } + if (pthread_create (thread, NULL, callback, arg) != 0) { + ecs_os_abort(); } - return node; + return (ecs_os_thread_t)(uintptr_t)thread; } static -void init_edge( - ecs_table_t *table, - ecs_graph_edge_t *edge, - ecs_id_t id, - ecs_table_t *to) +void* posix_thread_join( + ecs_os_thread_t thread) { - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->id == 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->hdr.next == NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->hdr.prev == NULL, ECS_INTERNAL_ERROR, NULL); - - edge->from = table; - edge->to = to; - edge->id = id; + void *arg; + pthread_t *thr = (pthread_t*)(uintptr_t)thread; + pthread_join(*thr, &arg); + ecs_os_free(thr); + return arg; } static -void init_add_edge( - ecs_world_t *world, - ecs_table_t *table, - ecs_graph_edge_t *edge, - ecs_id_t id, - ecs_table_t *to) +int32_t posix_ainc( + int32_t *count) { - init_edge(table, edge, id, to); - - ensure_hi_edge(world, &table->node.add, id); - - if (table != to) { - /* Add edges are appended to refs.next */ - ecs_graph_edge_hdr_t *to_refs = &to->node.refs; - ecs_graph_edge_hdr_t *next = to_refs->next; - - to_refs->next = &edge->hdr; - edge->hdr.prev = to_refs; + int value; +#ifdef __GNUC__ + value = __sync_add_and_fetch (count, 1); + return value; +#else + /* Unsupported */ + abort(); +#endif +} - edge->hdr.next = next; - if (next) { - next->prev = &edge->hdr; - } +static +int32_t posix_adec( + int32_t *count) +{ + int value; +#ifdef __GNUC__ + value = __sync_sub_and_fetch (count, 1); + return value; +#else + /* Unsupported */ + abort(); +#endif +} - compute_table_diff(world, table, to, edge, id); +static +ecs_os_mutex_t posix_mutex_new(void) { + pthread_mutex_t *mutex = ecs_os_malloc(sizeof(pthread_mutex_t)); + if (pthread_mutex_init(mutex, NULL)) { + abort(); } + return (ecs_os_mutex_t)(uintptr_t)mutex; } static -void init_remove_edge( - ecs_world_t *world, - ecs_table_t *table, - ecs_graph_edge_t *edge, - ecs_id_t id, - ecs_table_t *to) +void posix_mutex_free( + ecs_os_mutex_t m) { - init_edge(table, edge, id, to); - - ensure_hi_edge(world, &table->node.remove, id); - - if (table != to) { - /* Remove edges are appended to refs.prev */ - ecs_graph_edge_hdr_t *to_refs = &to->node.refs; - ecs_graph_edge_hdr_t *prev = to_refs->prev; - - to_refs->prev = &edge->hdr; - edge->hdr.next = to_refs; - - edge->hdr.prev = prev; - if (prev) { - prev->next = &edge->hdr; - } + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + pthread_mutex_destroy(mutex); + ecs_os_free(mutex); +} - compute_table_diff(world, table, to, edge, id); +static +void posix_mutex_lock( + ecs_os_mutex_t m) +{ + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_mutex_lock(mutex)) { + abort(); } } static -ecs_table_t* find_or_create_table_without( - ecs_world_t *world, - ecs_table_t *node, - ecs_graph_edge_t *edge, - ecs_id_t id) +void posix_mutex_unlock( + ecs_os_mutex_t m) { - ecs_table_t *to = find_or_create_table_without_id(world, node, id); - - init_remove_edge(world, node, edge, id, to); - - return to; + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_mutex_unlock(mutex)) { + abort(); + } } static -ecs_table_t* find_or_create_table_with( - ecs_world_t *world, - ecs_table_t *node, - ecs_graph_edge_t *edge, - ecs_id_t id) -{ - ecs_table_t *to = find_or_create_table_with_id(world, node, id); +ecs_os_cond_t posix_cond_new(void) { + pthread_cond_t *cond = ecs_os_malloc(sizeof(pthread_cond_t)); + if (pthread_cond_init(cond, NULL)) { + abort(); + } + return (ecs_os_cond_t)(uintptr_t)cond; +} - if (ECS_HAS_ROLE(id, PAIR) && ECS_PAIR_FIRST(id) == EcsIsA) { - ecs_entity_t base = ecs_pair_second(world, id); - to = find_or_create_table_with_isa(world, to, base); +static +void posix_cond_free( + ecs_os_cond_t c) +{ + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_destroy(cond)) { + abort(); } + ecs_os_free(cond); +} - init_add_edge(world, node, edge, id, to); +static +void posix_cond_signal( + ecs_os_cond_t c) +{ + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_signal(cond)) { + abort(); + } +} - return to; +static +void posix_cond_broadcast( + ecs_os_cond_t c) +{ + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + if (pthread_cond_broadcast(cond)) { + abort(); + } } -static -void populate_diff( - ecs_graph_edge_t *edge, - ecs_id_t *add_ptr, - ecs_id_t *remove_ptr, - ecs_table_diff_t *out) +static +void posix_cond_wait( + ecs_os_cond_t c, + ecs_os_mutex_t m) { - if (out) { - ecs_table_diff_t *diff = edge->diff; + pthread_cond_t *cond = (pthread_cond_t*)(intptr_t)c; + pthread_mutex_t *mutex = (pthread_mutex_t*)(intptr_t)m; + if (pthread_cond_wait(cond, mutex)) { + abort(); + } +} - if (diff && diff != &ecs_table_edge_is_component) { - ecs_assert(!add_ptr || !ECS_HAS_ROLE(add_ptr[0], CASE), - ECS_INTERNAL_ERROR, NULL); - ecs_assert(!remove_ptr || !ECS_HAS_ROLE(remove_ptr[0], CASE), - ECS_INTERNAL_ERROR, NULL); - *out = *diff; - } else { - out->on_set.count = 0; +static bool posix_time_initialized; - if (add_ptr) { - out->added.array = add_ptr; - out->added.count = 1; - } else { - out->added.count = 0; - } +#if defined(__APPLE__) && defined(__MACH__) +static mach_timebase_info_data_t posix_osx_timebase; +static uint64_t posix_time_start; +#else +static uint64_t posix_time_start; +#endif - if (remove_ptr) { - out->removed.array = remove_ptr; - out->removed.count = 1; - if (diff == &ecs_table_edge_is_component) { - out->un_set.array = remove_ptr; - out->un_set.count = 1; - } else { - out->un_set.count = 0; - } - } else { - out->removed.count = 0; - out->un_set.count = 0; - } - } +static +void posix_time_setup(void) { + if (posix_time_initialized) { + return; } + + posix_time_initialized = true; + + #if defined(__APPLE__) && defined(__MACH__) + mach_timebase_info(&posix_osx_timebase); + posix_time_start = mach_absolute_time(); + #else + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + posix_time_start = (uint64_t)ts.tv_sec*1000000000 + (uint64_t)ts.tv_nsec; + #endif } -ecs_table_t* flecs_table_traverse_remove( - ecs_world_t *world, - ecs_table_t *node, - ecs_id_t *id_ptr, - ecs_table_diff_t *diff) +static +void posix_sleep( + int32_t sec, + int32_t nanosec) { - ecs_poly_assert(world, ecs_world_t); - - node = node ? node : &world->store.root; - - /* Removing 0 from an entity is not valid */ - ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL); - - ecs_id_t id = id_ptr[0]; - ecs_graph_edge_t *edge = ensure_edge(world, &node->node.remove, id); - ecs_table_t *to = edge->to; + struct timespec sleepTime; + ecs_assert(sec >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_assert(nanosec >= 0, ECS_INTERNAL_ERROR, NULL); - if (!to) { - to = find_or_create_table_without(world, node, edge, id); - ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL); + sleepTime.tv_sec = sec; + sleepTime.tv_nsec = nanosec; + if (nanosleep(&sleepTime, NULL)) { + ecs_err("nanosleep failed"); } - - populate_diff(edge, NULL, id_ptr, diff); - - return to; -error: - return NULL; } -ecs_table_t* flecs_table_traverse_add( - ecs_world_t *world, - ecs_table_t *node, - ecs_id_t *id_ptr, - ecs_table_diff_t *diff) -{ - ecs_poly_assert(world, ecs_world_t); - - node = node ? node : &world->store.root; +static +void posix_enable_high_timer_resolution(bool enable) { + (void)enable; +} - /* Adding 0 to an entity is not valid */ - ecs_check(id_ptr != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(id_ptr[0] != 0, ECS_INVALID_PARAMETER, NULL); +/* prevent 64-bit overflow when computing relative timestamp + see https://gist.github.com/jspohr/3dc4f00033d79ec5bdaf67bc46c813e3 +*/ +#if defined(ECS_TARGET_DARWIN) +static +int64_t posix_int64_muldiv(int64_t value, int64_t numer, int64_t denom) { + int64_t q = value / denom; + int64_t r = value % denom; + return q * numer + r * numer / denom; +} +#endif - ecs_id_t id = id_ptr[0]; - ecs_graph_edge_t *edge = ensure_edge(world, &node->node.add, id); - ecs_table_t *to = edge->to; +static +uint64_t posix_time_now(void) { + ecs_assert(posix_time_initialized != 0, ECS_INTERNAL_ERROR, NULL); - if (!to) { - to = find_or_create_table_with(world, node, edge, id); - ecs_assert(to != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->to != NULL, ECS_INTERNAL_ERROR, NULL); - } + uint64_t now; - populate_diff(edge, id_ptr, NULL, diff); + #if defined(ECS_TARGET_DARWIN) + now = (uint64_t) posix_int64_muldiv( + (int64_t)mach_absolute_time(), + (int64_t)posix_osx_timebase.numer, + (int64_t)posix_osx_timebase.denom); + #elif defined(__EMSCRIPTEN__) + now = (long long)(emscripten_get_now() * 1000.0 * 1000); + #else + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + now = ((uint64_t)ts.tv_sec * 1000 * 1000 * 1000 + (uint64_t)ts.tv_nsec); + #endif - return to; -error: - return NULL; + return now; } -ecs_table_t* flecs_table_find_or_create( - ecs_world_t *world, - const ecs_ids_t *ids) -{ - ecs_poly_assert(world, ecs_world_t); - return find_or_create(world, ids, NULL); -} +void ecs_set_os_api_impl(void) { + ecs_os_set_api_defaults(); -void flecs_init_root_table( - ecs_world_t *world) -{ - ecs_poly_assert(world, ecs_world_t); + ecs_os_api_t api = ecs_os_api; - ecs_ids_t entities = { - .array = NULL, - .count = 0 - }; + api.thread_new_ = posix_thread_new; + api.thread_join_ = posix_thread_join; + api.ainc_ = posix_ainc; + api.adec_ = posix_adec; + api.mutex_new_ = posix_mutex_new; + api.mutex_free_ = posix_mutex_free; + api.mutex_lock_ = posix_mutex_lock; + api.mutex_unlock_ = posix_mutex_unlock; + api.cond_new_ = posix_cond_new; + api.cond_free_ = posix_cond_free; + api.cond_signal_ = posix_cond_signal; + api.cond_broadcast_ = posix_cond_broadcast; + api.cond_wait_ = posix_cond_wait; + api.sleep_ = posix_sleep; + api.now_ = posix_time_now; + api.enable_high_timer_resolution_ = posix_enable_high_timer_resolution; - world->store.root.type = ids_to_vector(&entities); - init_table(world, &world->store.root); + posix_time_setup(); - /* Ensure table indices start at 1, as 0 is reserved for the root */ - uint64_t new_id = flecs_sparse_new_id(&world->store.tables); - ecs_assert(new_id == 0, ECS_INTERNAL_ERROR, NULL); - (void)new_id; + ecs_os_set_api(&api); } -void flecs_table_clear_edges( - ecs_world_t *world, - ecs_table_t *table) -{ - (void)world; - ecs_poly_assert(world, ecs_world_t); - - ecs_log_push_1(); - - ecs_map_iter_t it; - ecs_graph_node_t *table_node = &table->node; - ecs_graph_edges_t *node_add = &table_node->add; - ecs_graph_edges_t *node_remove = &table_node->remove; - ecs_map_t *add_hi = &node_add->hi; - ecs_map_t *remove_hi = &node_remove->hi; - ecs_graph_edge_hdr_t *node_refs = &table_node->refs; - ecs_graph_edge_t *edge; - uint64_t key; +#endif +#endif - /* Cleanup outgoing edges */ - it = ecs_map_iter(add_hi); - while ((edge = ecs_map_next_ptr(&it, ecs_graph_edge_t*, &key))) { - disconnect_edge(world, key, edge); - } - it = ecs_map_iter(remove_hi); - while ((edge = ecs_map_next_ptr(&it, ecs_graph_edge_t*, &key))) { - disconnect_edge(world, key, edge); - } - /* Cleanup incoming add edges */ - ecs_graph_edge_hdr_t *next, *cur = node_refs->next; - if (cur) { - do { - edge = (ecs_graph_edge_t*)cur; - ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL); - next = cur->next; - remove_edge(world, &edge->from->node.add, edge->id, edge); - } while ((cur = next)); - } +#ifdef FLECS_COREDOC - /* Cleanup incoming remove edges */ - cur = node_refs->prev; - if (cur) { - do { - edge = (ecs_graph_edge_t*)cur; - ecs_assert(edge->to == table, ECS_INTERNAL_ERROR, NULL); - ecs_assert(edge->from != NULL, ECS_INTERNAL_ERROR, NULL); - next = cur->prev; - remove_edge(world, &edge->from->node.remove, edge->id, edge); - } while ((cur = next)); - } +#define URL_ROOT "https://flecs.docsforge.com/master/relations-manual/" - ecs_os_free(node_add->lo); - ecs_os_free(node_remove->lo); - ecs_map_fini(add_hi); - ecs_map_fini(remove_hi); - table_node->add.lo = NULL; - table_node->remove.lo = NULL; +void FlecsCoreDocImport( + ecs_world_t *world) +{ + ECS_MODULE(world, FlecsCoreDoc); - ecs_log_pop_1(); -} + ECS_IMPORT(world, FlecsMeta); + ECS_IMPORT(world, FlecsDoc); -/* Public convenience functions for traversing table graph */ -ecs_table_t* ecs_table_add_id( - ecs_world_t *world, - ecs_table_t *table, - ecs_id_t id) -{ - return flecs_table_traverse_add(world, table, &id, NULL); -} + ecs_set_name_prefix(world, "Ecs"); -ecs_table_t* ecs_table_remove_id( - ecs_world_t *world, - ecs_table_t *table, - ecs_id_t id) -{ - return flecs_table_traverse_remove(world, table, &id, NULL); -} + /* Initialize reflection data for core components */ -#include + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsComponent), + .members = { + {.name = (char*)"size", .type = ecs_id(ecs_i32_t)}, + {.name = (char*)"alignment", .type = ecs_id(ecs_i32_t)} + } + }); -#define INIT_CACHE(it, f, term_count)\ - if (!it->f && term_count) {\ - if (term_count <= ECS_TERM_CACHE_SIZE) {\ - it->f = it->priv.cache.f;\ - it->priv.cache.f##_alloc = false;\ - } else {\ - it->f = ecs_os_calloc(ECS_SIZEOF(*(it->f)) * term_count);\ - it->priv.cache.f##_alloc = true;\ - }\ - } + ecs_struct_init(world, &(ecs_struct_desc_t) { + .entity.entity = ecs_id(EcsDocDescription), + .members = { + {.name = "value", .type = ecs_id(ecs_string_t)} + } + }); -#define FINI_CACHE(it, f)\ - if (it->f) {\ - if (it->priv.cache.f##_alloc) {\ - ecs_os_free((void*)it->f);\ - }\ - } + /* Initialize documentation data for core components */ + ecs_doc_set_brief(world, EcsFlecs, "Flecs root module"); + ecs_doc_set_link(world, EcsFlecs, "https://github.com/SanderMertens/flecs"); -void flecs_iter_init( - ecs_iter_t *it) -{ - INIT_CACHE(it, ids, it->term_count); - INIT_CACHE(it, subjects, it->term_count); - INIT_CACHE(it, match_indices, it->term_count); - INIT_CACHE(it, columns, it->term_count); - - if (!it->is_filter) { - INIT_CACHE(it, sizes, it->term_count); - INIT_CACHE(it, ptrs, it->term_count); - } else { - it->sizes = NULL; - it->ptrs = NULL; - } + ecs_doc_set_brief(world, EcsFlecsCore, "Flecs module with builtin components"); + ecs_doc_set_brief(world, EcsFlecsHidden, "Flecs module with internal/anonymous entities"); - it->is_valid = true; -} + ecs_doc_set_brief(world, EcsWorld, "Entity associated with world"); -void ecs_iter_fini( - ecs_iter_t *it) -{ - ecs_check(it->is_valid == true, ECS_INVALID_PARAMETER, NULL); - it->is_valid = false; + ecs_doc_set_brief(world, ecs_id(EcsComponent), "Component that is added to all components"); + ecs_doc_set_brief(world, EcsModule, "Tag that is added to modules"); + ecs_doc_set_brief(world, EcsPrefab, "Tag that is added to prefabs"); + ecs_doc_set_brief(world, EcsDisabled, "Tag that is added to disabled entities"); - if (it->fini) { - it->fini(it); - } + ecs_doc_set_brief(world, ecs_id(EcsIdentifier), "Component used for entity names"); + ecs_doc_set_brief(world, EcsName, "Tag used with EcsIdentifier to signal entity name"); + ecs_doc_set_brief(world, EcsSymbol, "Tag used with EcsIdentifier to signal entity symbol"); - FINI_CACHE(it, ids); - FINI_CACHE(it, columns); - FINI_CACHE(it, subjects); - FINI_CACHE(it, sizes); - FINI_CACHE(it, ptrs); - FINI_CACHE(it, match_indices); -error: - return; -} + ecs_doc_set_brief(world, ecs_id(EcsComponentLifecycle), "Callbacks for component constructors, destructors, copy and move operations"); -static -bool flecs_iter_populate_term_data( - ecs_world_t *world, - ecs_iter_t *it, - int32_t t, - int32_t column, - void **ptr_out, - ecs_size_t *size_out) -{ - bool is_shared = false; + ecs_doc_set_brief(world, EcsTransitive, "Transitive relation property"); + ecs_doc_set_brief(world, EcsReflexive, "Reflexive relation property"); + ecs_doc_set_brief(world, EcsFinal, "Final relation property"); + ecs_doc_set_brief(world, EcsDontInherit, "DontInherit relation property"); + ecs_doc_set_brief(world, EcsTag, "Tag relation property"); + ecs_doc_set_brief(world, EcsAcyclic, "Acyclic relation property"); + ecs_doc_set_brief(world, EcsExclusive, "Exclusive relation property"); + ecs_doc_set_brief(world, EcsSymmetric, "Symmetric relation property"); + ecs_doc_set_brief(world, EcsWith, "With relation property"); + ecs_doc_set_brief(world, EcsOnDelete, "OnDelete relation cleanup property"); + ecs_doc_set_brief(world, EcsOnDeleteObject, "OnDeleteObject relation cleanup property"); + ecs_doc_set_brief(world, EcsDefaultChildComponent, "Sets default component hint for children of entity"); + ecs_doc_set_brief(world, EcsRemove, "Remove relation cleanup property"); + ecs_doc_set_brief(world, EcsDelete, "Delete relation cleanup property"); + ecs_doc_set_brief(world, EcsThrow, "Throw relation cleanup property"); + ecs_doc_set_brief(world, EcsIsA, "Builtin IsA relation"); + ecs_doc_set_brief(world, EcsChildOf, "Builtin ChildOf relation"); + ecs_doc_set_brief(world, EcsOnAdd, "Builtin OnAdd event"); + ecs_doc_set_brief(world, EcsOnRemove, "Builtin OnRemove event"); + ecs_doc_set_brief(world, EcsOnSet, "Builtin OnSet event"); + ecs_doc_set_brief(world, EcsUnSet, "Builtin UnSet event"); - if (!column) { - /* Term has no data. This includes terms that have Not operators. */ - goto no_data; - } + ecs_doc_set_link(world, EcsTransitive, URL_ROOT "#transitive-property"); + ecs_doc_set_link(world, EcsReflexive, URL_ROOT "#reflexive-property"); + ecs_doc_set_link(world, EcsFinal, URL_ROOT "#final-property"); + ecs_doc_set_link(world, EcsDontInherit, URL_ROOT "#dontinherit-property"); + ecs_doc_set_link(world, EcsTag, URL_ROOT "#tag-property"); + ecs_doc_set_link(world, EcsAcyclic, URL_ROOT "#acyclic-property"); + ecs_doc_set_link(world, EcsExclusive, URL_ROOT "#exclusive-property"); + ecs_doc_set_link(world, EcsSymmetric, URL_ROOT "#symmetric-property"); + ecs_doc_set_link(world, EcsWith, URL_ROOT "#with-property"); + ecs_doc_set_link(world, EcsOnDelete, URL_ROOT "#cleanup-properties"); + ecs_doc_set_link(world, EcsOnDeleteObject, URL_ROOT "#cleanup-properties"); + ecs_doc_set_link(world, EcsRemove, URL_ROOT "#cleanup-properties"); + ecs_doc_set_link(world, EcsDelete, URL_ROOT "#cleanup-properties"); + ecs_doc_set_link(world, EcsThrow, URL_ROOT "#cleanup-properties"); + ecs_doc_set_link(world, EcsIsA, URL_ROOT "#the-isa-relation"); + ecs_doc_set_link(world, EcsChildOf, URL_ROOT "#the-childof-relation"); + + /* Initialize documentation for meta components */ + ecs_entity_t meta = ecs_lookup_fullpath(world, "flecs.meta"); + ecs_doc_set_brief(world, meta, "Flecs module with reflection components"); - if (!it->terms) { - goto no_data; - } + ecs_doc_set_brief(world, ecs_id(EcsMetaType), "Component added to types"); + ecs_doc_set_brief(world, ecs_id(EcsMetaTypeSerialized), "Component that stores reflection data in an optimized format"); + ecs_doc_set_brief(world, ecs_id(EcsPrimitive), "Component added to primitive types"); + ecs_doc_set_brief(world, ecs_id(EcsEnum), "Component added to enumeration types"); + ecs_doc_set_brief(world, ecs_id(EcsBitmask), "Component added to bitmask types"); + ecs_doc_set_brief(world, ecs_id(EcsMember), "Component added to struct members"); + ecs_doc_set_brief(world, ecs_id(EcsStruct), "Component added to struct types"); + ecs_doc_set_brief(world, ecs_id(EcsArray), "Component added to array types"); + ecs_doc_set_brief(world, ecs_id(EcsVector), "Component added to vector types"); - /* Filter terms may match with data but don't return it */ - if (it->terms[t].inout == EcsInOutFilter) { - goto no_data; - } + ecs_doc_set_brief(world, ecs_id(ecs_bool_t), "bool component"); + ecs_doc_set_brief(world, ecs_id(ecs_char_t), "char component"); + ecs_doc_set_brief(world, ecs_id(ecs_byte_t), "byte component"); + ecs_doc_set_brief(world, ecs_id(ecs_u8_t), "8 bit unsigned int component"); + ecs_doc_set_brief(world, ecs_id(ecs_u16_t), "16 bit unsigned int component"); + ecs_doc_set_brief(world, ecs_id(ecs_u32_t), "32 bit unsigned int component"); + ecs_doc_set_brief(world, ecs_id(ecs_u64_t), "64 bit unsigned int component"); + ecs_doc_set_brief(world, ecs_id(ecs_uptr_t), "word sized unsigned int component"); + ecs_doc_set_brief(world, ecs_id(ecs_i8_t), "8 bit signed int component"); + ecs_doc_set_brief(world, ecs_id(ecs_i16_t), "16 bit signed int component"); + ecs_doc_set_brief(world, ecs_id(ecs_i32_t), "32 bit signed int component"); + ecs_doc_set_brief(world, ecs_id(ecs_i64_t), "64 bit signed int component"); + ecs_doc_set_brief(world, ecs_id(ecs_iptr_t), "word sized signed int component"); + ecs_doc_set_brief(world, ecs_id(ecs_f32_t), "32 bit floating point component"); + ecs_doc_set_brief(world, ecs_id(ecs_f64_t), "64 bit floating point component"); + ecs_doc_set_brief(world, ecs_id(ecs_string_t), "string component"); + ecs_doc_set_brief(world, ecs_id(ecs_entity_t), "entity component"); - ecs_table_t *table; - ecs_vector_t *vec; - ecs_size_t size; - ecs_size_t align; - int32_t row; + /* Initialize documentation for doc components */ + ecs_entity_t doc = ecs_lookup_fullpath(world, "flecs.doc"); + ecs_doc_set_brief(world, doc, "Flecs module with documentation components"); - if (column < 0) { - is_shared = true; + ecs_doc_set_brief(world, ecs_id(EcsDocDescription), "Component used to add documentation"); + ecs_doc_set_brief(world, EcsDocBrief, "Used as (Description, Brief) to add a brief description"); + ecs_doc_set_brief(world, EcsDocDetail, "Used as (Description, Detail) to add a detailed description"); + ecs_doc_set_brief(world, EcsDocLink, "Used as (Description, Link) to add a link"); +} - /* Data is not from This */ - if (it->references) { - /* Iterator provides cached references for non-This terms */ - ecs_ref_t *ref = &it->references[-column - 1]; - if (ptr_out) ptr_out[0] = (void*)ecs_get_ref_id( - world, ref, ref->entity, ref->component); +#endif - /* If cached references were provided, the code that populated - * the iterator also had a chance to cache sizes, so size array - * should already have been assigned. This saves us from having - * to do additional lookups to find the component size. */ - ecs_assert(size_out == NULL, ECS_INTERNAL_ERROR, NULL); - return true; - } else { - ecs_entity_t subj = it->subjects[t]; - ecs_assert(subj != 0, ECS_INTERNAL_ERROR, NULL); - /* Don't use ecs_get_id directly. Instead, go directly to the - * storage so that we can get both the pointer and size */ - ecs_record_t *r = ecs_eis_get(world, subj); - ecs_assert(r != NULL && r->table != NULL, ECS_INTERNAL_ERROR, NULL); +#ifdef FLECS_PARSER - row = ECS_RECORD_TO_ROW(r->row); - table = r->table; +#include - ecs_id_t id = it->ids[t]; - ecs_table_t *s_table = table->storage_table; - ecs_table_record_t *tr; +#define ECS_ANNOTATION_LENGTH_MAX (16) - if (!s_table || !(tr = flecs_get_table_record(world, s_table, id))){ - /* The entity has no components or the id is not a component */ - - ecs_id_t term_id = it->terms[t].id; - if (ECS_HAS_ROLE(term_id, SWITCH) || ECS_HAS_ROLE(term_id, CASE)) { - /* Edge case: if this is a switch. Find switch column in - * actual table, as its not in the storage table */ - tr = flecs_get_table_record(world, table, id); - ecs_assert(tr != NULL, ECS_INTERNAL_ERROR, NULL); - column = tr->column; - goto has_switch; - } else { - goto no_data; - } - } +#define TOK_NEWLINE '\n' +#define TOK_COLON ':' +#define TOK_AND ',' +#define TOK_OR "||" +#define TOK_NOT '!' +#define TOK_OPTIONAL '?' +#define TOK_BITWISE_OR '|' +#define TOK_NAME_SEP '.' +#define TOK_BRACKET_OPEN '[' +#define TOK_BRACKET_CLOSE ']' +#define TOK_WILDCARD '*' +#define TOK_SINGLETON '$' +#define TOK_PAREN_OPEN '(' +#define TOK_PAREN_CLOSE ')' +#define TOK_AS_ENTITY '\\' - /* We now have row and column, so we can get the storage for the id - * which gives us the pointer and size */ - column = tr->column; - ecs_column_t *s = &table->storage.columns[column]; - size = s->size; - align = s->alignment; - vec = s->data; - /* Fallthrough to has_data */ - } - } else { - /* Data is from This, use table from iterator */ - table = it->table; - if (!table || !ecs_table_count(table)) { - goto no_data; - } +#define TOK_SELF "self" +#define TOK_SUPERSET "super" +#define TOK_SUBSET "sub" +#define TOK_CASCADE "cascade" +#define TOK_PARENT "parent" +#define TOK_ALL "all" - row = it->offset; - - int32_t storage_column = ecs_table_type_to_storage_index( - table, column - 1); - if (storage_column == -1) { - ecs_id_t id = it->terms[t].id; - if (ECS_HAS_ROLE(id, SWITCH) || ECS_HAS_ROLE(id, CASE)) { - goto has_switch; - } - goto no_data; - } +#define TOK_OVERRIDE "OVERRIDE" - ecs_column_t *s = &table->storage.columns[storage_column]; - size = s->size; - align = s->alignment; - vec = s->data; - /* Fallthrough to has_data */ - } +#define TOK_ROLE_PAIR "PAIR" +#define TOK_ROLE_AND "AND" +#define TOK_ROLE_OR "OR" +#define TOK_ROLE_XOR "XOR" +#define TOK_ROLE_NOT "NOT" +#define TOK_ROLE_SWITCH "SWITCH" +#define TOK_ROLE_CASE "CASE" +#define TOK_ROLE_DISABLED "DISABLED" -has_data: - if (ptr_out) ptr_out[0] = ecs_vector_get_t(vec, size, align, row); - if (size_out) size_out[0] = size; - return is_shared; +#define TOK_IN "in" +#define TOK_OUT "out" +#define TOK_INOUT "inout" +#define TOK_INOUT_FILTER "filter" -has_switch: { - /* Edge case: if column is a switch we should return the vector with case - * identifiers. Will be replaced in the future with pluggable storage */ - ecs_switch_t *sw = table->storage.sw_columns[ - (column - 1) - table->sw_column_offset].data; - vec = flecs_switch_values(sw); - size = ECS_SIZEOF(ecs_entity_t); - align = ECS_ALIGNOF(ecs_entity_t); - goto has_data; - } +#define ECS_MAX_TOKEN_SIZE (256) -no_data: - if (ptr_out) ptr_out[0] = NULL; - if (size_out) size_out[0] = 0; - return false; -} +typedef char ecs_token_t[ECS_MAX_TOKEN_SIZE]; -void flecs_iter_populate_data( - ecs_world_t *world, - ecs_iter_t *it, - ecs_table_t *table, - int32_t offset, - int32_t count, - void **ptrs, - ecs_size_t *sizes) +const char* ecs_parse_eol_and_whitespace( + const char *ptr) { - if (it->table) { - it->frame_offset += ecs_table_count(it->table); + while (isspace(*ptr)) { + ptr ++; } - it->table = table; - it->offset = offset; - it->count = count; + return ptr; +} - if (table) { - it->type = it->table->type; - if (!count) { - count = it->count = ecs_table_count(table); - } - if (count) { - it->entities = ecs_vector_get( - table->storage.entities, ecs_entity_t, offset); - } else { - it->entities = NULL; - } +/** Skip spaces when parsing signature */ +const char* ecs_parse_whitespace( + const char *ptr) +{ + while ((*ptr != '\n') && isspace(*ptr)) { + ptr ++; } - if (it->is_filter) { - it->has_shared = false; - return; + return ptr; +} + +const char* ecs_parse_digit( + const char *ptr, + char *token) +{ + char *tptr = token; + char ch = ptr[0]; + + if (!isdigit(ch) && ch != '-') { + ecs_parser_error(NULL, NULL, 0, "invalid start of number '%s'", ptr); + return NULL; } - int t, term_count = it->term_count; - bool has_shared = false; + tptr[0] = ch; + tptr ++; + ptr ++; - if (ptrs && sizes) { - for (t = 0; t < term_count; t ++) { - int32_t column = it->columns[t]; - has_shared |= flecs_iter_populate_term_data(world, it, t, column, - &ptrs[t], - &sizes[t]); - } - } else { - for (t = 0; t < term_count; t ++) { - int32_t column = it->columns[t]; - void **ptr = NULL; - if (ptrs) { - ptr = &ptrs[t]; - } - ecs_size_t *size = NULL; - if (sizes) { - size = &sizes[t]; - } - has_shared |= flecs_iter_populate_term_data(world, it, t, column, - ptr, size); + for (; (ch = *ptr); ptr ++) { + if (!isdigit(ch)) { + break; } + + tptr[0] = ch; + tptr ++; } - it->has_shared = has_shared; + tptr[0] = '\0'; + + return ptr; } -bool flecs_iter_next_row( - ecs_iter_t *it) +static +bool is_newline_comment( + const char *ptr) { - ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL); + if (ptr[0] == '/' && ptr[1] == '/') { + return true; + } + return false; +} - bool is_instanced = it->is_instanced; - if (!is_instanced) { - int32_t instance_count = it->instance_count; - int32_t count = it->count; - int32_t offset = it->offset; +const char* ecs_parse_fluff( + const char *ptr, + char **last_comment) +{ + const char *last_comment_start = NULL; - if (instance_count > count && offset < (instance_count - 1)) { - ecs_assert(count == 1, ECS_INTERNAL_ERROR, NULL); - int t, term_count = it->term_count; + do { + /* Skip whitespaces before checking for a comment */ + ptr = ecs_parse_whitespace(ptr); - for (t = 0; t < term_count; t ++) { - int32_t column = it->columns[t]; - if (column >= 0) { - void *ptr = it->ptrs[t]; - if (ptr) { - it->ptrs[t] = ECS_OFFSET(ptr, it->sizes[t]); - } - } - } + /* Newline comment, skip until newline character */ + if (is_newline_comment(ptr)) { + ptr += 2; + last_comment_start = ptr; - if (it->entities) { - it->entities ++; + while (ptr[0] && ptr[0] != TOK_NEWLINE) { + ptr ++; } - it->offset ++; + } - return true; + /* If a newline character is found, skip it */ + if (ptr[0] == TOK_NEWLINE) { + ptr ++; } - } - return false; -} + } while (isspace(ptr[0]) || is_newline_comment(ptr)); -bool flecs_iter_next_instanced( - ecs_iter_t *it, - bool result) -{ - it->instance_count = it->count; - if (result && !it->is_instanced && it->count && it->has_shared) { - it->count = 1; + if (last_comment) { + *last_comment = (char*)last_comment_start; } - return result; + + return ptr; } -/* --- Public API --- */ +/* -- Private functions -- */ -void* ecs_term_w_size( - const ecs_iter_t *it, - size_t size, - int32_t term) +static +bool valid_identifier_start_char( + char ch) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(!size || ecs_term_size(it, term) == size || - (!ecs_term_size(it, term) && (!it->ptrs || !it->ptrs[term - 1])), - ECS_INVALID_PARAMETER, NULL); - - (void)size; - - if (!term) { - return it->entities; - } - - if (!it->ptrs) { - return NULL; + if (ch && (isalpha(ch) || (ch == '.') || (ch == '_') || (ch == '*') || + (ch == '0') || (ch == TOK_AS_ENTITY) || isdigit(ch))) + { + return true; } - return it->ptrs[term - 1]; -error: - return NULL; + return false; } -bool ecs_term_is_readonly( - const ecs_iter_t *it, - int32_t term_index) +static +bool valid_token_start_char( + char ch) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(term_index > 0, ECS_INVALID_PARAMETER, NULL); - - ecs_term_t *term = &it->terms[term_index - 1]; - ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - - if (term->inout == EcsIn) { + if ((ch == '"') || (ch == '{') || (ch == '}') || (ch == ',') || (ch == '-') + || (ch == '[') || (ch == ']') || valid_identifier_start_char(ch)) + { return true; - } else { - ecs_term_id_t *subj = &term->subj; + } - if (term->inout == EcsInOutDefault) { - if (subj->entity != EcsThis) { - return true; - } + return false; +} - if (!(subj->set.mask & EcsSelf)) { - return true; - } - } +static +bool valid_token_char( + char ch) +{ + if (ch && + (isalpha(ch) || isdigit(ch) || ch == '_' || ch == '.' || ch == '"')) + { + return true; } -error: return false; } -bool ecs_term_is_writeonly( - const ecs_iter_t *it, - int32_t term_index) +static +bool valid_operator_char( + char ch) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(term_index > 0, ECS_INVALID_PARAMETER, NULL); - - ecs_term_t *term = &it->terms[term_index - 1]; - ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - - if (term->inout == EcsOut) { + if (ch == TOK_OPTIONAL || ch == TOK_NOT) { return true; } -error: return false; } -int32_t ecs_iter_find_column( - const ecs_iter_t *it, - ecs_entity_t component) +static +const char* parse_digit( + const char *ptr, + char *token_out) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); - return ecs_search(it->real_world, it->table, component, 0); -error: - return -1; + ptr = ecs_parse_whitespace(ptr); + ptr = ecs_parse_digit(ptr, token_out); + return ecs_parse_whitespace(ptr); } -bool ecs_term_is_set( - const ecs_iter_t *it, - int32_t index) +const char* ecs_parse_token( + const char *name, + const char *expr, + const char *ptr, + char *token_out) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); + int64_t column = ptr - expr; - int32_t column = it->columns[index - 1]; - if (!column) { - return false; - } else if (column < 0) { - if (it->references) { - column = -column - 1; - ecs_ref_t *ref = &it->references[column]; - return ref->entity != 0; + ptr = ecs_parse_whitespace(ptr); + char *tptr = token_out, ch = ptr[0]; + + if (!valid_token_start_char(ch)) { + if (ch == '\0' || ch == '\n') { + ecs_parser_error(name, expr, column, + "unexpected end of expression"); } else { - return true; + ecs_parser_error(name, expr, column, + "invalid start of token '%s'", ptr); } + return NULL; } - return true; -error: - return false; + tptr[0] = ch; + tptr ++; + ptr ++; + + if (ch == '{' || ch == '}' || ch == '[' || ch == ']' || ch == ',') { + tptr[0] = 0; + return ptr; + } + + int tmpl_nesting = 0; + bool in_str = ch == '"'; + + for (; (ch = *ptr); ptr ++) { + if (ch == '<') { + tmpl_nesting ++; + } else if (ch == '>') { + if (!tmpl_nesting) { + break; + } + tmpl_nesting --; + } else if (ch == '"') { + in_str = !in_str; + } else + if (!valid_token_char(ch) && !in_str) { + break; + } + + tptr[0] = ch; + tptr ++; + } + + tptr[0] = '\0'; + + if (tmpl_nesting != 0) { + ecs_parser_error(name, expr, column, + "identifier '%s' has mismatching < > pairs", ptr); + return NULL; + } + + const char *next_ptr = ecs_parse_whitespace(ptr); + if (next_ptr[0] == ':' && next_ptr != ptr) { + /* Whitespace between token and : is significant */ + ptr = next_ptr - 1; + } else { + ptr = next_ptr; + } + + return ptr; } -void* ecs_iter_column_w_size( - const ecs_iter_t *it, - size_t size, - int32_t index) +static +const char* ecs_parse_identifier( + const char *name, + const char *expr, + const char *ptr, + char *token_out) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); - (void)size; - - ecs_table_t *table = it->table; - int32_t storage_index = ecs_table_type_to_storage_index(table, index); - if (storage_index == -1) { + if (!valid_identifier_start_char(ptr[0])) { + ecs_parser_error(name, expr, (ptr - expr), + "expected start of identifier"); return NULL; } - ecs_column_t *columns = table->storage.columns; - ecs_column_t *column = &columns[storage_index]; - ecs_check(!size || (ecs_size_t)size == column->size, - ECS_INVALID_PARAMETER, NULL); + ptr = ecs_parse_token(name, expr, ptr, token_out); - void *ptr = ecs_vector_first_t( - column->data, column->size, column->alignment); + return ptr; +} - return ECS_OFFSET(ptr, column->size * it->offset); -error: - return NULL; +static +int parse_identifier( + const char *token, + ecs_term_id_t *out) +{ + char ch = token[0]; + + const char *tptr = token; + if (ch == TOK_AS_ENTITY) { + tptr ++; + } + + out->name = ecs_os_strdup(tptr); + + if (ch == TOK_AS_ENTITY) { + out->var = EcsVarIsEntity; + } + + return 0; } -size_t ecs_iter_column_size( - const ecs_iter_t *it, - int32_t index) +static +ecs_entity_t parse_role( + const char *name, + const char *sig, + int64_t column, + const char *token) { - ecs_check(it->is_valid, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->table != NULL, ECS_INVALID_PARAMETER, NULL); - - ecs_table_t *table = it->table; - int32_t storage_index = ecs_table_type_to_storage_index(table, index); - if (storage_index == -1) { + if (!ecs_os_strcmp(token, TOK_ROLE_PAIR)) + { + return ECS_PAIR; + } else if (!ecs_os_strcmp(token, TOK_ROLE_AND)) { + return ECS_AND; + } else if (!ecs_os_strcmp(token, TOK_ROLE_OR)) { + return ECS_OR; + } else if (!ecs_os_strcmp(token, TOK_ROLE_XOR)) { + return ECS_XOR; + } else if (!ecs_os_strcmp(token, TOK_ROLE_NOT)) { + return ECS_NOT; + } else if (!ecs_os_strcmp(token, TOK_ROLE_SWITCH)) { + return ECS_SWITCH; + } else if (!ecs_os_strcmp(token, TOK_ROLE_CASE)) { + return ECS_CASE; + } else if (!ecs_os_strcmp(token, TOK_OVERRIDE)) { + return ECS_OVERRIDE; + } else if (!ecs_os_strcmp(token, TOK_ROLE_DISABLED)) { + return ECS_DISABLED; + } else { + ecs_parser_error(name, sig, column, "invalid role '%s'", token); return 0; } +} - ecs_column_t *columns = table->storage.columns; - ecs_column_t *column = &columns[storage_index]; - - return flecs_ito(size_t, column->size); -error: - return 0; +static +ecs_oper_kind_t parse_operator( + char ch) +{ + if (ch == TOK_OPTIONAL) { + return EcsOptional; + } else if (ch == TOK_NOT) { + return EcsNot; + } else { + ecs_abort(ECS_INTERNAL_ERROR, NULL); + } } -char* ecs_iter_str( - const ecs_iter_t *it) +static +const char* parse_annotation( + const char *name, + const char *sig, + int64_t column, + const char *ptr, + ecs_inout_kind_t *inout_kind_out) { - ecs_world_t *world = it->world; - ecs_strbuf_t buf = ECS_STRBUF_INIT; - int i; + char token[ECS_MAX_TOKEN_SIZE]; - if (it->term_count) { - ecs_strbuf_list_push(&buf, "term: ", ","); - for (i = 0; i < it->term_count; i ++) { - ecs_id_t id = ecs_term_id(it, i + 1); - char *str = ecs_id_str(world, id); - ecs_strbuf_list_appendstr(&buf, str); - ecs_os_free(str); - } - ecs_strbuf_list_pop(&buf, "\n"); + ptr = ecs_parse_identifier(name, sig, ptr, token); + if (!ptr) { + return NULL; + } - ecs_strbuf_list_push(&buf, "subj: ", ","); - for (i = 0; i < it->term_count; i ++) { - ecs_entity_t subj = ecs_term_source(it, i + 1); - char *str = ecs_get_fullpath(world, subj); - ecs_strbuf_list_appendstr(&buf, str); - ecs_os_free(str); - } - ecs_strbuf_list_pop(&buf, "\n"); + if (!ecs_os_strcmp(token, TOK_IN)) { + *inout_kind_out = EcsIn; + } else + if (!ecs_os_strcmp(token, TOK_OUT)) { + *inout_kind_out = EcsOut; + } else + if (!ecs_os_strcmp(token, TOK_INOUT)) { + *inout_kind_out = EcsInOut; + } else if (!ecs_os_strcmp(token, TOK_INOUT_FILTER)) { + *inout_kind_out = EcsInOutFilter; } - if (it->variable_count) { - int32_t actual_count = 0; - for (i = 0; i < it->variable_count; i ++) { - const char *var_name = it->variable_names[i]; - if (!var_name || var_name[0] == '_' || var_name[0] == '.') { - /* Skip anonymous variables */ - continue; - } + ptr = ecs_parse_whitespace(ptr); - ecs_entity_t var = it->variables[i]; - if (!var) { - /* Skip table variables */ - continue; - } + if (ptr[0] != TOK_BRACKET_CLOSE) { + ecs_parser_error(name, sig, column, "expected ]"); + return NULL; + } - if (!actual_count) { - ecs_strbuf_list_push(&buf, "vars: ", ","); - } + return ptr + 1; +} - char *str = ecs_get_fullpath(world, var); - ecs_strbuf_list_append(&buf, "%s=%s", var_name, str); - ecs_os_free(str); +static +uint8_t parse_set_token( + const char *token) +{ + if (!ecs_os_strcmp(token, TOK_SELF)) { + return EcsSelf; + } else if (!ecs_os_strcmp(token, TOK_SUPERSET)) { + return EcsSuperSet; + } else if (!ecs_os_strcmp(token, TOK_SUBSET)) { + return EcsSubSet; + } else if (!ecs_os_strcmp(token, TOK_CASCADE)) { + return EcsCascade; + } else if (!ecs_os_strcmp(token, TOK_ALL)) { + return EcsAll; + } else if (!ecs_os_strcmp(token, TOK_PARENT)) { + return EcsParent; + } else { + return 0; + } +} - actual_count ++; - } - if (actual_count) { - ecs_strbuf_list_pop(&buf, "\n"); +static +const char* parse_set_expr( + const ecs_world_t *world, + const char *name, + const char *expr, + int64_t column, + const char *ptr, + char *token, + ecs_term_id_t *id, + char tok_end) +{ + char token_buf[ECS_MAX_TOKEN_SIZE] = {0}; + if (!token) { + token = token_buf; + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + return NULL; } } - if (it->count) { - ecs_strbuf_appendstr(&buf, "this:\n"); - for (i = 0; i < it->count; i ++) { - ecs_entity_t e = it->entities[i]; - char *str = ecs_get_fullpath(world, e); - ecs_strbuf_appendstr(&buf, " - "); - ecs_strbuf_appendstr(&buf, str); - ecs_strbuf_appendstr(&buf, "\n"); - ecs_os_free(str); + do { + uint8_t tok = parse_set_token(token); + if (!tok) { + ecs_parser_error(name, expr, column, + "invalid set token '%s'", token); + return NULL; } - } - return ecs_strbuf_get(&buf); -} + if (id->set.mask & tok) { + ecs_parser_error(name, expr, column, + "duplicate set token '%s'", token); + return NULL; + } -void ecs_iter_poly( - const ecs_world_t *world, - const ecs_poly_t *poly, - ecs_iter_t *iter_out, - ecs_term_t *filter) -{ - ecs_iterable_t *iterable = ecs_get_iterable(poly); - iterable->init(world, poly, iter_out, filter); -} + if ((tok == EcsSubSet && id->set.mask & EcsSuperSet) || + (tok == EcsSuperSet && id->set.mask & EcsSubSet)) + { + ecs_parser_error(name, expr, column, + "cannot mix super and sub", token); + return NULL; + } + + id->set.mask |= tok; -bool ecs_iter_next( - ecs_iter_t *iter) -{ - ecs_check(iter != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(iter->next != NULL, ECS_INVALID_PARAMETER, NULL); - return iter->next(iter); -error: - return false; -} + if (ptr[0] == TOK_PAREN_OPEN) { + ptr ++; -bool ecs_iter_count( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - int32_t count = 0; - while (ecs_iter_next(it)) { - count += it->count; - } - return count; -error: - return 0; -} + /* Relationship (overrides IsA default) */ + if (!isdigit(ptr[0]) && valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + return NULL; + } -bool ecs_iter_is_true( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - bool result = ecs_iter_next(it); - if (result) { - ecs_iter_fini(it); - } - return result; -error: - return false; -} + id->set.relation = ecs_lookup_fullpath(world, token); + if (!id->set.relation) { + ecs_parser_error(name, expr, column, + "unresolved identifier '%s'", token); + return NULL; + } -ecs_entity_t ecs_iter_get_var( - ecs_iter_t *it, - int32_t var_id) -{ - ecs_check(var_id < it->variable_count, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->variables != NULL, ECS_INVALID_PARAMETER, NULL); - return it->variables[var_id]; -error: - return 0; -} + if (ptr[0] == TOK_AND) { + ptr = ecs_parse_whitespace(ptr + 1); + } else if (ptr[0] != TOK_PAREN_CLOSE) { + ecs_parser_error(name, expr, column, + "expected ',' or ')'"); + return NULL; + } + } -ecs_iter_t ecs_page_iter( - const ecs_iter_t *it, - int32_t offset, - int32_t limit) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL); + /* Max depth of search */ + if (isdigit(ptr[0])) { + ptr = parse_digit(ptr, token); + if (!ptr) { + return NULL; + } - ecs_iter_t result = *it; - result.priv.iter.page = (ecs_page_iter_t){ - .offset = offset, - .limit = limit, - .remaining = limit - }; - result.next = ecs_page_next; - result.chain_it = (ecs_iter_t*)it; + id->set.max_depth = atoi(token); + if (id->set.max_depth < 0) { + ecs_parser_error(name, expr, column, + "invalid negative depth"); + return NULL; + } - return result; -error: - return (ecs_iter_t){ 0 }; -} + if (ptr[0] == ',') { + ptr = ecs_parse_whitespace(ptr + 1); + } + } -static -void offset_iter( - ecs_iter_t *it, - int32_t offset) -{ - it->entities = &it->entities[offset]; + /* If another digit is found, previous depth was min depth */ + if (isdigit(ptr[0])) { + ptr = parse_digit(ptr, token); + if (!ptr) { + return NULL; + } - int32_t t, term_count = it->term_count; - for (t = 0; t < term_count; t ++) { - void *ptrs = it->ptrs[t]; - if (!ptrs) { - continue; + id->set.min_depth = id->set.max_depth; + id->set.max_depth = atoi(token); + if (id->set.max_depth < 0) { + ecs_parser_error(name, expr, column, + "invalid negative depth"); + return NULL; + } + } + + if (ptr[0] != TOK_PAREN_CLOSE) { + ecs_parser_error(name, expr, column, "expected ')', got '%c'", + ptr[0]); + return NULL; + } else { + ptr = ecs_parse_whitespace(ptr + 1); + if (ptr[0] != tok_end && ptr[0] != TOK_AND && ptr[0] != 0) { + ecs_parser_error(name, expr, column, + "expected end of set expr"); + return NULL; + } + } } - if (it->subjects[t]) { - continue; + /* Next token in set expression */ + if (ptr[0] == TOK_BITWISE_OR) { + ptr ++; + if (valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + return NULL; + } + } + + /* End of set expression */ + } else if (ptr[0] == tok_end || ptr[0] == TOK_AND || !ptr[0]) { + break; } + } while (true); - it->ptrs[t] = ECS_OFFSET(ptrs, offset * it->sizes[t]); + if (id->set.mask & EcsCascade && !(id->set.mask & EcsSuperSet) && + !(id->set.mask & EcsSubSet)) + { + /* If cascade is used without specifying super or sub, assume + * super */ + id->set.mask |= EcsSuperSet; } + + if (id->set.mask & EcsSelf && id->set.min_depth != 0) { + ecs_parser_error(name, expr, column, + "min_depth must be zero for set expression with 'self'"); + return NULL; + } + + return ptr; } static -bool ecs_page_next_instanced( - ecs_iter_t *it) +const char* parse_arguments( + const ecs_world_t *world, + const char *name, + const char *expr, + int64_t column, + const char *ptr, + char *token, + ecs_term_t *term) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL); + (void)column; - ecs_iter_t *chain_it = it->chain_it; - bool instanced = it->is_instanced; + int32_t arg = 0; do { - if (!ecs_iter_next(chain_it)) { - goto done; - } + if (valid_token_start_char(ptr[0])) { + if (arg == 2) { + ecs_parser_error(name, expr, (ptr - expr), + "too many arguments in term"); + return NULL; + } - ecs_page_iter_t *iter = &it->priv.iter.page; - - /* Copy everything up to the private iterator data */ - ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv)); - it->is_instanced = instanced; + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + return NULL; + } - if (!chain_it->table) { - goto yield; /* Task query */ - } + ecs_term_id_t *term_id = NULL; - int32_t offset = iter->offset; - int32_t limit = iter->limit; - if (!(offset || limit)) { - if (it->count) { - goto yield; - } else { - goto done; + if (arg == 0) { + term_id = &term->subj; + } else if (arg == 1) { + term_id = &term->obj; } - } - int32_t count = it->count; - int32_t remaining = iter->remaining; + /* If token is a colon, the token is an identifier followed by a + * set expression. */ + if (ptr[0] == TOK_COLON) { + if (parse_identifier(token, term_id)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + return NULL; + } - if (offset) { - if (offset > count) { - /* No entities to iterate in current table */ - iter->offset -= count; - it->count = 0; - continue; - } else { - it->offset += offset; - count = it->count -= offset; - iter->offset = 0; - offset_iter(it, offset); + ptr = ecs_parse_whitespace(ptr + 1); + ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, + NULL, term_id, TOK_PAREN_CLOSE); + if (!ptr) { + return NULL; + } + + /* If token is a self, super or sub token, this is a set + * expression */ + } else if (!ecs_os_strcmp(token, TOK_ALL) || + !ecs_os_strcmp(token, TOK_CASCADE) || + !ecs_os_strcmp(token, TOK_SELF) || + !ecs_os_strcmp(token, TOK_SUPERSET) || + !ecs_os_strcmp(token, TOK_SUBSET) || + !(ecs_os_strcmp(token, TOK_PARENT))) + { + ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, + token, term_id, TOK_PAREN_CLOSE); + if (!ptr) { + return NULL; + } + + /* Regular identifier */ + } else if (parse_identifier(token, term_id)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + return NULL; } - } - if (remaining) { - if (remaining > count) { - iter->remaining -= count; + if (ptr[0] == TOK_AND) { + ptr = ecs_parse_whitespace(ptr + 1); + + term->role = ECS_PAIR; + + } else if (ptr[0] == TOK_PAREN_CLOSE) { + ptr = ecs_parse_whitespace(ptr + 1); + break; + } else { - it->count = remaining; - iter->remaining = 0; + ecs_parser_error(name, expr, (ptr - expr), + "expected ',' or ')'"); + return NULL; } - } else if (limit) { - /* Limit hit: no more entities left to iterate */ - goto done; + + } else { + ecs_parser_error(name, expr, (ptr - expr), + "expected identifier or set expression"); + return NULL; } - } while (it->count == 0); -yield: - if (!it->is_instanced) { - it->offset = 0; - } + arg ++; - return true; -done: -error: - return false; + } while (true); + + return ptr; } -bool ecs_page_next( - ecs_iter_t *it) +static +void parser_unexpected_char( + const char *name, + const char *expr, + const char *ptr, + char ch) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_page_next, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); - - it->chain_it->is_instanced = true; - - if (flecs_iter_next_row(it)) { - return true; + if (ch && (ch != '\n')) { + ecs_parser_error(name, expr, (ptr - expr), + "unexpected character '%c'", ch); + } else { + ecs_parser_error(name, expr, (ptr - expr), + "unexpected end of term"); } - - return flecs_iter_next_instanced(it, ecs_page_next_instanced(it)); -error: - return false; } -ecs_iter_t ecs_worker_iter( - const ecs_iter_t *it, - int32_t index, - int32_t count) +static +const char* parse_term( + const ecs_world_t *world, + const char *name, + const char *expr, + ecs_term_t *term_out) { - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(count > 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(index >= 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(index < count, ECS_INVALID_PARAMETER, NULL); - - return (ecs_iter_t){ - .real_world = it->real_world, - .world = it->world, - .priv.iter.worker = { - .index = index, - .count = count - }, - .next = ecs_worker_next, - .chain_it = (ecs_iter_t*)it, - .is_instanced = it->is_instanced - }; + const char *ptr = expr; + char token[ECS_MAX_TOKEN_SIZE] = {0}; + ecs_term_t term = { .move = true /* parser never owns resources */ }; -error: - return (ecs_iter_t){ 0 }; -} + ptr = ecs_parse_whitespace(ptr); -static -bool ecs_worker_next_instanced( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL); + /* Inout specifiers always come first */ + if (ptr[0] == TOK_BRACKET_OPEN) { + ptr = parse_annotation(name, expr, (ptr - expr), ptr + 1, &term.inout); + if (!ptr) { + goto error; + } + ptr = ecs_parse_whitespace(ptr); + } - bool instanced = it->is_instanced; + if (valid_operator_char(ptr[0])) { + term.oper = parse_operator(ptr[0]); + ptr = ecs_parse_whitespace(ptr + 1); + } - ecs_iter_t *chain_it = it->chain_it; - ecs_worker_iter_t *iter = &it->priv.iter.worker; - int32_t res_count = iter->count, res_index = iter->index; - int32_t per_worker, instances_per_worker, first; + /* If next token is the start of an identifier, it could be either a type + * role, source or component identifier */ + if (valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + goto error; + } - do { - if (!ecs_iter_next(chain_it)) { - return false; + /* Is token a type role? */ + if (ptr[0] == TOK_BITWISE_OR && ptr[1] != TOK_BITWISE_OR) { + ptr ++; + goto parse_role; } - /* Copy everything up to the private iterator data */ - ecs_os_memcpy(it, chain_it, offsetof(ecs_iter_t, priv)); - it->is_instanced = instanced; + /* Is token a predicate? */ + if (ptr[0] == TOK_PAREN_OPEN) { + goto parse_predicate; + } - int32_t count = it->count; - int32_t instance_count = it->instance_count; - per_worker = count / res_count; - instances_per_worker = instance_count / res_count; - first = per_worker * res_index; - count -= per_worker * res_count; + /* Next token must be a predicate */ + goto parse_predicate; - if (count) { - if (res_index < count) { - per_worker ++; - first += res_index; - } else { - first += count; + /* If next token is a singleton, assign identifier to pred and subject */ + } else if (ptr[0] == TOK_SINGLETON) { + ptr ++; + if (valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + goto error; } - } - if (!per_worker && it->table == NULL) { - if (res_index == 0) { - return true; - } else { - return false; - } - } - } while (!per_worker); + goto parse_singleton; - it->instance_count = instances_per_worker; - it->frame_offset += first; + } else { + ecs_parser_error(name, expr, (ptr - expr), + "expected identifier after singleton operator"); + goto error; + } - offset_iter(it, it->offset + first); - it->count = per_worker; + /* Pair with implicit subject */ + } else if (ptr[0] == TOK_PAREN_OPEN) { + goto parse_pair; - if (it->is_instanced) { - it->offset += first; + /* Nothing else expected here */ } else { - it->offset = 0; + parser_unexpected_char(name, expr, ptr, ptr[0]); + goto error; } - return true; -error: - return false; -} - -bool ecs_worker_next( - ecs_iter_t *it) -{ - ecs_check(it != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->next == ecs_worker_next, ECS_INVALID_PARAMETER, NULL); - ecs_check(it->chain_it != NULL, ECS_INVALID_PARAMETER, NULL); +parse_role: + term.role = parse_role(name, expr, (ptr - expr), token); + if (!term.role) { + goto error; + } - it->chain_it->is_instanced = true; + ptr = ecs_parse_whitespace(ptr); - if (flecs_iter_next_row(it)) { - return true; - } + /* If next token is the source token, this is an empty source */ + if (valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + goto error; + } - return flecs_iter_next_instanced(it, ecs_worker_next_instanced(it)); -error: - return false; -} + /* If not, it's a predicate */ + goto parse_predicate; -#include + } else if (ptr[0] == TOK_PAREN_OPEN) { + goto parse_pair; + } else { + ecs_parser_error(name, expr, (ptr - expr), + "expected identifier after role"); + goto error; + } -static -int32_t count_events( - const ecs_entity_t *events) -{ - int32_t i; +parse_predicate: + if (parse_identifier(token, &term.pred)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + goto error; + } - for (i = 0; i < ECS_TRIGGER_DESC_EVENT_COUNT_MAX; i ++) { - if (!events[i]) { - break; + /* Set expression */ + if (ptr[0] == TOK_COLON) { + ptr = ecs_parse_whitespace(ptr + 1); + ptr = parse_set_expr(world, name, expr, (ptr - expr), ptr, NULL, + &term.pred, TOK_COLON); + if (!ptr) { + goto error; } - } - return i; -} + ptr = ecs_parse_whitespace(ptr); -static -ecs_entity_t get_actual_event( - ecs_trigger_t *trigger, - ecs_entity_t event) -{ - /* If operator is Not, reverse the event */ - if (trigger->term.oper == EcsNot) { - if (event == EcsOnAdd) { - event = EcsOnRemove; - } else if (event == EcsOnRemove) { - event = EcsOnAdd; + if (ptr[0] == TOK_AND || !ptr[0]) { + goto parse_done; } - } - return event; -} + if (ptr[0] != TOK_COLON) { + ecs_parser_error(name, expr, (ptr - expr), + "unexpected token '%c' after predicate set expression", ptr[0]); + goto error; + } -static -void unregister_event_trigger( - ecs_event_record_t *evt, - ecs_id_t id) -{ - if (ecs_map_remove(&evt->event_ids, id) == 0) { - ecs_map_fini(&evt->event_ids); + ptr = ecs_parse_whitespace(ptr + 1); + } else { + ptr = ecs_parse_whitespace(ptr); } -} + + if (ptr[0] == TOK_PAREN_OPEN) { + ptr ++; + if (ptr[0] == TOK_PAREN_CLOSE) { + term.subj.set.mask = EcsNothing; + ptr ++; + ptr = ecs_parse_whitespace(ptr); + } else { + ptr = parse_arguments( + world, name, expr, (ptr - expr), ptr, token, &term); + } -static -ecs_event_id_record_t* ensure_event_id_record( - ecs_map_t *map, - ecs_id_t id) -{ - ecs_event_id_record_t **idt = ecs_map_ensure( - map, ecs_event_id_record_t*, id); - if (!idt[0]) { - idt[0] = ecs_os_calloc_t(ecs_event_id_record_t); + goto parse_done; } - return idt[0]; -} - -static -void inc_trigger_count( - ecs_world_t *world, - ecs_entity_t event, - ecs_event_record_t *evt, - ecs_id_t id, - int32_t value) -{ - ecs_event_id_record_t *idt = ensure_event_id_record(&evt->event_ids, id); - ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); - - int32_t result = idt->trigger_count += value; - if (result == 1) { - /* Notify framework that there are triggers for the event/id. This - * allows parts of the code to skip event evaluation early */ - flecs_notify_tables(world, id, &(ecs_table_event_t){ - .kind = EcsTableTriggersForId, - .event = event - }); - } else if (result == 0) { - /* Ditto, but the reverse */ - flecs_notify_tables(world, id, &(ecs_table_event_t){ - .kind = EcsTableNoTriggersForId, - .event = event - }); + goto parse_done; - /* Remove admin for id for event */ - if (!ecs_map_is_initialized(&idt->triggers) && - !ecs_map_is_initialized(&idt->set_triggers)) - { - unregister_event_trigger(evt, id); - ecs_os_free(idt); - } +parse_pair: + ptr = ecs_parse_identifier(name, expr, ptr + 1, token); + if (!ptr) { + goto error; } -} - -static -void register_trigger_for_id( - ecs_world_t *world, - ecs_observable_t *observable, - ecs_trigger_t *trigger, - ecs_id_t id, - size_t triggers_offset) -{ - ecs_sparse_t *events = observable->events; - ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_id_t term_id = trigger->term.id; - int i; - for (i = 0; i < trigger->event_count; i ++) { - ecs_entity_t event = get_actual_event(trigger, trigger->events[i]); + if (ptr[0] == TOK_AND) { + ptr ++; + term.subj.entity = EcsThis; + goto parse_pair_predicate; + } else if (ptr[0] == TOK_PAREN_CLOSE) { + term.subj.entity = EcsThis; + goto parse_pair_predicate; + } else { + parser_unexpected_char(name, expr, ptr, ptr[0]); + goto error; + } - /* Get triggers for event */ - ecs_event_record_t *evt = flecs_sparse_ensure( - events, ecs_event_record_t, event); - ecs_assert(evt != NULL, ECS_INTERNAL_ERROR, NULL); +parse_pair_predicate: + if (parse_identifier(token, &term.pred)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + goto error; + } - if (!ecs_map_is_initialized(&evt->event_ids)) { - ecs_map_init(&evt->event_ids, ecs_event_id_record_t*, 1); + ptr = ecs_parse_whitespace(ptr); + if (valid_token_start_char(ptr[0])) { + ptr = ecs_parse_identifier(name, expr, ptr, token); + if (!ptr) { + goto error; } - /* Get triggers for (component) id for event */ - ecs_event_id_record_t *idt = ensure_event_id_record( - &evt->event_ids, id); - ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); - - ecs_map_t *triggers = ECS_OFFSET(idt, triggers_offset); - if (!ecs_map_is_initialized(triggers)) { - ecs_map_init(triggers, ecs_trigger_t*, 1); + if (ptr[0] == TOK_PAREN_CLOSE) { + ptr ++; + goto parse_pair_object; + } else { + parser_unexpected_char(name, expr, ptr, ptr[0]); + goto error; } + } else if (ptr[0] == TOK_PAREN_CLOSE) { + /* No object */ + ptr ++; + goto parse_done; + } else { + ecs_parser_error(name, expr, (ptr - expr), + "expected pair object or ')'"); + goto error; + } - ecs_map_ensure(triggers, ecs_trigger_t*, trigger->id)[0] = trigger; +parse_pair_object: + if (parse_identifier(token, &term.obj)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + goto error; + } - inc_trigger_count(world, event, evt, term_id, 1); - if (term_id != id) { - inc_trigger_count(world, event, evt, id, 1); + if (term.role != 0) { + if (term.role != ECS_PAIR && term.role != ECS_CASE) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid combination of role '%s' with pair", + ecs_role_str(term.role)); + goto error; } + } else { + term.role = ECS_PAIR; } -} -static -void register_trigger( - ecs_world_t *world, - ecs_observable_t *observable, - ecs_trigger_t *trigger) -{ - ecs_term_t *term = &trigger->term; + ptr = ecs_parse_whitespace(ptr); + goto parse_done; - if (term->subj.set.mask & EcsSelf) { - if (term->subj.entity == EcsThis) { - register_trigger_for_id(world, observable, trigger, term->id, - offsetof(ecs_event_id_record_t, triggers)); - } else { - register_trigger_for_id(world, observable, trigger, term->id, - offsetof(ecs_event_id_record_t, entity_triggers)); - } +parse_singleton: + if (parse_identifier(token, &term.pred)) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid identifier '%s'", token); + goto error; } - if (trigger->term.subj.set.mask & EcsSuperSet) { - ecs_id_t pair = ecs_pair(term->subj.set.relation, EcsWildcard); - register_trigger_for_id(world, observable, trigger, pair, - offsetof(ecs_event_id_record_t, set_triggers)); - } + parse_identifier(token, &term.subj); + goto parse_done; - if (ECS_HAS_ROLE(term->id, SWITCH)) { - ecs_entity_t sw = term->id & ECS_COMPONENT_MASK; - ecs_id_t sw_case = ecs_case(sw, EcsWildcard); - register_trigger_for_id(world, observable, trigger, sw_case, - offsetof(ecs_event_id_record_t, triggers)); - } +parse_done: + *term_out = term; + return ptr; - if (ECS_HAS_ROLE(term->id, CASE)) { - ecs_entity_t sw = ECS_PAIR_FIRST(term->id); - register_trigger_for_id(world, observable, trigger, ECS_SWITCH | sw, - offsetof(ecs_event_id_record_t, triggers)); - } +error: + ecs_term_fini(&term); + *term_out = (ecs_term_t){0}; + return NULL; } static -void unregister_trigger_for_id( - ecs_world_t *world, - ecs_observable_t *observable, - ecs_trigger_t *trigger, - ecs_id_t id, - size_t triggers_offset) +bool is_valid_end_of_term( + const char *ptr) { - ecs_sparse_t *events = observable->events; - ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_id_t term_id = trigger->term.id; - - int i; - for (i = 0; i < trigger->event_count; i ++) { - ecs_entity_t event = get_actual_event(trigger, trigger->events[i]); - - /* Get triggers for event */ - ecs_event_record_t *evt = flecs_sparse_get( - events, ecs_event_record_t, event); - ecs_assert(evt != NULL, ECS_INTERNAL_ERROR, NULL); + if ((ptr[0] == TOK_AND) || /* another term with And operator */ + (ptr[0] == TOK_OR[0]) || /* another term with Or operator */ + (ptr[0] == '\n') || /* newlines are valid */ + (ptr[0] == '\0') || /* end of string */ + (ptr[0] == '/') || /* comment (in plecs) */ + (ptr[0] == '{') || /* scope (in plecs) */ + (ptr[0] == '}') || + (ptr[0] == ':') || /* inheritance (in plecs) */ + (ptr[0] == '=')) /* assignment (in plecs) */ + { + return true; + } + return false; +} - /* Get triggers for (component) id */ - ecs_event_id_record_t *idt = ecs_map_get_ptr( - &evt->event_ids, ecs_event_id_record_t*, id); - ecs_assert(idt != NULL, ECS_INTERNAL_ERROR, NULL); +char* ecs_parse_term( + const ecs_world_t *world, + const char *name, + const char *expr, + const char *ptr, + ecs_term_t *term) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(ptr != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(term != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_map_t *id_triggers = ECS_OFFSET(idt, triggers_offset); + ecs_term_id_t *subj = &term->subj; - if (ecs_map_remove(id_triggers, trigger->id) == 0) { - ecs_map_fini(id_triggers); + bool prev_or = false; + if (ptr != expr) { + if (ptr[0]) { + if (ptr[0] == ',') { + ptr ++; + } else if (ptr[0] == '|') { + ptr += 2; + prev_or = true; + } else { + ecs_parser_error(name, expr, (ptr - expr), + "invalid preceding token"); + } } + } + + ptr = ecs_parse_eol_and_whitespace(ptr); + if (!ptr[0]) { + *term = (ecs_term_t){0}; + return (char*)ptr; + } - inc_trigger_count(world, event, evt, term_id, -1); + if (ptr == expr && !strcmp(expr, "0")) { + return (char*)&ptr[1]; + } - if (id != term_id) { - /* Id is different from term_id in case of a set trigger. If they're - * the same, inc_trigger_count could already have done cleanup */ - if (!ecs_map_is_initialized(&idt->triggers) && - !ecs_map_is_initialized(&idt->set_triggers) && - !idt->trigger_count) - { - unregister_event_trigger(evt, id); - } + int32_t prev_set = subj->set.mask; - inc_trigger_count(world, event, evt, id, -1); - } + /* Parse next element */ + ptr = parse_term(world, name, ptr, term); + if (!ptr) { + goto error; } -} -static -void unregister_trigger( - ecs_world_t *world, - ecs_observable_t *observable, - ecs_trigger_t *trigger) -{ - ecs_term_t *term = &trigger->term; + /* Post-parse consistency checks */ - if (term->subj.set.mask & EcsSelf) { - if (term->subj.entity == EcsThis) { - unregister_trigger_for_id(world, observable, trigger, term->id, - offsetof(ecs_event_id_record_t, triggers)); - } else { - unregister_trigger_for_id(world, observable, trigger, term->id, - offsetof(ecs_event_id_record_t, entity_triggers)); + /* If next token is OR, term is part of an OR expression */ + if (!ecs_os_strncmp(ptr, TOK_OR, 2) || prev_or) { + /* An OR operator must always follow an AND or another OR */ + if (term->oper != EcsAnd) { + ecs_parser_error(name, expr, (ptr - expr), + "cannot combine || with other operators"); + goto error; } - } - - if (term->subj.set.mask & EcsSuperSet) { - ecs_id_t pair = ecs_pair(term->subj.set.relation, EcsWildcard); - unregister_trigger_for_id(world, observable, trigger, pair, - offsetof(ecs_event_id_record_t, set_triggers)); - } - if (ECS_HAS_ROLE(term->id, SWITCH)) { - ecs_entity_t sw = term->id & ECS_COMPONENT_MASK; - ecs_id_t sw_case = ecs_case(sw, EcsWildcard); - unregister_trigger_for_id(world, observable, trigger, sw_case, - offsetof(ecs_event_id_record_t, triggers)); + term->oper = EcsOr; } - if (ECS_HAS_ROLE(term->id, CASE)) { - ecs_entity_t sw = ECS_PAIR_FIRST(term->id); - unregister_trigger_for_id(world, observable, trigger, ECS_SWITCH | sw, - offsetof(ecs_event_id_record_t, triggers)); + /* Term must either end in end of expression, AND or OR token */ + if (!is_valid_end_of_term(ptr)) { + ecs_parser_error(name, expr, (ptr - expr), + "expected end of expression or next term"); + goto error; } -} -static -ecs_map_t* get_triggers_for_event( - const ecs_observable_t *observable, - ecs_entity_t event) -{ - ecs_check(observable != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_assert(event != 0, ECS_INTERNAL_ERROR, NULL); + /* If the term just contained a 0, the expression has nothing. Ensure + * that after the 0 nothing else follows */ + if (!ecs_os_strcmp(term->pred.name, "0")) { + if (ptr[0]) { + ecs_parser_error(name, expr, (ptr - expr), + "unexpected term after 0"); + goto error; + } - ecs_sparse_t *events = observable->events; - ecs_assert(events != NULL, ECS_INTERNAL_ERROR, NULL); + if (subj->set.mask != EcsDefaultSet || + (subj->entity && subj->entity != EcsThis) || + (subj->name && ecs_os_strcmp(subj->name, "This"))) + { + ecs_parser_error(name, expr, (ptr - expr), + "invalid combination of 0 with non-default subject"); + goto error; + } - const ecs_event_record_t *evt = flecs_sparse_get( - events, ecs_event_record_t, event); - - if (evt) { - return (ecs_map_t*)&evt->event_ids; + subj->set.mask = EcsNothing; + ecs_os_free(term->pred.name); + term->pred.name = NULL; } -error: - return NULL; -} - -static -ecs_event_id_record_t* get_triggers_for_id( - const ecs_map_t *evt, - ecs_id_t id) -{ - return ecs_map_get_ptr(evt, ecs_event_id_record_t*, id); -} - -bool flecs_check_triggers_for_event( - const ecs_poly_t *object, - ecs_id_t id, - ecs_entity_t event) -{ - ecs_observable_t *observable = ecs_get_observable(object); - const ecs_map_t *evt = get_triggers_for_event(observable, event); - if (!evt) { - return false; + /* Cannot combine EcsNothing with operators other than AND */ + if (term->oper != EcsAnd && subj->set.mask == EcsNothing) { + ecs_parser_error(name, expr, (ptr - expr), + "invalid operator for empty source"); + goto error; } - ecs_event_id_record_t *edr = get_triggers_for_id(evt, id); - if (edr) { - return edr->trigger_count != 0; - } else { - return false; + /* Verify consistency of OR expression */ + if (prev_or && term->oper == EcsOr) { + /* Set expressions must be the same for all OR terms */ + if (subj->set.mask != prev_set) { + ecs_parser_error(name, expr, (ptr - expr), + "cannot combine different sources in OR expression"); + goto error; + } + + term->oper = EcsOr; } -} -static -void init_iter( - ecs_iter_t *it, - bool *iter_set) -{ - ecs_assert(it != NULL, ECS_INTERNAL_ERROR, NULL); - - if (*iter_set) { - return; + /* Automatically assign This if entity is not assigned and the set is + * nothing */ + if (subj->set.mask != EcsNothing) { + if (!subj->name) { + if (!subj->entity) { + subj->entity = EcsThis; + } + } } - if (it->table_only) { - it->ids = it->priv.cache.ids; - it->ids[0] = it->event_id; - return; + if (subj->name && !ecs_os_strcmp(subj->name, "0")) { + subj->entity = 0; + subj->set.mask = EcsNothing; } - flecs_iter_init(it); + /* Process role */ + if (term->role == ECS_AND) { + term->oper = EcsAndFrom; + term->role = 0; + } else if (term->role == ECS_OR) { + term->oper = EcsOrFrom; + term->role = 0; + } else if (term->role == ECS_NOT) { + term->oper = EcsNotFrom; + term->role = 0; + } - *iter_set = true; + ptr = ecs_parse_whitespace(ptr); - it->ids[0] = it->event_id; + return (char*)ptr; +error: + if (term) { + ecs_term_fini(term); + } + return NULL; +} - ecs_assert(it->table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(!it->count || it->offset < ecs_table_count(it->table), - ECS_INTERNAL_ERROR, NULL); - ecs_assert((it->offset + it->count) <= ecs_table_count(it->table), - ECS_INTERNAL_ERROR, NULL); +#endif - int32_t index = ecs_search_relation(it->world, it->table, 0, - it->event_id, EcsIsA, 0, 0, it->subjects, NULL, NULL); - - if (index == -1) { - it->columns[0] = 0; - } else if (it->subjects[0]) { - it->columns[0] = -index - 1; - } else { - it->columns[0] = index + 1; - } - ecs_term_t term = { - .id = it->event_id - }; +#ifdef FLECS_SYSTEM - it->term_count = 1; - it->terms = &term; - flecs_iter_populate_data(it->world, it, it->table, it->offset, - it->count, it->ptrs, it->sizes); -} static -bool ignore_trigger( +void invoke_status_action( ecs_world_t *world, - ecs_trigger_t *t, - ecs_table_t *table) + ecs_entity_t system, + const EcsSystem *system_data, + ecs_system_status_t status) { - int32_t *last_event_id = t->last_event_id; - if (last_event_id && last_event_id[0] == world->event_id) { - return true; - } - - if (!table) { - return false; - } - - if (!t->match_prefab && (table->flags & EcsTableIsPrefab)) { - return true; - } - if (!t->match_disabled && (table->flags & EcsTableIsDisabled)) { - return true; + ecs_system_status_action_t action = system_data->status_action; + if (action) { + action(world, system, status, system_data->status_ctx); } - - return false; } -static -void notify_self_triggers( +/* Invoked when system becomes active or inactive */ +void ecs_system_activate( ecs_world_t *world, - ecs_iter_t *it, - const ecs_map_t *triggers) + ecs_entity_t system, + bool activate, + const EcsSystem *system_data) { - ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); - ecs_map_iter_t mit = ecs_map_iter(triggers); - ecs_trigger_t *t; - while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { - if (ignore_trigger(world, t, it->table)) { - continue; - } + if (activate) { + /* If activating system, ensure that it doesn't have the Inactive tag. + * Systems are implicitly activated so they are kept out of the main + * loop as long as they aren't used. They are not implicitly deactivated + * to prevent overhead in case of oscillating app behavior. + * After activation, systems that aren't matched with anything can be + * deactivated again by explicitly calling ecs_deactivate_systems. + */ + ecs_remove_id(world, system, EcsInactive); + } - it->is_filter = t->term.inout == EcsInOutFilter; - it->system = t->entity; - it->self = t->self; - it->ctx = t->ctx; - it->binding_ctx = t->binding_ctx; - it->term_index = t->term.index; - it->terms = &t->term; + if (!system_data) { + system_data = ecs_get(world, system, EcsSystem); + } + if (!system_data || !system_data->query) { + return; + } - t->callback(it); + if (!activate) { + if (ecs_has_id(world, system, EcsDisabled)) { + if (!ecs_query_table_count(system_data->query)) { + /* If deactivating a disabled system that isn't matched with + * any active tables, there is nothing to deactivate. */ + return; + } + } } + + /* Invoke system status action */ + invoke_status_action(world, system, system_data, + activate ? EcsSystemActivated : EcsSystemDeactivated); + + ecs_dbg_1("#[green]system#[reset] %s %s", + ecs_get_name(world, system), + activate ? "activated" : "deactivated"); } +/* Actually enable or disable system */ static -void notify_entity_triggers( +void ecs_enable_system( ecs_world_t *world, - ecs_iter_t *it, - const ecs_map_t *triggers) + ecs_entity_t system, + EcsSystem *system_data, + bool enabled) { - ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_poly_assert(world, ecs_world_t); + ecs_assert(!world->is_readonly, ECS_INTERNAL_ERROR, NULL); - if (it->table_only) { + ecs_query_t *query = system_data->query; + if (!query) { return; } - ecs_map_iter_t mit = ecs_map_iter(triggers); - ecs_trigger_t *t; - int32_t offset = it->offset, count = it->count; - ecs_entity_t *entities = it->entities; - - ecs_entity_t dummy = 0; - it->entities = &dummy; - - while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { - if (ignore_trigger(world, t, it->table)) { - continue; - } - - int32_t i, entity_count = it->count; - for (i = 0; i < entity_count; i ++) { - if (entities[i] != t->term.subj.entity) { - continue; - } - - it->is_filter = t->term.inout == EcsInOutFilter; - it->system = t->entity; - it->self = t->self; - it->ctx = t->ctx; - it->binding_ctx = t->binding_ctx; - it->term_index = t->term.index; - it->terms = &t->term; - it->offset = i; - it->count = 1; - it->subjects[0] = entities[i]; - - t->callback(it); - } + if (ecs_query_table_count(query)) { + /* Only (de)activate system if it has non-empty tables. */ + ecs_system_activate(world, system, enabled, system_data); + system_data = ecs_get_mut(world, system, EcsSystem, NULL); } - - it->offset = offset; - it->count = count; - it->entities = entities; - it->subjects[0] = 0; + + /* Invoke action for enable/disable status */ + invoke_status_action( + world, system, system_data, + enabled ? EcsSystemEnabled : EcsSystemDisabled); } -static -void notify_set_base_triggers( +/* -- Public API -- */ + +ecs_entity_t ecs_run_intern( ecs_world_t *world, - ecs_iter_t *it, - const ecs_map_t *triggers) + ecs_stage_t *stage, + ecs_entity_t system, + EcsSystem *system_data, + int32_t stage_current, + int32_t stage_count, + FLECS_FLOAT delta_time, + int32_t offset, + int32_t limit, + void *param) { - ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); + FLECS_FLOAT time_elapsed = delta_time; + ecs_entity_t tick_source = system_data->tick_source; - ecs_entity_t event_id = it->event_id; - ecs_entity_t rel = ECS_PAIR_FIRST(event_id); - ecs_entity_t obj = ecs_pair_second(world, event_id); - ecs_assert(obj != 0, ECS_INTERNAL_ERROR, NULL); - ecs_table_t *obj_table = ecs_get_table(world, obj); - if (!obj_table) { - return; + /* Support legacy behavior */ + if (!param) { + param = system_data->ctx; } - ecs_map_iter_t mit = ecs_map_iter(triggers); - ecs_trigger_t *t; - while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { - if (ignore_trigger(world, t, it->table)) { - continue; - } - - ecs_term_t *term = &t->term; - ecs_id_t id = term->id; - int32_t column = ecs_search_relation(world, obj_table, 0, id, rel, - 0, 0, it->subjects, it->ids, 0); - - bool result = column != -1; - if (term->oper == EcsNot) { - result = !result; - } - if (!result) { - continue; - } - - if (!term->subj.set.min_depth && flecs_get_table_record( - world, it->table, id) != NULL) - { - continue; - } + if (tick_source) { + const EcsTickSource *tick = ecs_get( + world, tick_source, EcsTickSource); - if (!it->table_only) { - if (!it->subjects[0]) { - it->subjects[0] = obj; - } + if (tick) { + time_elapsed = tick->time_elapsed; - if (column != -1) { - it->columns[0] = -(column + 1); - } else { - it->columns[0] = 0; + /* If timer hasn't fired we shouldn't run the system */ + if (!tick->tick) { + return 0; } + } else { + /* If a timer has been set but the timer entity does not have the + * EcsTimer component, don't run the system. This can be the result + * of a single-shot timer that has fired already. Not resetting the + * timer field of the system will ensure that the system won't be + * ran after the timer has fired. */ + return 0; } - - it->is_filter = t->term.inout == EcsInOutFilter; - it->event_id = t->term.id; - it->system = t->entity; - it->self = t->self; - it->ctx = t->ctx; - it->binding_ctx = t->binding_ctx; - it->term_index = t->term.index; - it->terms = &t->term; - - t->callback(it); } -} - -static -void notify_set_triggers( - ecs_world_t *world, - ecs_iter_t *it, - const ecs_map_t *triggers) -{ - ecs_assert(triggers != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_assert(it->count != 0, ECS_INTERNAL_ERROR, NULL); - if (it->table_only) { - return; + ecs_time_t time_start; + bool measure_time = world->measure_system_time; + if (measure_time) { + ecs_os_get_time(&time_start); } - ecs_map_iter_t mit = ecs_map_iter(triggers); - ecs_trigger_t *t; - while ((t = ecs_map_next_ptr(&mit, ecs_trigger_t*, NULL))) { - if (!ecs_id_match(it->event_id, t->term.id)) { - continue; - } + ecs_world_t *thread_ctx = world; + if (stage) { + thread_ctx = stage->thread_ctx; + } - if (ignore_trigger(world, t, it->table)) { - continue; - } + ecs_defer_begin(thread_ctx); - ecs_entity_t subj = it->entities[0]; - int32_t i, count = it->count; - ecs_entity_t term_subj = t->term.subj.entity; + /* Prepare the query iterator */ + ecs_iter_t pit, wit, qit = ecs_query_iter(thread_ctx, system_data->query); + ecs_iter_t *it = &qit; - /* If trigger is for a specific entity, make sure it is in the table - * being triggered for */ - if (term_subj != EcsThis) { - for (i = 0; i < count; i ++) { - if (it->entities[i] == term_subj) { - break; - } - } + if (offset || limit) { + pit = ecs_page_iter(it, offset, limit); + it = &pit; + } - if (i == count) { - continue; - } + if (stage_count > 1 && system_data->multi_threaded) { + wit = ecs_worker_iter(it, stage_current, stage_count); + it = &wit; + } - /* If the entity matches, trigger for no other entities */ - it->entities[0] = 0; - it->count = 1; - } + qit.system = system; + qit.self = system_data->self; + qit.delta_time = delta_time; + qit.delta_system_time = time_elapsed; + qit.frame_offset = offset; + qit.param = param; + qit.ctx = system_data->ctx; + qit.binding_ctx = system_data->binding_ctx; - if (flecs_term_match_table(world, &t->term, it->table, it->type, - it->ids, it->columns, it->subjects, NULL, true)) - { - if (!it->subjects[0]) { - /* Do not match owned components */ - continue; + ecs_iter_action_t action = system_data->action; + it->callback = action; + + ecs_run_action_t run = system_data->run; + if (run) { + run(it); + } else { + if (it == &qit) { + while (ecs_query_next(&qit)) { + action(&qit); } - - it->is_filter = t->term.inout == EcsInOutFilter; - it->system = t->entity; - it->self = t->self; - it->ctx = t->ctx; - it->binding_ctx = t->binding_ctx; - it->term_index = t->term.index; - it->terms = &t->term; - - /* Triggers for supersets can be instanced */ - if (it->count == 1 || t->instanced || it->is_filter || !it->sizes[0]) { - it->is_instanced = t->instanced; - t->callback(it); - it->is_instanced = false; - } else { - ecs_entity_t *entities = it->entities; - it->count = 1; - for (i = 0; i < count; i ++) { - it->entities = &entities[i]; - t->callback(it); - } - it->entities = entities; + } else { + while (ecs_iter_next(it)) { + action(it); } } - - it->entities[0] = subj; - it->count = count; } -} -static -void notify_triggers_for_id( - ecs_world_t *world, - const ecs_map_t *evt, - ecs_id_t event_id, - ecs_iter_t *it, - bool *iter_set) -{ - const ecs_event_id_record_t *idt = get_triggers_for_id(evt, event_id); - if (!idt) { - return; + if (measure_time) { + system_data->time_spent += (float)ecs_time_measure(&time_start); } - if (ecs_map_is_initialized(&idt->triggers)) { - init_iter(it, iter_set); - notify_self_triggers(world, it, &idt->triggers); - } - if (ecs_map_is_initialized(&idt->entity_triggers)) { - init_iter(it, iter_set); - notify_entity_triggers(world, it, &idt->entity_triggers); - } - if (ecs_map_is_initialized(&idt->set_triggers)) { - init_iter(it, iter_set); - notify_set_base_triggers(world, it, &idt->set_triggers); - } + system_data->invoke_count ++; + + ecs_defer_end(thread_ctx); + + return it->interrupted_by; } -static -void notify_set_triggers_for_id( +/* -- Public API -- */ + +ecs_entity_t ecs_run_w_filter( ecs_world_t *world, - const ecs_map_t *evt, - ecs_iter_t *it, - bool *iter_set, - ecs_id_t set_id) + ecs_entity_t system, + FLECS_FLOAT delta_time, + int32_t offset, + int32_t limit, + void *param) { - const ecs_event_id_record_t *idt = get_triggers_for_id(evt, set_id); - if (idt && ecs_map_is_initialized(&idt->set_triggers)) { - init_iter(it, iter_set); - notify_set_triggers(world, it, &idt->set_triggers); - } + ecs_stage_t *stage = flecs_stage_from_world(&world); + + EcsSystem *system_data = (EcsSystem*)ecs_get( + world, system, EcsSystem); + assert(system_data != NULL); + + return ecs_run_intern(world, stage, system, system_data, 0, 0, delta_time, + offset, limit, param); } -static -void trigger_yield_existing( +ecs_entity_t ecs_run_worker( ecs_world_t *world, - ecs_trigger_t *trigger) + ecs_entity_t system, + int32_t stage_current, + int32_t stage_count, + FLECS_FLOAT delta_time, + void *param) { - ecs_iter_action_t callback = trigger->callback; + ecs_stage_t *stage = flecs_stage_from_world(&world); - /* If yield existing is enabled, trigger for each thing that matches - * the event, if the event is iterable. */ - int i, count = trigger->event_count; - for (i = 0; i < count; i ++) { - ecs_entity_t evt = trigger->events[i]; - const EcsIterable *iterable = ecs_get(world, evt, EcsIterable); - if (!iterable) { - continue; - } + EcsSystem *system_data = (EcsSystem*)ecs_get( + world, system, EcsSystem); + assert(system_data != NULL); - ecs_iter_t it; - iterable->init(world, world, &it, &trigger->term); - it.system = trigger->entity; - it.ctx = trigger->ctx; - it.binding_ctx = trigger->binding_ctx; - it.event = evt; + return ecs_run_intern( + world, stage, system, system_data, stage_current, stage_count, + delta_time, 0, 0, param); +} + +ecs_entity_t ecs_run( + ecs_world_t *world, + ecs_entity_t system, + FLECS_FLOAT delta_time, + void *param) +{ + return ecs_run_w_filter(world, system, delta_time, 0, 0, param); +} - ecs_iter_next_action_t next = it.next; - ecs_assert(next != NULL, ECS_INTERNAL_ERROR, NULL); - while (next(&it)) { - it.event_id = it.ids[0]; - callback(&it); +ecs_query_t* ecs_system_get_query( + const ecs_world_t *world, + ecs_entity_t system) +{ + const EcsQuery *q = ecs_get(world, system, EcsQuery); + if (q) { + return q->query; + } else { + const EcsSystem *s = ecs_get(world, system, EcsSystem); + if (s) { + return s->query; + } else { + return NULL; } } } -void flecs_triggers_notify( - ecs_iter_t *it, - ecs_observable_t *observable, - ecs_ids_t *ids, - ecs_entity_t event) +void* ecs_get_system_ctx( + const ecs_world_t *world, + ecs_entity_t system) { - ecs_assert(ids != NULL && ids->count != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ids->array != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t events[2] = {event, EcsWildcard}; - int32_t e, i, ids_count = ids->count; - ecs_id_t *ids_array = ids->array; - ecs_world_t *world = it->real_world; + const EcsSystem *s = ecs_get(world, system, EcsSystem); + if (s) { + return s->ctx; + } else { + return NULL; + } +} - for (e = 0; e < 2; e ++) { - event = events[e]; - const ecs_map_t *evt = get_triggers_for_event(observable, event); - if (!evt) { - continue; - } +void* ecs_get_system_binding_ctx( + const ecs_world_t *world, + ecs_entity_t system) +{ + const EcsSystem *s = ecs_get(world, system, EcsSystem); + if (s) { + return s->binding_ctx; + } else { + return NULL; + } +} - it->event = event; +/* System destructor */ +static +ECS_DTOR(EcsSystem, ptr, { + if (!ecs_is_alive(world, entity)) { + /* This can happen when a set is deferred while a system is being + * cleaned up. The operation will be discarded, but the destructor + * still needs to be invoked for the value */ + continue; + } - for (i = 0; i < ids_count; i ++) { - ecs_id_t id = ids_array[i]; - ecs_entity_t role = id & ECS_ROLE_MASK; - bool iter_set = false; + /* Invoke Deactivated action for active systems */ + if (ptr->query && ecs_query_table_count(ptr->query)) { + invoke_status_action(world, entity, ptr, EcsSystemDeactivated); + } - it->event_id = id; + /* Invoke Disabled action for enabled systems */ + if (!ecs_has_id(world, entity, EcsDisabled)) { + invoke_status_action(world, entity, ptr, EcsSystemDisabled); + } - notify_triggers_for_id(world, evt, id, it, &iter_set); + if (ptr->ctx_free) { + ptr->ctx_free(ptr->ctx); + } - if (role == ECS_PAIR || role == ECS_CASE) { - ecs_entity_t pred = ECS_PAIR_FIRST(id); - ecs_entity_t obj = ECS_PAIR_SECOND(id); + if (ptr->status_ctx_free) { + ptr->status_ctx_free(ptr->status_ctx); + } - ecs_id_t tid = role | ecs_entity_t_comb(EcsWildcard, pred); - notify_triggers_for_id(world, evt, tid, it, &iter_set); + if (ptr->binding_ctx_free) { + ptr->binding_ctx_free(ptr->binding_ctx); + } - tid = role | ecs_entity_t_comb(obj, EcsWildcard); - notify_triggers_for_id(world, evt, tid, it, &iter_set); - - tid = role | ecs_entity_t_comb(EcsWildcard, EcsWildcard); - notify_triggers_for_id(world, evt, tid, it, &iter_set); - } else { - notify_triggers_for_id(world, evt, EcsWildcard, it, &iter_set); - } - } + if (ptr->query) { + ecs_query_fini(ptr->query); } -} +}) -void flecs_set_triggers_notify( - ecs_iter_t *it, - ecs_observable_t *observable, - ecs_ids_t *ids, - ecs_entity_t event, - ecs_id_t set_id) +static +void EnableMonitor( + ecs_iter_t *it) { - ecs_assert(ids != NULL && ids->count != 0, ECS_INTERNAL_ERROR, NULL); - ecs_assert(ids->array != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t events[2] = {event, EcsWildcard}; - int32_t e, i, ids_count = ids->count; - ecs_id_t *ids_array = ids->array; - ecs_world_t *world = it->real_world; - - for (e = 0; e < 2; e ++) { - event = events[e]; - const ecs_map_t *evt = get_triggers_for_event(observable, event); - if (!evt) { - continue; - } - - it->event = event; - - for (i = 0; i < ids_count; i ++) { - ecs_id_t id = ids_array[i]; - bool iter_set = false; + if (ecs_is_fini(it->world)) { + return; + } - it->event_id = id; + EcsSystem *sys = ecs_term(it, EcsSystem, 1); - notify_set_triggers_for_id(world, evt, it, &iter_set, set_id); + int32_t i; + for (i = 0; i < it->count; i ++) { + if (it->event == EcsOnAdd) { + ecs_enable_system(it->world, it->entities[i], &sys[i], true); + } else if (it->event == EcsOnRemove) { + ecs_enable_system(it->world, it->entities[i], &sys[i], false); } } } -ecs_entity_t ecs_trigger_init( +ecs_entity_t ecs_system_init( ecs_world_t *world, - const ecs_trigger_desc_t *desc) + const ecs_system_desc_t *desc) { - char *name = NULL; - ecs_poly_assert(world, ecs_world_t); - ecs_check(!world->is_readonly, ECS_INVALID_OPERATION, NULL); ecs_check(desc != NULL, ECS_INVALID_PARAMETER, NULL); ecs_check(desc->_canary == 0, ECS_INVALID_PARAMETER, NULL); - ecs_check(!world->is_fini, ECS_INVALID_OPERATION, NULL); - - const char *expr = desc->expr; - ecs_trigger_t *trigger = NULL; - - ecs_observable_t *observable = desc->observable; - if (!observable) { - observable = ecs_get_observable(world); - } + ecs_check(!world->is_readonly, ECS_INVALID_WHILE_ITERATING, NULL); - /* If entity is provided, create it */ ecs_entity_t existing = desc->entity.entity; - ecs_entity_t entity = ecs_entity_init(world, &desc->entity); - if (!existing && !desc->entity.name) { - ecs_add_pair(world, entity, EcsChildOf, EcsFlecsHidden); + ecs_entity_t result = ecs_entity_init(world, &desc->entity); + if (!result) { + return 0; } bool added = false; - EcsTrigger *comp = ecs_get_mut(world, entity, EcsTrigger, &added); + EcsSystem *system = ecs_get_mut(world, result, EcsSystem, &added); if (added) { ecs_check(desc->callback != NULL, ECS_INVALID_PARAMETER, NULL); - - /* Something went wrong with the construction of the entity */ - ecs_check(entity != 0, ECS_INVALID_PARAMETER, NULL); - name = ecs_get_fullpath(world, entity); - ecs_term_t term; - if (expr) { - #ifdef FLECS_PARSER - const char *ptr = ecs_parse_term(world, name, expr, expr, &term); - if (!ptr) { - goto error; - } + memset(system, 0, sizeof(EcsSystem)); - if (!ecs_term_is_initialized(&term)) { - ecs_parser_error( - name, expr, 0, "invalid empty trigger expression"); - goto error; - } + ecs_query_desc_t query_desc = desc->query; + query_desc.filter.name = desc->entity.name; + query_desc.system = result; - if (ptr[0]) { - ecs_parser_error(name, expr, 0, - "too many terms in trigger expression (expected 1)"); - goto error; - } - #else - ecs_abort(ECS_UNSUPPORTED, "parser addon is not available"); - #endif - } else { - term = ecs_term_copy(&desc->term); + ecs_query_t *query = ecs_query_init(world, &query_desc); + if (!query) { + ecs_delete(world, result); + return 0; } - if (ecs_term_finalize(world, name, &term)) { - ecs_term_fini(&term); - goto error; - } + /* Re-obtain pointer, as query may have added components */ + system = ecs_get_mut(world, result, EcsSystem, &added); + ecs_assert(added == false, ECS_INTERNAL_ERROR, NULL); - trigger = flecs_sparse_add(world->triggers, ecs_trigger_t); - trigger->id = flecs_sparse_last_id(world->triggers); + /* Prevent the system from moving while we're initializing */ + ecs_defer_begin(world); - trigger->term = ecs_term_move(&term); - trigger->callback = desc->callback; - trigger->ctx = desc->ctx; - trigger->binding_ctx = desc->binding_ctx; - trigger->ctx_free = desc->ctx_free; - trigger->binding_ctx_free = desc->binding_ctx_free; - trigger->event_count = count_events(desc->events); - ecs_os_memcpy(trigger->events, desc->events, - trigger->event_count * ECS_SIZEOF(ecs_entity_t)); - trigger->entity = entity; - trigger->self = desc->self; - trigger->observable = observable; - trigger->match_prefab = desc->match_prefab; - trigger->match_disabled = desc->match_disabled; - trigger->instanced = desc->instanced; - trigger->last_event_id = desc->last_event_id; + system->entity = result; + system->query = query; - if (trigger->term.id == EcsPrefab) { - trigger->match_prefab = true; - } - if (trigger->term.id == EcsDisabled) { - trigger->match_disabled = true; + system->run = desc->run; + system->action = desc->callback; + system->status_action = desc->status_callback; + + system->self = desc->self; + system->ctx = desc->ctx; + system->status_ctx = desc->status_ctx; + system->binding_ctx = desc->binding_ctx; + + system->ctx_free = desc->ctx_free; + system->status_ctx_free = desc->status_ctx_free; + system->binding_ctx_free = desc->binding_ctx_free; + + system->tick_source = desc->tick_source; + + system->multi_threaded = desc->multi_threaded; + system->no_staging = desc->no_staging; + + /* If tables have been matched with this system it is active, and we + * should activate the in terms, if any. This will ensure that any + * OnDemand systems get enabled. */ + if (ecs_query_table_count(query)) { + ecs_system_activate(world, result, true, system); + } else { + /* If system isn't matched with any tables, mark it as inactive. This + * causes it to be ignored by the main loop. When the system matches + * with a table it will be activated. */ + ecs_add_id(world, result, EcsInactive); } - comp->trigger = trigger; + if (!ecs_has_id(world, result, EcsDisabled)) { + /* If system is already enabled, generate enable status. The API + * should guarantee that it exactly matches enable-disable + * notifications and activate-deactivate notifications. */ + invoke_status_action(world, result, system, EcsSystemEnabled); - /* Trigger must have at least one event */ - ecs_check(trigger->event_count != 0, ECS_INVALID_PARAMETER, NULL); + /* If column system has active (non-empty) tables, also generate the + * activate status. */ + if (ecs_query_table_count(system->query)) { + invoke_status_action(world, result, system, EcsSystemActivated); + } + } - register_trigger(world, observable, trigger); + if (desc->interval != 0 || desc->rate != 0 || desc->tick_source != 0) { +#ifdef FLECS_TIMER + if (desc->interval != 0) { + ecs_set_interval(world, result, desc->interval); + } - ecs_term_fini(&term); + if (desc->rate) { + ecs_set_rate(world, result, desc->rate, desc->tick_source); + } else if (desc->tick_source) { + ecs_set_tick_source(world, result, desc->tick_source); + } +#else + ecs_abort(ECS_UNSUPPORTED, "timer module not available"); +#endif + } + + ecs_modified(world, result, EcsSystem); if (desc->entity.name) { - ecs_trace("#[green]trigger#[reset] %s created", - ecs_get_name(world, entity)); + ecs_trace("#[green]system#[reset] %s created", + ecs_get_name(world, result)); } - if (desc->yield_existing) { - trigger_yield_existing(world, trigger); - } + ecs_defer_end(world); } else { - ecs_assert(comp->trigger != NULL, ECS_INTERNAL_ERROR, NULL); + const char *expr_desc = desc->query.filter.expr; + const char *expr_sys = system->query->filter.expr; - /* If existing entity handle was provided, override existing params */ - if (existing) { - if (desc->callback) { - ((ecs_trigger_t*)comp->trigger)->callback = desc->callback; - } - if (desc->ctx) { - ((ecs_trigger_t*)comp->trigger)->ctx = desc->ctx; + /* Only check expression if it's set */ + if (expr_desc) { + if (expr_sys && !strcmp(expr_sys, "0")) expr_sys = NULL; + if (expr_desc && !strcmp(expr_desc, "0")) expr_desc = NULL; + + if (expr_sys && expr_desc) { + if (strcmp(expr_sys, expr_desc)) { + ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); + } + } else { + if (expr_sys != expr_desc) { + ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); + } } - if (desc->binding_ctx) { - ((ecs_trigger_t*)comp->trigger)->binding_ctx = desc->binding_ctx; + + /* If expr_desc is not set, and this is an existing system, don't throw + * an error because we could be updating existing parameters of the + * system such as the context or system callback. However, if no + * entity handle was provided, we have to assume that the application is + * trying to redeclare the system. */ + } else if (!existing) { + if (expr_sys) { + ecs_abort(ECS_ALREADY_DEFINED, desc->entity.name); } } + + if (desc->run) { + system->run = desc->run; + } + if (desc->callback) { + system->action = desc->callback; + } + if (desc->ctx) { + system->ctx = desc->ctx; + } + if (desc->binding_ctx) { + system->binding_ctx = desc->binding_ctx; + } + if (desc->query.filter.instanced) { + system->query->filter.instanced = true; + } + if (desc->multi_threaded) { + system->multi_threaded = desc->multi_threaded; + } + if (desc->no_staging) { + system->no_staging = desc->no_staging; + } } - ecs_os_free(name); - return entity; + return result; error: - ecs_os_free(name); - ecs_delete(world, entity); return 0; } -void* ecs_get_trigger_ctx( - const ecs_world_t *world, - ecs_entity_t trigger) +void FlecsSystemImport( + ecs_world_t *world) { - const EcsTrigger *t = ecs_get(world, trigger, EcsTrigger); - if (t) { - return t->trigger->ctx; - } else { - return NULL; - } + ECS_MODULE(world, FlecsSystem); + + ecs_set_name_prefix(world, "Ecs"); + + flecs_bootstrap_component(world, EcsSystem); + flecs_bootstrap_component(world, EcsTickSource); + + /* Put following tags in flecs.core so they can be looked up + * without using the flecs.systems prefix. */ + ecs_entity_t old_scope = ecs_set_scope(world, EcsFlecsCore); + flecs_bootstrap_tag(world, EcsInactive); + flecs_bootstrap_tag(world, EcsMonitor); + ecs_set_scope(world, old_scope); + + /* Bootstrap ctor and dtor for EcsSystem */ + ecs_set_component_actions_w_id(world, ecs_id(EcsSystem), + &(EcsComponentLifecycle) { + .ctor = ecs_default_ctor, + .dtor = ecs_dtor(EcsSystem) + }); + + ecs_observer_init(world, &(ecs_observer_desc_t) { + .entity.name = "EnableMonitor", + .filter.terms = { + { .id = ecs_id(EcsSystem) }, + { .id = EcsDisabled, .oper = EcsNot }, + }, + .events = {EcsMonitor}, + .callback = EnableMonitor + }); } -void* ecs_get_trigger_binding_ctx( - const ecs_world_t *world, - ecs_entity_t trigger) +#endif + + +#ifdef FLECS_DEPRECATED + + +#endif + +#include +#include + +#define ECS_NAME_BUFFER_LENGTH (64) + +static +bool path_append( + const ecs_world_t *world, + ecs_entity_t parent, + ecs_entity_t child, + const char *sep, + const char *prefix, + ecs_strbuf_t *buf) { - const EcsTrigger *t = ecs_get(world, trigger, EcsTrigger); - if (t) { - return t->trigger->binding_ctx; - } else { - return NULL; - } -} + ecs_poly_assert(world, ecs_world_t); -void flecs_trigger_fini( - ecs_world_t *world, - ecs_trigger_t *trigger) -{ - unregister_trigger(world, trigger->observable, trigger); - ecs_term_fini(&trigger->term); + ecs_entity_t cur = 0; + char buff[22]; + const char *name; - if (trigger->ctx_free) { - trigger->ctx_free(trigger->ctx); - } + if (ecs_is_valid(world, child)) { + cur = ecs_get_object(world, child, EcsChildOf, 0); + if (cur) { + if (cur != parent && (cur != EcsFlecsCore || prefix != NULL)) { + path_append(world, parent, cur, sep, prefix, buf); + ecs_strbuf_appendstr(buf, sep); + } + } else if (prefix) { + ecs_strbuf_appendstr(buf, prefix); + } - if (trigger->binding_ctx_free) { - trigger->binding_ctx_free(trigger->binding_ctx); + name = ecs_get_name(world, child); + if (!name || !ecs_os_strlen(name)) { + ecs_os_sprintf(buff, "%u", (uint32_t)child); + name = buff; + } + } else { + ecs_os_sprintf(buff, "%u", (uint32_t)child); + name = buff; } - flecs_sparse_remove(world->triggers, trigger->id); -} - -#include + ecs_strbuf_appendstr(buf, name); -#ifndef FLECS_NDEBUG -static int64_t s_min[] = { - [1] = INT8_MIN, [2] = INT16_MIN, [4] = INT32_MIN, [8] = INT64_MIN }; -static int64_t s_max[] = { - [1] = INT8_MAX, [2] = INT16_MAX, [4] = INT32_MAX, [8] = INT64_MAX }; -static uint64_t u_max[] = { - [1] = UINT8_MAX, [2] = UINT16_MAX, [4] = UINT32_MAX, [8] = UINT64_MAX }; + return cur != 0; +} -uint64_t _flecs_ito( - size_t size, - bool is_signed, - bool lt_zero, - uint64_t u, - const char *err) +static +bool is_number( + const char *name) { - union { - uint64_t u; - int64_t s; - } v; + ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL); + + if (!isdigit(name[0])) { + return false; + } - v.u = u; + ecs_size_t i, length = ecs_os_strlen(name); + for (i = 1; i < length; i ++) { + char ch = name[i]; - if (is_signed) { - ecs_assert(v.s >= s_min[size], ECS_INVALID_CONVERSION, err); - ecs_assert(v.s <= s_max[size], ECS_INVALID_CONVERSION, err); - } else { - ecs_assert(lt_zero == false, ECS_INVALID_CONVERSION, err); - ecs_assert(u <= u_max[size], ECS_INVALID_CONVERSION, err); + if (!isdigit(ch)) { + break; + } } - return u; + return i >= length; } -#endif -int32_t flecs_next_pow_of_2( - int32_t n) +static +ecs_entity_t name_to_id( + const ecs_world_t *world, + const char *name) { - n --; - n |= n >> 1; - n |= n >> 2; - n |= n >> 4; - n |= n >> 8; - n |= n >> 16; - n ++; - - return n; + long int result = atol(name); + ecs_assert(result >= 0, ECS_INTERNAL_ERROR, NULL); + ecs_entity_t alive = ecs_get_alive(world, (ecs_entity_t)result); + if (alive) { + return alive; + } else { + return (ecs_entity_t)result; + } } -/** Convert time to double */ -double ecs_time_to_double( - ecs_time_t t) +static +ecs_entity_t get_builtin( + const char *name) { - double result; - result = t.sec; - return result + (double)t.nanosec / (double)1000000000; + if (name[0] == '.' && name[1] == '\0') { + return EcsThis; + } else if (name[0] == '*' && name[1] == '\0') { + return EcsWildcard; + } else if (name[0] == '_' && name[1] == '\0') { + return EcsAny; + } + + return 0; } -ecs_time_t ecs_time_sub( - ecs_time_t t1, - ecs_time_t t2) +static +bool is_sep( + const char **ptr, + const char *sep) { - ecs_time_t result; + ecs_size_t len = ecs_os_strlen(sep); - if (t1.nanosec >= t2.nanosec) { - result.nanosec = t1.nanosec - t2.nanosec; - result.sec = t1.sec - t2.sec; + if (!ecs_os_strncmp(*ptr, sep, len)) { + *ptr += len; + return true; } else { - result.nanosec = t1.nanosec - t2.nanosec + 1000000000; - result.sec = t1.sec - t2.sec - 1; + return false; } - - return result; } -void ecs_sleepf( - double t) +static +const char* path_elem( + const char *path, + const char *sep, + int32_t *len) { - if (t > 0) { - int sec = (int)t; - int nsec = (int)((t - sec) * 1000000000); - ecs_os_sleep(sec, nsec); + const char *ptr; + char ch; + int32_t template_nesting = 0; + int32_t count = 0; + + for (ptr = path; (ch = *ptr); ptr ++) { + if (ch == '<') { + template_nesting ++; + } else if (ch == '>') { + template_nesting --; + } + + ecs_check(template_nesting >= 0, ECS_INVALID_PARAMETER, path); + + if (!template_nesting && is_sep(&ptr, sep)) { + break; + } + + count ++; } -} -double ecs_time_measure( - ecs_time_t *start) -{ - ecs_time_t stop, temp; - ecs_os_get_time(&stop); - temp = stop; - stop = ecs_time_sub(stop, *start); - *start = temp; - return ecs_time_to_double(stop); -} + if (len) { + *len = count; + } -void* ecs_os_memdup( - const void *src, - ecs_size_t size) -{ - if (!src) { + if (count) { + return ptr; + } else { return NULL; } - - void *dst = ecs_os_malloc(size); - ecs_assert(dst != NULL, ECS_OUT_OF_MEMORY, NULL); - ecs_os_memcpy(dst, src, size); - return dst; -} - -int flecs_entity_compare( - ecs_entity_t e1, - const void *ptr1, - ecs_entity_t e2, - const void *ptr2) -{ - (void)ptr1; - (void)ptr2; - return (e1 > e2) - (e1 < e2); +error: + return NULL; } -int flecs_entity_compare_qsort( - const void *e1, - const void *e2) +static +ecs_entity_t get_parent_from_path( + const ecs_world_t *world, + ecs_entity_t parent, + const char **path_ptr, + const char *prefix, + bool new_entity) { - ecs_entity_t v1 = *(ecs_entity_t*)e1; - ecs_entity_t v2 = *(ecs_entity_t*)e2; - return flecs_entity_compare(v1, NULL, v2, NULL); -} + bool start_from_root = false; + const char *path = *path_ptr; + + if (prefix) { + ecs_size_t len = ecs_os_strlen(prefix); + if (!ecs_os_strncmp(path, prefix, len)) { + path += len; + parent = 0; + start_from_root = true; + } + } -uint64_t flecs_string_hash( - const void *ptr) -{ - const ecs_hashed_string_t *str = ptr; - ecs_assert(str->hash != 0, ECS_INTERNAL_ERROR, NULL); - return str->hash; -} + if (!start_from_root && !parent && new_entity) { + parent = ecs_get_scope(world); + } -/* - This code was taken from sokol_time.h - - zlib/libpng license - Copyright (c) 2018 Andre Weissflog - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the - use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software in a - product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not - be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source - distribution. -*/ + *path_ptr = path; + return parent; +} -/* -- Component lifecycle -- */ +static +void on_set_symbol(ecs_iter_t *it) { + EcsIdentifier *n = ecs_term(it, EcsIdentifier, 1); + ecs_world_t *world = it->world; -/* Component lifecycle actions for EcsIdentifier */ -static ECS_CTOR(EcsIdentifier, ptr, { - ptr->value = NULL; - ptr->hash = 0; - ptr->length = 0; - ptr->index_hash = 0; - ptr->index = NULL; -}) + int i; + for (i = 0; i < it->count; i ++) { + ecs_entity_t e = it->entities[i]; + flecs_name_index_ensure( + &world->symbols, e, n[i].value, n[i].length, n[i].hash); + } +} -static ECS_DTOR(EcsIdentifier, ptr, { - ecs_os_strset(&ptr->value, NULL); -}) +void flecs_bootstrap_hierarchy(ecs_world_t *world) { + ecs_trigger_init(world, &(ecs_trigger_desc_t){ + .term = {.id = ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), .subj.set.mask = EcsSelf }, + .callback = on_set_symbol, + .events = {EcsOnSet}, + .yield_existing = true + }); +} -static ECS_COPY(EcsIdentifier, dst, src, { - ecs_os_strset(&dst->value, src->value); - dst->hash = src->hash; - dst->length = src->length; - dst->index_hash = src->index_hash; - dst->index = src->index; -}) -static ECS_MOVE(EcsIdentifier, dst, src, { - ecs_os_strset(&dst->value, NULL); - dst->value = src->value; - dst->hash = src->hash; - dst->length = src->length; - dst->index_hash = src->index_hash; - dst->index = src->index; +/* Public functions */ - src->value = NULL; - src->hash = 0; - src->index_hash = 0; - src->index = 0; - src->length = 0; -}) +void ecs_get_path_w_sep_buf( + const ecs_world_t *world, + ecs_entity_t parent, + ecs_entity_t child, + const char *sep, + const char *prefix, + ecs_strbuf_t *buf) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(buf != NULL, ECS_INVALID_PARAMETER, NULL); -static -void ecs_on_set(EcsIdentifier)(ecs_iter_t *it) { - EcsIdentifier *ptr = ecs_term(it, EcsIdentifier, 1); - - ecs_world_t *world = it->real_world; - ecs_entity_t evt = it->event; - ecs_id_t evt_id = it->event_id; - ecs_entity_t kind = ECS_PAIR_SECOND(evt_id); /* Name, Symbol, Alias */ + world = ecs_get_world(world); - ecs_id_t pair = ecs_childof(0); + if (child == EcsThis) { + ecs_strbuf_appendstr(buf, "."); + return; + } + if (child == EcsWildcard) { + ecs_strbuf_appendstr(buf, "*"); + return; + } + if (child == EcsAny) { + ecs_strbuf_appendstr(buf, "_"); + return; + } - ecs_hashmap_t *name_index = NULL; - if (kind == EcsSymbol) { - name_index = &world->symbols; - } else if (kind == EcsAlias) { - name_index = &world->aliases; - } else if (kind == EcsName) { - ecs_assert(it->table != NULL, ECS_INTERNAL_ERROR, NULL); - ecs_search(world, it->table, ecs_childof(EcsWildcard), &pair); - ecs_assert(pair != 0, ECS_INTERNAL_ERROR, NULL); + if (!sep) { + sep = "."; + } - if (evt == EcsOnSet) { - name_index = flecs_ensure_id_name_index(world, pair); - } else { - name_index = flecs_get_id_name_index(world, pair); - } + if (!child || parent != child) { + path_append(world, parent, child, sep, prefix, buf); + } else { + ecs_strbuf_appendstr(buf, ""); } - for (int i = 0; i < it->count; i ++) { - EcsIdentifier *cur = &ptr[i]; - uint64_t hash; - ecs_size_t len; - const char *name = cur->value; +error: + return; +} - if (cur->index && cur->index != name_index) { - /* If index doesn't match up, the value must have been copied from - * another entity, so reset index & cached index hash */ - cur->index = NULL; - cur->index_hash = 0; - } +char* ecs_get_path_w_sep( + const ecs_world_t *world, + ecs_entity_t parent, + ecs_entity_t child, + const char *sep, + const char *prefix) +{ + ecs_strbuf_t buf = ECS_STRBUF_INIT; + ecs_get_path_w_sep_buf(world, parent, child, sep, prefix, &buf); + return ecs_strbuf_get(&buf); +} - if (cur->value && (evt == EcsOnSet)) { - len = cur->length = ecs_os_strlen(name); - hash = cur->hash = flecs_hash(name, len); - } else { - len = cur->length = 0; - hash = cur->hash = 0; - cur->index = NULL; - } +ecs_entity_t ecs_lookup_child( + const ecs_world_t *world, + ecs_entity_t parent, + const char *name) +{ + ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); - if (name_index) { - uint64_t index_hash = cur->index_hash; - ecs_entity_t e = it->entities[i]; + if (is_number(name)) { + return name_to_id(world, name); + } - if (hash != index_hash) { - if (index_hash) { - flecs_name_index_remove(name_index, e, index_hash); - } - if (hash) { - flecs_name_index_ensure(name_index, e, name, len, hash); - cur->index_hash = hash; - cur->index = name_index; - } - } else { - /* Name didn't change, but the string could have been - * reallocated. Make sure name index points to correct string */ - flecs_name_index_update_name(name_index, e, hash, name); - } - } + ecs_id_t pair = ecs_childof(parent); + ecs_hashmap_t *index = flecs_get_id_name_index(world, pair); + if (index) { + return flecs_name_index_find(index, name, 0, 0); + } else { + return 0; } +error: + return 0; } -/* Component lifecycle actions for EcsTrigger */ -static ECS_CTOR(EcsTrigger, ptr, { - ptr->trigger = NULL; -}) - -static ECS_DTOR(EcsTrigger, ptr, { - if (ptr->trigger) { - flecs_trigger_fini(world, (ecs_trigger_t*)ptr->trigger); +ecs_entity_t ecs_lookup( + const ecs_world_t *world, + const char *name) +{ + if (!name) { + return 0; } -}) -static ECS_COPY(EcsTrigger, dst, src, { - ecs_abort(ECS_INVALID_OPERATION, "Trigger component cannot be copied"); -}) + ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); + world = ecs_get_world(world); -static ECS_MOVE(EcsTrigger, dst, src, { - if (dst->trigger) { - flecs_trigger_fini(world, (ecs_trigger_t*)dst->trigger); + ecs_entity_t e = get_builtin(name); + if (e) { + return e; } - dst->trigger = src->trigger; - src->trigger = NULL; -}) - -/* Component lifecycle actions for EcsObserver */ -static ECS_CTOR(EcsObserver, ptr, { - ptr->observer = NULL; -}) -static ECS_DTOR(EcsObserver, ptr, { - if (ptr->observer) { - flecs_observer_fini(world, (ecs_observer_t*)ptr->observer); + if (is_number(name)) { + return name_to_id(world, name); } -}) -static ECS_COPY(EcsObserver, dst, src, { - ecs_abort(ECS_INVALID_OPERATION, "Observer component cannot be copied"); -}) + e = flecs_name_index_find(&world->aliases, name, 0, 0); + if (e) { + return e; + } + + return ecs_lookup_child(world, 0, name); +error: + return 0; +} -static ECS_MOVE(EcsObserver, dst, src, { - if (dst->observer) { - flecs_observer_fini(world, (ecs_observer_t*)dst->observer); +ecs_entity_t ecs_lookup_symbol( + const ecs_world_t *world, + const char *name, + bool lookup_as_path) +{ + if (!name) { + return 0; } - dst->observer = src->observer; - src->observer = NULL; -}) - -/* -- Builtin triggers -- */ + ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); + world = ecs_get_world(world); -static -void assert_relation_unused( - ecs_world_t *world, - ecs_entity_t rel, - ecs_entity_t property) -{ - if (flecs_get_id_record(world, ecs_pair(rel, EcsWildcard)) != NULL) { - char *r_str = ecs_get_fullpath(world, rel); - char *p_str = ecs_get_fullpath(world, property); + ecs_entity_t e = flecs_name_index_find(&world->symbols, name, 0, 0); + if (e) { + return e; + } - ecs_throw(ECS_ID_IN_USE, - "cannot add property '%s' to relation '%s': already in use", - p_str, r_str); - - ecs_os_free(r_str); - ecs_os_free(p_str); + if (lookup_as_path) { + return ecs_lookup_fullpath(world, name); } error: - return; + return 0; } -static -void register_final(ecs_iter_t *it) { - ecs_world_t *world = it->world; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - if (flecs_get_id_record(world, ecs_pair(EcsIsA, e)) != NULL) { - char *e_str = ecs_get_fullpath(world, e); - ecs_throw(ECS_ID_IN_USE, - "cannot add property 'Final' to '%s': already inherited from", - e_str); - ecs_os_free(e_str); - error: - continue; - } +ecs_entity_t ecs_lookup_path_w_sep( + const ecs_world_t *world, + ecs_entity_t parent, + const char *path, + const char *sep, + const char *prefix, + bool recursive) +{ + if (!path) { + return 0; } -} - -static -void register_on_delete(ecs_iter_t *it) { - ecs_world_t *world = it->world; - ecs_id_t id = ecs_term_id(it, 1); - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - assert_relation_unused(world, e, EcsOnDelete); - ecs_id_record_t *r = flecs_ensure_id_record(world, e); - ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); - r->flags |= ECS_ID_ON_DELETE_FLAG(ECS_PAIR_SECOND(id)); + if (!sep) { + sep = "."; + } - flecs_add_flag(world, e, ECS_FLAG_OBSERVED_ID); + ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); + const ecs_world_t *stage = world; + world = ecs_get_world(world); + + ecs_entity_t e = get_builtin(path); + if (e) { + return e; } -} -static -void register_on_delete_object(ecs_iter_t *it) { - ecs_world_t *world = it->world; - ecs_id_t id = ecs_term_id(it, 1); + e = flecs_name_index_find(&world->aliases, path, 0, 0); + if (e) { + return e; + } - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - assert_relation_unused(world, e, EcsOnDeleteObject); + char buff[ECS_NAME_BUFFER_LENGTH]; + const char *ptr, *ptr_start; + char *elem = buff; + int32_t len, size = ECS_NAME_BUFFER_LENGTH; + ecs_entity_t cur; + bool lookup_path_search = false; - ecs_id_record_t *r = flecs_ensure_id_record(world, e); - ecs_assert(r != NULL, ECS_INTERNAL_ERROR, NULL); - r->flags |= ECS_ID_ON_DELETE_OBJECT_FLAG(ECS_PAIR_SECOND(id)); + ecs_entity_t *lookup_path = ecs_get_lookup_path(stage); + ecs_entity_t *lookup_path_cur = lookup_path; + while (lookup_path_cur && *lookup_path_cur) { + lookup_path_cur ++; + } - flecs_add_flag(world, e, ECS_FLAG_OBSERVED_ID); - } -} + if (!sep) { + sep = "."; + } -static -void register_exclusive(ecs_iter_t *it) { - ecs_world_t *world = it->world; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - assert_relation_unused(world, e, EcsExclusive); + parent = get_parent_from_path(stage, parent, &path, prefix, true); - ecs_id_record_t *r = flecs_ensure_id_record(world, e); - r->flags |= ECS_ID_EXCLUSIVE; - } -} +retry: + cur = parent; + ptr_start = ptr = path; -static -void register_dont_inherit(ecs_iter_t *it) { - ecs_world_t *world = it->world; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - assert_relation_unused(world, e, EcsDontInherit); + while ((ptr = path_elem(ptr, sep, &len))) { + if (len < size) { + ecs_os_memcpy(elem, ptr_start, len); + } else { + if (size == ECS_NAME_BUFFER_LENGTH) { + elem = NULL; + } - ecs_id_record_t *r = flecs_ensure_id_record(world, e); - r->flags |= ECS_ID_DONT_INHERIT; - } -} + elem = ecs_os_realloc(elem, len + 1); + ecs_os_memcpy(elem, ptr_start, len); + size = len + 1; + } -static -void on_symmetric_add_remove(ecs_iter_t *it) { - ecs_entity_t pair = ecs_term_id(it, 1); + elem[len] = '\0'; + ptr_start = ptr; - if (!ECS_HAS_ROLE(pair, PAIR)) { - /* If relationship was not added as a pair, there's nothing to do */ - return; + cur = ecs_lookup_child(world, cur, elem); + if (!cur) { + goto tail; + } } - ecs_entity_t rel = ECS_PAIR_FIRST(pair); - ecs_entity_t obj = ECS_PAIR_SECOND(pair); - ecs_entity_t event = it->event; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t subj = it->entities[i]; - if (event == EcsOnAdd) { - if (!ecs_has_id(it->real_world, obj, ecs_pair(rel, subj))) { - ecs_add_pair(it->world, obj, rel, subj); +tail: + if (!cur && recursive) { + if (!lookup_path_search) { + if (parent) { + parent = ecs_get_object(world, parent, EcsChildOf, 0); + goto retry; + } else { + lookup_path_search = true; } - } else { - if (ecs_has_id(it->real_world, obj, ecs_pair(rel, subj))) { - ecs_remove_pair(it->world, obj, rel, subj); + } + + if (lookup_path_search) { + if (lookup_path_cur != lookup_path) { + lookup_path_cur --; + parent = lookup_path_cur[0]; + goto retry; } } } -} - -static -void register_symmetric(ecs_iter_t *it) { - ecs_world_t *world = it->real_world; - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t r = it->entities[i]; - assert_relation_unused(world, r, EcsSymmetric); + if (elem != buff) { + ecs_os_free(elem); + } - /* Create trigger that adds the reverse relationship when R(X, Y) is - * added, or remove the reverse relationship when R(X, Y) is removed. */ - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term.id = ecs_pair(r, EcsWildcard), - .callback = on_symmetric_add_remove, - .events = {EcsOnAdd, EcsOnRemove} - }); - } + return cur; +error: + return 0; } -static -void on_set_component(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsComponent *c = ecs_term(it, EcsComponent, 1); - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_type_info_t *ti = flecs_ensure_type_info(world, e); - ti->size = c[i].size; - ti->alignment = c[i].alignment; - } -} +ecs_entity_t ecs_set_scope( + ecs_world_t *world, + ecs_entity_t scope) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_stage_t *stage = flecs_stage_from_world(&world); -static -void on_set_component_lifecycle(ecs_iter_t *it) { - ecs_world_t *world = it->world; - EcsComponentLifecycle *cl = ecs_term(it, EcsComponentLifecycle, 1); + ecs_entity_t cur = stage->scope; + stage->scope = scope; - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_set_component_actions_w_id(world, e, &cl[i]); - } + return cur; +error: + return 0; } -static -void ensure_module_tag(ecs_iter_t *it) { - ecs_world_t *world = it->world; - - int i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - ecs_entity_t parent = ecs_get_object(world, e, EcsChildOf, 0); - if (parent) { - ecs_add_id(world, parent, EcsModule); - } - } +ecs_entity_t ecs_get_scope( + const ecs_world_t *world) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); + return stage->scope; +error: + return 0; } -/* -- Triggers for keeping hashed ids in sync -- */ +ecs_entity_t* ecs_set_lookup_path( + ecs_world_t *world, + const ecs_entity_t *lookup_path) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_stage_t *stage = flecs_stage_from_world(&world); -static -void on_parent_change(ecs_iter_t *it) { - ecs_world_t *world = it->world; - ecs_table_t *other_table = it->other_table, *table = it->table; + ecs_entity_t *cur = stage->lookup_path; + stage->lookup_path = (ecs_entity_t*)lookup_path; - int32_t col = ecs_search(it->real_world, table, - ecs_pair(ecs_id(EcsIdentifier), EcsName), 0); - bool has_name = col != -1; - bool other_has_name = ecs_search(it->real_world, other_table, - ecs_pair(ecs_id(EcsIdentifier), EcsName), 0) != -1; + return cur; +error: + return NULL; +} - if (!has_name && !other_has_name) { - /* If tables don't have names, index does not need to be updated */ - return; - } +ecs_entity_t* ecs_get_lookup_path( + const ecs_world_t *world) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); + return stage->lookup_path; +error: + return NULL; +} - ecs_id_t to_pair = it->event_id; - ecs_id_t from_pair = ecs_childof(0); +const char* ecs_set_name_prefix( + ecs_world_t *world, + const char *prefix) +{ + ecs_poly_assert(world, ecs_world_t); + const char *old_prefix = world->name_prefix; + world->name_prefix = prefix; + return old_prefix; +} - /* Find the other ChildOf relationship */ - ecs_search(it->real_world, other_table, - ecs_pair(EcsChildOf, EcsWildcard), &from_pair); +ecs_entity_t ecs_add_path_w_sep( + ecs_world_t *world, + ecs_entity_t entity, + ecs_entity_t parent, + const char *path, + const char *sep, + const char *prefix) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - bool to_has_name = has_name, from_has_name = other_has_name; - if (it->event == EcsOnRemove) { - if (from_pair != ecs_childof(0)) { - /* Because ChildOf is an exclusive relationship, events always come - * in OnAdd/OnRemove pairs (add for the new, remove for the old - * parent). We only need one of those events, so filter out the - * OnRemove events except for the case where a parent is removed and - * not replaced with another parent. */ - return; + if (!sep) { + sep = "."; + } + + if (!path) { + if (!entity) { + entity = ecs_new_id(world); } - ecs_id_t temp = from_pair; - from_pair = to_pair; - to_pair = temp; + if (parent) { + ecs_add_pair(world, entity, EcsChildOf, entity); + } - to_has_name = other_has_name; - from_has_name = has_name; + return entity; } - /* Get the table column with names */ - const EcsIdentifier *names = ecs_iter_column(it, EcsIdentifier, col); + parent = get_parent_from_path(world, parent, &path, prefix, entity == 0); - ecs_hashmap_t *from_index = 0; - if (from_has_name) { - from_index = flecs_get_id_name_index(world, from_pair); - } - ecs_hashmap_t *to_index = NULL; - if (to_has_name) { - to_index = flecs_ensure_id_name_index(world, to_pair); - } + char buff[ECS_NAME_BUFFER_LENGTH]; + const char *ptr = path; + const char *ptr_start = path; + char *elem = buff; + int32_t len, size = ECS_NAME_BUFFER_LENGTH; - int32_t i, count = it->count; - for (i = 0; i < count; i ++) { - ecs_entity_t e = it->entities[i]; - const EcsIdentifier *name = &names[i]; + ecs_entity_t cur = parent; - uint64_t index_hash = name->index_hash; - if (from_index && index_hash) { - flecs_name_index_remove(from_index, e, index_hash); - } - const char *name_str = name->value; - if (to_index && name_str) { - ecs_assert(name->hash != 0, ECS_INTERNAL_ERROR, NULL); - flecs_name_index_ensure( - to_index, e, name_str, name->length, name->hash); - } - } -} + char *name = NULL; + while ((ptr = path_elem(ptr, sep, &len))) { + if (len < size) { + ecs_os_memcpy(elem, ptr_start, len); + } else { + if (size == ECS_NAME_BUFFER_LENGTH) { + elem = NULL; + } -/* -- Iterable mixins -- */ + elem = ecs_os_realloc(elem, len + 1); + ecs_os_memcpy(elem, ptr_start, len); + size = len + 1; + } -static -void on_event_iterable_init( - const ecs_world_t *world, - const ecs_poly_t *poly, /* Observable */ - ecs_iter_t *it, - ecs_term_t *filter) -{ - ecs_iter_poly(world, poly, it, filter); - it->event_id = filter->id; -} + elem[len] = '\0'; + ptr_start = ptr; -/* -- Bootstrapping -- */ + ecs_entity_t e = ecs_lookup_child(world, cur, elem); + if (!e) { + if (name) { + ecs_os_free(name); + } -#define bootstrap_component(world, table, name)\ - _bootstrap_component(world, table, ecs_id(name), #name, sizeof(name),\ - ECS_ALIGNOF(name)) + name = ecs_os_strdup(elem); -static -void _bootstrap_component( - ecs_world_t *world, - ecs_table_t *table, - ecs_entity_t entity, - const char *symbol, - ecs_size_t size, - ecs_size_t alignment) -{ - ecs_assert(table != NULL, ECS_INTERNAL_ERROR, NULL); + /* If this is the last entity in the path, use the provided id */ + bool last_elem = false; + if (!path_elem(ptr, sep, NULL)) { + e = entity; + last_elem = true; + } - ecs_column_t *columns = table->storage.columns; - ecs_assert(columns != NULL, ECS_INTERNAL_ERROR, NULL); + if (!e) { + if (last_elem) { + ecs_entity_t prev = ecs_set_scope(world, 0); + e = ecs_new(world, 0); + ecs_set_scope(world, prev); + } else { + e = ecs_new_id(world); + } + } - ecs_record_t *record = ecs_eis_ensure(world, entity); - record->table = table; + if (cur) { + ecs_add_pair(world, e, EcsChildOf, cur); + } - int32_t index = flecs_table_append(world, table, &table->storage, - entity, record, false); - record->row = ECS_ROW_TO_RECORD(index, 0); + ecs_set_name(world, e, name); + } - EcsComponent *component = ecs_vector_first(columns[0].data, EcsComponent); - component[index].size = size; - component[index].alignment = alignment; + cur = e; + } - const char *name = &symbol[3]; /* Strip 'Ecs' */ - ecs_size_t symbol_length = ecs_os_strlen(symbol); - ecs_size_t name_length = symbol_length - 3; + if (entity && (cur != entity)) { + ecs_throw(ECS_ALREADY_DEFINED, name); + } - EcsIdentifier *name_col = ecs_vector_first(columns[1].data, EcsIdentifier); - name_col[index].value = ecs_os_strdup(name); - name_col[index].length = name_length; - name_col[index].hash = flecs_hash(name, name_length); - name_col[index].index_hash = 0; - name_col[index].index = NULL; + if (name) { + ecs_os_free(name); + } - EcsIdentifier *symbol_col = ecs_vector_first(columns[2].data, EcsIdentifier); - symbol_col[index].value = ecs_os_strdup(symbol); - symbol_col[index].length = symbol_length; - symbol_col[index].hash = flecs_hash(symbol, symbol_length); - symbol_col[index].index_hash = 0; - symbol_col[index].index = NULL; + if (elem != buff) { + ecs_os_free(elem); + } + + return cur; +error: + return 0; } -/** Initialize component table. This table is manually constructed to bootstrap - * flecs. After this function has been called, the builtin components can be - * created. - * The reason this table is constructed manually is because it requires the size - * and alignment of the EcsComponent and EcsIdentifier components, which haven't - * been created yet */ -static -ecs_table_t* bootstrap_component_table( - ecs_world_t *world) +ecs_entity_t ecs_new_from_path_w_sep( + ecs_world_t *world, + ecs_entity_t parent, + const char *path, + const char *sep, + const char *prefix) { - /* Before creating the table, ensure component ids are alive */ - ecs_ensure(world, ecs_id(EcsComponent)); - ecs_ensure(world, EcsFinal); - ecs_ensure(world, ecs_id(EcsIdentifier)); - ecs_ensure(world, EcsName); - ecs_ensure(world, EcsSymbol); - ecs_ensure(world, EcsAlias); - ecs_ensure(world, EcsChildOf); - ecs_ensure(world, EcsFlecsCore); - ecs_ensure(world, EcsOnDelete); - ecs_ensure(world, EcsThrow); - ecs_ensure(world, EcsWildcard); - ecs_ensure(world, EcsAny); - - /* Before creating table, manually set flags for ChildOf/Identifier, as this - * can no longer be done after they are in use. */ - ecs_id_record_t *childof_idr = flecs_ensure_id_record(world, EcsChildOf); - childof_idr->flags |= ECS_ID_ON_DELETE_OBJECT_DELETE; - childof_idr->flags |= ECS_ID_DONT_INHERIT; - - ecs_id_record_t *ident_idr = flecs_ensure_id_record( - world, ecs_id(EcsIdentifier)); - ident_idr->flags |= ECS_ID_DONT_INHERIT; - - ecs_id_t entities[] = { - ecs_id(EcsComponent), - EcsFinal, - ecs_pair(ecs_id(EcsIdentifier), EcsName), - ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), - ecs_pair(EcsChildOf, EcsFlecsCore), - ecs_pair(EcsOnDelete, EcsThrow) - }; - - ecs_ids_t array = { - .array = entities, - .count = 6 - }; + if (!sep) { + sep = "."; + } - ecs_table_t *result = flecs_table_find_or_create(world, &array); - ecs_data_t *data = &result->storage; + return ecs_add_path_w_sep(world, 0, parent, path, sep, prefix); +} - /* Preallocate enough memory for initial components */ - data->entities = ecs_vector_new(ecs_entity_t, EcsFirstUserComponentId); - data->record_ptrs = ecs_vector_new(ecs_record_t*, EcsFirstUserComponentId); - data->columns[0].data = ecs_vector_new(EcsComponent, EcsFirstUserComponentId); - data->columns[1].data = ecs_vector_new(EcsIdentifier, EcsFirstUserComponentId); - data->columns[2].data = ecs_vector_new(EcsIdentifier, EcsFirstUserComponentId); - +static +ecs_defer_op_t* new_defer_op(ecs_stage_t *stage) { + ecs_defer_op_t *result = ecs_vector_add(&stage->defer_queue, ecs_defer_op_t); + ecs_os_memset(result, 0, ECS_SIZEOF(ecs_defer_op_t)); return result; } static -void bootstrap_entity( +bool defer_add_remove( ecs_world_t *world, - ecs_entity_t id, - const char *name, - ecs_entity_t parent) + ecs_stage_t *stage, + ecs_defer_op_kind_t op_kind, + ecs_entity_t entity, + ecs_id_t id) { - char symbol[256]; - ecs_os_strcpy(symbol, "flecs.core."); - ecs_os_strcat(symbol, name); - - ecs_add_pair(world, id, EcsChildOf, parent); - ecs_set_name(world, id, name); - ecs_set_symbol(world, id, symbol); + if (stage->defer) { + if (!id) { + return true; + } + + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = op_kind; + op->id = id; + op->is._1.entity = entity; - ecs_assert(ecs_get_name(world, id) != NULL, ECS_INTERNAL_ERROR, NULL); + if (op_kind == EcsOpNew) { + world->new_count ++; + } else if (op_kind == EcsOpAdd) { + world->add_count ++; + } else if (op_kind == EcsOpRemove) { + world->remove_count ++; + } - if (!parent || parent == EcsFlecsCore) { - ecs_assert(ecs_lookup_fullpath(world, name) == id, - ECS_INTERNAL_ERROR, NULL); + return true; + } else { + stage->defer ++; } + + return false; } -void flecs_bootstrap( - ecs_world_t *world) +static +void merge_stages( + ecs_world_t *world, + bool force_merge) { - ecs_log_push(); - - ecs_set_name_prefix(world, "Ecs"); - - /* Bootstrap type info (otherwise initialized by setting EcsComponent) */ - flecs_init_type_info_t(world, EcsComponent); - flecs_init_type_info_t(world, EcsIdentifier); - flecs_init_type_info_t(world, EcsTrigger); - flecs_init_type_info_t(world, EcsObserver); - - /* Setup component lifecycle actions */ - ecs_set_component_actions(world, EcsComponent, { - .ctor = ecs_default_ctor - }); + bool is_stage = ecs_poly_is(world, ecs_stage_t); + ecs_stage_t *stage = flecs_stage_from_world(&world); - ecs_set_component_actions(world, EcsIdentifier, { - .ctor = ecs_ctor(EcsIdentifier), - .dtor = ecs_dtor(EcsIdentifier), - .copy = ecs_copy(EcsIdentifier), - .move = ecs_move(EcsIdentifier), - .on_set = ecs_on_set(EcsIdentifier), - .on_remove = ecs_on_set(EcsIdentifier) - }); + bool measure_frame_time = world->measure_frame_time; - ecs_set_component_actions(world, EcsTrigger, { - .ctor = ecs_ctor(EcsTrigger), - .dtor = ecs_dtor(EcsTrigger), - .copy = ecs_copy(EcsTrigger), - .move = ecs_move(EcsTrigger) - }); + ecs_time_t t_start; + if (measure_frame_time) { + ecs_os_get_time(&t_start); + } - ecs_set_component_actions(world, EcsObserver, { - .ctor = ecs_ctor(EcsObserver), - .dtor = ecs_dtor(EcsObserver), - .copy = ecs_copy(EcsObserver), - .move = ecs_move(EcsObserver) - }); + if (is_stage) { + /* Check for consistency if force_merge is enabled. In practice this + * function will never get called with force_merge disabled for just + * a single stage. */ + if (force_merge || stage->auto_merge) { + ecs_defer_end((ecs_world_t*)stage); + } + } else { + /* Merge stages. Only merge if the stage has auto_merging turned on, or + * if this is a forced merge (like when ecs_merge is called) */ + int32_t i, count = ecs_get_stage_count(world); + for (i = 0; i < count; i ++) { + ecs_stage_t *s = (ecs_stage_t*)ecs_get_stage(world, i); + ecs_poly_assert(s, ecs_stage_t); + if (force_merge || s->auto_merge) { + ecs_defer_end((ecs_world_t*)s); + } + } + } - /* Create table for initial components */ - ecs_table_t *table = bootstrap_component_table(world); - assert(table != NULL); + flecs_eval_component_monitors(world); - bootstrap_component(world, table, EcsIdentifier); - bootstrap_component(world, table, EcsComponent); - bootstrap_component(world, table, EcsComponentLifecycle); + if (measure_frame_time) { + world->stats.merge_time_total += (float)ecs_time_measure(&t_start); + } - bootstrap_component(world, table, EcsType); - bootstrap_component(world, table, EcsQuery); - bootstrap_component(world, table, EcsTrigger); - bootstrap_component(world, table, EcsObserver); - bootstrap_component(world, table, EcsIterable); + world->stats.merge_count_total ++; - world->stats.last_component_id = EcsFirstUserComponentId; - world->stats.last_id = EcsFirstUserEntityId; - world->stats.min_id = 0; - world->stats.max_id = 0; + /* If stage is asynchronous, deferring is always enabled */ + if (stage->asynchronous) { + ecs_defer_begin((ecs_world_t*)stage); + } +} - /* Populate core module */ - ecs_set_scope(world, EcsFlecsCore); +static +void do_auto_merge( + ecs_world_t *world) +{ + merge_stages(world, false); +} - flecs_bootstrap_tag(world, EcsName); - flecs_bootstrap_tag(world, EcsSymbol); - flecs_bootstrap_tag(world, EcsAlias); +static +void do_manual_merge( + ecs_world_t *world) +{ + merge_stages(world, true); +} - flecs_bootstrap_tag(world, EcsModule); - flecs_bootstrap_tag(world, EcsPrivate); - flecs_bootstrap_tag(world, EcsPrefab); - flecs_bootstrap_tag(world, EcsDisabled); +bool flecs_defer_none( + ecs_world_t *world, + ecs_stage_t *stage) +{ + (void)world; + return (++ stage->defer) == 1; +} - /* Initialize builtin modules */ - ecs_set_name(world, EcsFlecs, "flecs"); - ecs_add_id(world, EcsFlecs, EcsModule); +bool flecs_defer_modified( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_id_t id) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpModified; + op->id = id; + op->is._1.entity = entity; + return true; + } else { + stage->defer ++; + } + + return false; +} - ecs_add_pair(world, EcsFlecsCore, EcsChildOf, EcsFlecs); - ecs_set_name(world, EcsFlecsCore, "core"); - ecs_add_id(world, EcsFlecsCore, EcsModule); +bool flecs_defer_clone( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_entity_t src, + bool clone_value) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpClone; + op->id = src; + op->is._1.entity = entity; + op->is._1.clone_value = clone_value; + return true; + } else { + stage->defer ++; + } + + return false; +} - ecs_add_pair(world, EcsFlecsHidden, EcsChildOf, EcsFlecs); - ecs_set_name(world, EcsFlecsHidden, "hidden"); - ecs_add_id(world, EcsFlecsHidden, EcsModule); +bool flecs_defer_delete( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpDelete; + op->is._1.entity = entity; + world->delete_count ++; + return true; + } else { + stage->defer ++; + } + return false; +} - /* Initialize builtin entities */ - bootstrap_entity(world, EcsWorld, "World", EcsFlecsCore); - bootstrap_entity(world, EcsThis, "This", EcsFlecsCore); - bootstrap_entity(world, EcsWildcard, "*", EcsFlecsCore); - bootstrap_entity(world, EcsAny, "_", EcsFlecsCore); +bool flecs_defer_clear( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpClear; + op->is._1.entity = entity; + world->clear_count ++; + return true; + } else { + stage->defer ++; + } + return false; +} - /* Component/relationship properties */ - flecs_bootstrap_tag(world, EcsTransitive); - flecs_bootstrap_tag(world, EcsReflexive); - flecs_bootstrap_tag(world, EcsSymmetric); - flecs_bootstrap_tag(world, EcsFinal); - flecs_bootstrap_tag(world, EcsDontInherit); - flecs_bootstrap_tag(world, EcsTag); - flecs_bootstrap_tag(world, EcsExclusive); - flecs_bootstrap_tag(world, EcsAcyclic); - flecs_bootstrap_tag(world, EcsWith); +bool flecs_defer_on_delete_action( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_id_t id, + ecs_entity_t action) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpOnDeleteAction; + op->id = id; + op->is._1.entity = action; + world->clear_count ++; + return true; + } else { + stage->defer ++; + } + return false; +} - flecs_bootstrap_tag(world, EcsOnDelete); - flecs_bootstrap_tag(world, EcsOnDeleteObject); - flecs_bootstrap_tag(world, EcsRemove); - flecs_bootstrap_tag(world, EcsDelete); - flecs_bootstrap_tag(world, EcsThrow); +bool flecs_defer_enable( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_id_t id, + bool enable) +{ + (void)world; + if (stage->defer) { + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = enable ? EcsOpEnable : EcsOpDisable; + op->is._1.entity = entity; + op->id = id; + return true; + } else { + stage->defer ++; + } + return false; +} - flecs_bootstrap_tag(world, EcsDefaultChildComponent); +bool flecs_defer_bulk_new( + ecs_world_t *world, + ecs_stage_t *stage, + int32_t count, + ecs_id_t id, + const ecs_entity_t **ids_out) +{ + if (stage->defer) { + ecs_entity_t *ids = ecs_os_malloc(count * ECS_SIZEOF(ecs_entity_t)); + world->bulk_new_count ++; - /* Builtin relations */ - flecs_bootstrap_tag(world, EcsIsA); - flecs_bootstrap_tag(world, EcsChildOf); + /* Use ecs_new_id as this is thread safe */ + int i; + for (i = 0; i < count; i ++) { + ids[i] = ecs_new_id(world); + } - /* Builtin events */ - bootstrap_entity(world, EcsOnAdd, "OnAdd", EcsFlecsCore); - bootstrap_entity(world, EcsOnRemove, "OnRemove", EcsFlecsCore); - bootstrap_entity(world, EcsOnSet, "OnSet", EcsFlecsCore); - bootstrap_entity(world, EcsUnSet, "UnSet", EcsFlecsCore); - bootstrap_entity(world, EcsOnTableEmpty, "OnTableEmpty", EcsFlecsCore); - bootstrap_entity(world, EcsOnTableFill, "OnTableFilled", EcsFlecsCore); + *ids_out = ids; - /* Transitive relations are always Acyclic */ - ecs_add_pair(world, EcsTransitive, EcsWith, EcsAcyclic); + /* Store data in op */ + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = EcsOpBulkNew; + op->id = id; + op->is._n.entities = ids; + op->is._n.count = count; - /* Transitive relations */ - ecs_add_id(world, EcsIsA, EcsTransitive); - ecs_add_id(world, EcsIsA, EcsReflexive); + return true; + } else { + stage->defer ++; + } - /* Tag relations (relations that should never have data) */ - ecs_add_id(world, EcsIsA, EcsTag); - ecs_add_id(world, EcsChildOf, EcsTag); - ecs_add_id(world, EcsDefaultChildComponent, EcsTag); + return false; +} - /* Acyclic relations */ - ecs_add_id(world, EcsIsA, EcsAcyclic); - ecs_add_id(world, EcsChildOf, EcsAcyclic); - ecs_add_id(world, EcsWith, EcsAcyclic); +bool flecs_defer_new( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_id_t id) +{ + return defer_add_remove(world, stage, EcsOpNew, entity, id); +} - /* Exclusive properties */ - ecs_add_id(world, EcsChildOf, EcsExclusive); - ecs_add_id(world, EcsOnDelete, EcsExclusive); - ecs_add_id(world, EcsOnDeleteObject, EcsExclusive); - ecs_add_id(world, EcsDefaultChildComponent, EcsExclusive); +bool flecs_defer_add( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_id_t id) +{ + return defer_add_remove(world, stage, EcsOpAdd, entity, id); +} - /* Make EcsOnAdd, EcsOnSet events iterable to enable .yield_existing */ - ecs_set(world, EcsOnAdd, EcsIterable, { .init = on_event_iterable_init }); - ecs_set(world, EcsOnSet, EcsIterable, { .init = on_event_iterable_init }); +bool flecs_defer_remove( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_entity_t entity, + ecs_id_t id) +{ + return defer_add_remove(world, stage, EcsOpRemove, entity, id); +} - /* Removal of ChildOf objects (parents) deletes the subject (child) */ - ecs_add_pair(world, EcsChildOf, EcsOnDeleteObject, EcsDelete); +bool flecs_defer_set( + ecs_world_t *world, + ecs_stage_t *stage, + ecs_defer_op_kind_t op_kind, + ecs_entity_t entity, + ecs_id_t id, + ecs_size_t size, + const void *value, + void **value_out, + bool *is_added) +{ + if (stage->defer) { + world->set_count ++; + if (!size) { + const EcsComponent *cptr = flecs_component_from_id(world, id); + ecs_check(cptr != NULL, ECS_INVALID_PARAMETER, NULL); + size = cptr->size; + } - /* ChildOf, Identifier, Disabled and Prefab should never be inherited */ - ecs_add_id(world, EcsChildOf, EcsDontInherit); - ecs_add_id(world, ecs_id(EcsIdentifier), EcsDontInherit); + ecs_defer_op_t *op = new_defer_op(stage); + op->kind = op_kind; + op->id = id; + op->is._1.entity = entity; + op->is._1.size = size; + op->is._1.value = ecs_os_malloc(size); - /* The (IsA, *) id record is used often in searches, so cache it */ - world->idr_isa_wildcard = flecs_ensure_id_record(world, - ecs_pair(EcsIsA, EcsWildcard)); + if (!value) { + value = ecs_get_id(world, entity, id); + if (is_added) { + *is_added = value == NULL; + } + } - ecs_trigger_init(world, &(ecs_trigger_desc_t) { - .term = { - .id = ecs_pair(EcsChildOf, EcsWildcard), - .subj.set.mask = EcsSelf - }, - .events = { EcsOnAdd, EcsOnRemove }, - .yield_existing = true, - .callback = on_parent_change - }); + const ecs_type_info_t *ti = NULL; + ecs_entity_t real_id = ecs_get_typeid(world, id); + if (real_id) { + ti = flecs_get_type_info(world, real_id); + } - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = EcsFinal, .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_final - }); + if (value) { + ecs_copy_t copy; + if (ti && (copy = ti->lifecycle.copy_ctor)) { + copy(world, &entity, &entity, op->is._1.value, value, 1, ti); + } else { + ecs_os_memcpy(op->is._1.value, value, size); + } + } else { + ecs_xtor_t ctor; + if (ti && (ctor = ti->lifecycle.ctor)) { + ctor(world, &entity, op->is._1.value, 1, ti); + } + } - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = ecs_pair(EcsOnDelete, EcsWildcard), .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_on_delete - }); + if (value_out) { + *value_out = op->is._1.value; + } - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = ecs_pair(EcsOnDeleteObject, EcsWildcard), .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_on_delete_object - }); + return true; + } else { + stage->defer ++; + } - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = EcsExclusive, .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_exclusive - }); +error: + return false; +} - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = EcsSymmetric, .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_symmetric +void flecs_stage_merge_post_frame( + ecs_world_t *world, + ecs_stage_t *stage) +{ + /* Execute post frame actions */ + ecs_vector_each(stage->post_frame_actions, ecs_action_elem_t, action, { + action->action(world, action->ctx); }); - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = EcsDontInherit, .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = register_dont_inherit - }); + ecs_vector_free(stage->post_frame_actions); + stage->post_frame_actions = NULL; +} - /* Define trigger to make sure that adding a module to a child entity also - * adds it to the parent. */ - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = EcsModule, .subj.set.mask = EcsSelf }, - .events = {EcsOnAdd}, - .callback = ensure_module_tag - }); +void flecs_stage_init( + ecs_world_t *world, + ecs_stage_t *stage) +{ + ecs_poly_assert(world, ecs_world_t); - /* Define trigger for when component lifecycle is set for component */ - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = ecs_id(EcsComponentLifecycle), .subj.set.mask = EcsSelf }, - .events = {EcsOnSet}, - .callback = on_set_component_lifecycle - }); + ecs_poly_init(stage, ecs_stage_t); - /* Define trigger for updating component size when it changes */ - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = ecs_id(EcsComponent), .subj.set.mask = EcsSelf }, - .events = {EcsOnSet}, - .callback = on_set_component - }); + stage->world = world; + stage->thread_ctx = world; + stage->auto_merge = true; + stage->asynchronous = false; +} - ecs_add_id(world, EcsDisabled, EcsDontInherit); - ecs_add_id(world, EcsPrefab, EcsDontInherit); +void flecs_stage_deinit( + ecs_world_t *world, + ecs_stage_t *stage) +{ + (void)world; + ecs_poly_assert(world, ecs_world_t); + ecs_poly_assert(stage, ecs_stage_t); - /* Run bootstrap functions for other parts of the code */ - flecs_bootstrap_hierarchy(world); + /* Make sure stage has no unmerged data */ + ecs_assert(ecs_vector_count(stage->defer_queue) == 0, + ECS_INTERNAL_ERROR, NULL); - ecs_set_scope(world, 0); + ecs_poly_fini(stage, ecs_stage_t); - ecs_log_pop(); + ecs_vector_free(stage->defer_queue); } -#include -#include - -#define ECS_NAME_BUFFER_LENGTH (64) - -static -bool path_append( - const ecs_world_t *world, - ecs_entity_t parent, - ecs_entity_t child, - const char *sep, - const char *prefix, - ecs_strbuf_t *buf) +void ecs_set_stages( + ecs_world_t *world, + int32_t stage_count) { ecs_poly_assert(world, ecs_world_t); - ecs_entity_t cur = 0; - char buff[22]; - const char *name; + ecs_stage_t *stages; + int32_t i, count = ecs_vector_count(world->worker_stages); - if (ecs_is_valid(world, child)) { - cur = ecs_get_object(world, child, EcsChildOf, 0); - if (cur) { - if (cur != parent && (cur != EcsFlecsCore || prefix != NULL)) { - path_append(world, parent, cur, sep, prefix, buf); - ecs_strbuf_appendstr(buf, sep); - } - } else if (prefix) { - ecs_strbuf_appendstr(buf, prefix); + if (count && count != stage_count) { + stages = ecs_vector_first(world->worker_stages, ecs_stage_t); + + for (i = 0; i < count; i ++) { + /* If stage contains a thread handle, ecs_set_threads was used to + * create the stages. ecs_set_threads and ecs_set_stages should not + * be mixed. */ + ecs_poly_assert(&stages[i], ecs_stage_t); + ecs_check(stages[i].thread == 0, ECS_INVALID_OPERATION, NULL); + flecs_stage_deinit(world, &stages[i]); } - name = ecs_get_name(world, child); - if (!name || !ecs_os_strlen(name)) { - ecs_os_sprintf(buff, "%u", (uint32_t)child); - name = buff; - } - } else { - ecs_os_sprintf(buff, "%u", (uint32_t)child); - name = buff; + ecs_vector_free(world->worker_stages); } - - ecs_strbuf_appendstr(buf, name); - - return cur != 0; -} - -static -bool is_number( - const char *name) -{ - ecs_assert(name != NULL, ECS_INTERNAL_ERROR, NULL); - if (!isdigit(name[0])) { - return false; - } + if (stage_count) { + world->worker_stages = ecs_vector_new(ecs_stage_t, stage_count); - ecs_size_t i, length = ecs_os_strlen(name); - for (i = 1; i < length; i ++) { - char ch = name[i]; + for (i = 0; i < stage_count; i ++) { + ecs_stage_t *stage = ecs_vector_add( + &world->worker_stages, ecs_stage_t); + flecs_stage_init(world, stage); + stage->id = 1 + i; /* 0 is reserved for main/temp stage */ - if (!isdigit(ch)) { - break; + /* Set thread_ctx to stage, as this stage might be used in a + * multithreaded context */ + stage->thread_ctx = (ecs_world_t*)stage; } + } else { + /* Set to NULL to prevent double frees */ + world->worker_stages = NULL; } - return i >= length; -} - -static -ecs_entity_t name_to_id( - const ecs_world_t *world, - const char *name) -{ - long int result = atol(name); - ecs_assert(result >= 0, ECS_INTERNAL_ERROR, NULL); - ecs_entity_t alive = ecs_get_alive(world, (ecs_entity_t)result); - if (alive) { - return alive; - } else { - return (ecs_entity_t)result; + /* Regardless of whether the stage was just initialized or not, when the + * ecs_set_stages function is called, all stages inherit the auto_merge + * property from the world */ + for (i = 0; i < stage_count; i ++) { + ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); + stage->auto_merge = world->stage.auto_merge; } +error: + return; } -static -ecs_entity_t get_builtin( - const char *name) +int32_t ecs_get_stage_count( + const ecs_world_t *world) { - if (name[0] == '.' && name[1] == '\0') { - return EcsThis; - } else if (name[0] == '*' && name[1] == '\0') { - return EcsWildcard; - } else if (name[0] == '_' && name[1] == '\0') { - return EcsAny; - } - - return 0; + world = ecs_get_world(world); + return ecs_vector_count(world->worker_stages); } -static -bool is_sep( - const char **ptr, - const char *sep) +int32_t ecs_get_stage_id( + const ecs_world_t *world) { - ecs_size_t len = ecs_os_strlen(sep); + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - if (!ecs_os_strncmp(*ptr, sep, len)) { - *ptr += len; - return true; + if (ecs_poly_is(world, ecs_stage_t)) { + ecs_stage_t *stage = (ecs_stage_t*)world; + + /* Index 0 is reserved for main stage */ + return stage->id - 1; + } else if (ecs_poly_is(world, ecs_world_t)) { + return 0; } else { - return false; + ecs_throw(ECS_INTERNAL_ERROR, NULL); } +error: + return 0; } -static -const char* path_elem( - const char *path, - const char *sep, - int32_t *len) +ecs_world_t* ecs_get_stage( + const ecs_world_t *world, + int32_t stage_id) { - const char *ptr; - char ch; - int32_t template_nesting = 0; - int32_t count = 0; - - for (ptr = path; (ch = *ptr); ptr ++) { - if (ch == '<') { - template_nesting ++; - } else if (ch == '>') { - template_nesting --; - } - - ecs_check(template_nesting >= 0, ECS_INVALID_PARAMETER, path); - - if (!template_nesting && is_sep(&ptr, sep)) { - break; - } - - count ++; - } - - if (len) { - *len = count; - } + ecs_poly_assert(world, ecs_world_t); + ecs_check(ecs_vector_count(world->worker_stages) > stage_id, + ECS_INVALID_PARAMETER, NULL); - if (count) { - return ptr; - } else { - return NULL; - } + return (ecs_world_t*)ecs_vector_get( + world->worker_stages, ecs_stage_t, stage_id); error: return NULL; } -static -ecs_entity_t get_parent_from_path( - const ecs_world_t *world, - ecs_entity_t parent, - const char **path_ptr, - const char *prefix, - bool new_entity) +bool ecs_staging_begin( + ecs_world_t *world) { - bool start_from_root = false; - const char *path = *path_ptr; - - if (prefix) { - ecs_size_t len = ecs_os_strlen(prefix); - if (!ecs_os_strncmp(path, prefix, len)) { - path += len; - parent = 0; - start_from_root = true; - } - } + ecs_poly_assert(world, ecs_world_t); - if (!start_from_root && !parent && new_entity) { - parent = ecs_get_scope(world); + flecs_process_pending_tables(world); + + int32_t i, count = ecs_get_stage_count(world); + for (i = 0; i < count; i ++) { + ecs_world_t *stage = ecs_get_stage(world, i); + ((ecs_stage_t*)stage)->lookup_path = world->stage.lookup_path; + ecs_defer_begin(stage); } - *path_ptr = path; + bool is_readonly = world->is_readonly; - return parent; -} + /* From this point on, the world is "locked" for mutations, and it is only + * allowed to enqueue commands from stages */ + world->is_readonly = true; -static -void on_set_symbol(ecs_iter_t *it) { - EcsIdentifier *n = ecs_term(it, EcsIdentifier, 1); - ecs_world_t *world = it->world; + ecs_dbg_3("staging: begin"); - int i; - for (i = 0; i < it->count; i ++) { - ecs_entity_t e = it->entities[i]; - flecs_name_index_ensure( - &world->symbols, e, n[i].value, n[i].length, n[i].hash); - } + return is_readonly; } -void flecs_bootstrap_hierarchy(ecs_world_t *world) { - ecs_trigger_init(world, &(ecs_trigger_desc_t){ - .term = {.id = ecs_pair(ecs_id(EcsIdentifier), EcsSymbol), .subj.set.mask = EcsSelf }, - .callback = on_set_symbol, - .events = {EcsOnSet}, - .yield_existing = true - }); -} +void ecs_staging_end( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_world_t); + ecs_check(world->is_readonly == true, ECS_INVALID_OPERATION, NULL); + /* After this it is safe again to mutate the world directly */ + world->is_readonly = false; -/* Public functions */ + ecs_dbg_3("staging: end"); -void ecs_get_path_w_sep_buf( - const ecs_world_t *world, - ecs_entity_t parent, - ecs_entity_t child, - const char *sep, - const char *prefix, - ecs_strbuf_t *buf) + do_auto_merge(world); +error: + return; +} + +void ecs_merge( + ecs_world_t *world) { ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_check(buf != NULL, ECS_INVALID_PARAMETER, NULL); + ecs_check(ecs_poly_is(world, ecs_world_t) || + ecs_poly_is(world, ecs_stage_t), ECS_INVALID_PARAMETER, NULL); + do_manual_merge(world); +error: + return; +} - world = ecs_get_world(world); +void ecs_set_automerge( + ecs_world_t *world, + bool auto_merge) +{ + /* If a world is provided, set auto_merge globally for the world. This + * doesn't actually do anything (the main stage never merges) but it serves + * as the default for when stages are created. */ + if (ecs_poly_is(world, ecs_world_t)) { + world->stage.auto_merge = auto_merge; - if (child == EcsThis) { - ecs_strbuf_appendstr(buf, "."); - return; - } - if (child == EcsWildcard) { - ecs_strbuf_appendstr(buf, "*"); - return; - } - if (child == EcsAny) { - ecs_strbuf_appendstr(buf, "_"); - return; + /* Propagate change to all stages */ + int i, stage_count = ecs_get_stage_count(world); + for (i = 0; i < stage_count; i ++) { + ecs_stage_t *stage = (ecs_stage_t*)ecs_get_stage(world, i); + stage->auto_merge = auto_merge; + } + + /* If a stage is provided, override the auto_merge value for the individual + * stage. This allows an application to control per-stage which stage should + * be automatically merged and which one shouldn't */ + } else { + ecs_poly_assert(world, ecs_stage_t); + ecs_stage_t *stage = (ecs_stage_t*)world; + stage->auto_merge = auto_merge; } +} - if (!sep) { - sep = "."; +bool ecs_stage_is_readonly( + const ecs_world_t *stage) +{ + const ecs_world_t *world = ecs_get_world(stage); + + if (ecs_poly_is(stage, ecs_stage_t)) { + if (((ecs_stage_t*)stage)->asynchronous) { + return false; + } } - if (!child || parent != child) { - path_append(world, parent, child, sep, prefix, buf); + if (world->is_readonly) { + if (ecs_poly_is(stage, ecs_world_t)) { + return true; + } } else { - ecs_strbuf_appendstr(buf, ""); + if (ecs_poly_is(stage, ecs_stage_t)) { + return true; + } } -error: - return; + return false; } -char* ecs_get_path_w_sep( - const ecs_world_t *world, - ecs_entity_t parent, - ecs_entity_t child, - const char *sep, - const char *prefix) +ecs_world_t* ecs_async_stage_new( + ecs_world_t *world) { - ecs_strbuf_t buf = ECS_STRBUF_INIT; - ecs_get_path_w_sep_buf(world, parent, child, sep, prefix, &buf); - return ecs_strbuf_get(&buf); -} + ecs_stage_t *stage = ecs_os_calloc(sizeof(ecs_stage_t)); + flecs_stage_init(world, stage); -ecs_entity_t ecs_lookup_child( - const ecs_world_t *world, - ecs_entity_t parent, - const char *name) -{ - ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); + stage->id = -1; + stage->auto_merge = false; + stage->asynchronous = true; - if (is_number(name)) { - return name_to_id(world, name); - } + ecs_defer_begin((ecs_world_t*)stage); - ecs_id_t pair = ecs_childof(parent); - ecs_hashmap_t *index = flecs_get_id_name_index(world, pair); - if (index) { - return flecs_name_index_find(index, name, 0, 0); - } else { - return 0; - } + return (ecs_world_t*)stage; +} + +void ecs_async_stage_free( + ecs_world_t *world) +{ + ecs_poly_assert(world, ecs_stage_t); + ecs_stage_t *stage = (ecs_stage_t*)world; + ecs_check(stage->asynchronous == true, ECS_INVALID_PARAMETER, NULL); + flecs_stage_deinit(stage->world, stage); + ecs_os_free(stage); error: - return 0; + return; } -ecs_entity_t ecs_lookup( - const ecs_world_t *world, - const char *name) -{ - if (!name) { - return 0; +bool ecs_stage_is_async( + ecs_world_t *stage) +{ + if (!stage) { + return false; } - - ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); - world = ecs_get_world(world); - - ecs_entity_t e = get_builtin(name); - if (e) { - return e; + + if (!ecs_poly_is(stage, ecs_stage_t)) { + return false; } - if (is_number(name)) { - return name_to_id(world, name); - } + return ((ecs_stage_t*)stage)->asynchronous; +} - e = flecs_name_index_find(&world->aliases, name, 0, 0); - if (e) { - return e; - } - - return ecs_lookup_child(world, 0, name); +bool ecs_is_deferred( + const ecs_world_t *world) +{ + ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); + return stage->defer != 0; error: - return 0; + return false; } -ecs_entity_t ecs_lookup_symbol( - const ecs_world_t *world, - const char *name, - bool lookup_as_path) -{ - if (!name) { - return 0; - } +#include +#include - ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); - world = ecs_get_world(world); +void ecs_os_api_impl(ecs_os_api_t *api); - ecs_entity_t e = flecs_name_index_find(&world->symbols, name, 0, 0); - if (e) { - return e; - } +static bool ecs_os_api_initialized = false; +static bool ecs_os_api_initializing = false; +static int ecs_os_api_init_count = 0; - if (lookup_as_path) { - return ecs_lookup_fullpath(world, name); - } +#ifndef __EMSCRIPTEN__ +ecs_os_api_t ecs_os_api = { + .log_with_color_ = true, + .log_level_ = -1 /* disable tracing by default, but enable >= warnings */ +}; +#else +/* Disable colors by default for emscripten */ +ecs_os_api_t ecs_os_api = { + .log_level_ = -1 +}; +#endif -error: - return 0; +int64_t ecs_os_api_malloc_count = 0; +int64_t ecs_os_api_realloc_count = 0; +int64_t ecs_os_api_calloc_count = 0; +int64_t ecs_os_api_free_count = 0; + +void ecs_os_set_api( + ecs_os_api_t *os_api) +{ + if (!ecs_os_api_initialized) { + ecs_os_api = *os_api; + ecs_os_api_initialized = true; + } } -ecs_entity_t ecs_lookup_path_w_sep( - const ecs_world_t *world, - ecs_entity_t parent, - const char *path, - const char *sep, - const char *prefix, - bool recursive) +void ecs_os_init(void) { - if (!path) { - return 0; + if (!ecs_os_api_initialized) { + ecs_os_set_api_defaults(); + } + + if (!(ecs_os_api_init_count ++)) { + if (ecs_os_api.init_) { + ecs_os_api.init_(); + } } +} - if (!sep) { - sep = "."; +void ecs_os_fini(void) { + if (!--ecs_os_api_init_count) { + if (ecs_os_api.fini_) { + ecs_os_api.fini_(); + } } +} + +#if !defined(ECS_TARGET_WINDOWS) && !defined(ECS_TARGET_EM) && !defined(ECS_TARGET_ANDROID) +#include +#define ECS_BT_BUF_SIZE 100 +static +void dump_backtrace( + FILE *stream) +{ + int nptrs; + void *buffer[ECS_BT_BUF_SIZE]; + char **strings; - ecs_check(world != NULL, ECS_INTERNAL_ERROR, NULL); - const ecs_world_t *stage = world; - world = ecs_get_world(world); + nptrs = backtrace(buffer, ECS_BT_BUF_SIZE); - ecs_entity_t e = get_builtin(path); - if (e) { - return e; + strings = backtrace_symbols(buffer, nptrs); + if (strings == NULL) { + return; } - e = flecs_name_index_find(&world->aliases, path, 0, 0); - if (e) { - return e; + for (int j = 3; j < nptrs; j++) { + fprintf(stream, "%s\n", strings[j]); } - char buff[ECS_NAME_BUFFER_LENGTH]; - const char *ptr, *ptr_start; - char *elem = buff; - int32_t len, size = ECS_NAME_BUFFER_LENGTH; - ecs_entity_t cur; - bool lookup_path_search = false; + free(strings); +} +#else +static +void dump_backtrace( + FILE *stream) +{ + (void)stream; +} +#endif - ecs_entity_t *lookup_path = ecs_get_lookup_path(stage); - ecs_entity_t *lookup_path_cur = lookup_path; - while (lookup_path_cur && *lookup_path_cur) { - lookup_path_cur ++; +static +void log_msg( + int32_t level, + const char *file, + int32_t line, + const char *msg) +{ + FILE *stream; + if (level >= 0) { + stream = stdout; + } else { + stream = stderr; } - if (!sep) { - sep = "."; + if (level >= 0) { + if (level == 0) { + if (ecs_os_api.log_with_color_) fputs(ECS_MAGENTA, stream); + } else { + if (ecs_os_api.log_with_color_) fputs(ECS_GREY, stream); + } + fputs("info", stream); + } else if (level == -2) { + if (ecs_os_api.log_with_color_) fputs(ECS_YELLOW, stream); + fputs("warning", stream); + } else if (level == -3) { + if (ecs_os_api.log_with_color_) fputs(ECS_RED, stream); + fputs("error", stream); + } else if (level == -4) { + if (ecs_os_api.log_with_color_) fputs(ECS_RED, stream); + fputs("fatal", stream); } - parent = get_parent_from_path(stage, parent, &path, prefix, true); + if (ecs_os_api.log_with_color_) fputs(ECS_NORMAL, stream); + fputs(": ", stream); -retry: - cur = parent; - ptr_start = ptr = path; + if (level >= 0) { + if (ecs_os_api.log_indent_) { + char indent[32]; + int i, indent_count = ecs_os_api.log_indent_; + if (indent_count > 15) indent_count = 15; - while ((ptr = path_elem(ptr, sep, &len))) { - if (len < size) { - ecs_os_memcpy(elem, ptr_start, len); - } else { - if (size == ECS_NAME_BUFFER_LENGTH) { - elem = NULL; + for (i = 0; i < indent_count; i ++) { + indent[i * 2] = '|'; + indent[i * 2 + 1] = ' '; } - elem = ecs_os_realloc(elem, len + 1); - ecs_os_memcpy(elem, ptr_start, len); - size = len + 1; - } + if (ecs_os_api.log_indent_ != indent_count) { + indent[i * 2 - 2] = '+'; + } - elem[len] = '\0'; - ptr_start = ptr; + indent[i * 2] = '\0'; - cur = ecs_lookup_child(world, cur, elem); - if (!cur) { - goto tail; + fputs(indent, stream); } } -tail: - if (!cur && recursive) { - if (!lookup_path_search) { - if (parent) { - parent = ecs_get_object(world, parent, EcsChildOf, 0); - goto retry; - } else { - lookup_path_search = true; + if (level < 0) { + if (file) { + const char *file_ptr = strrchr(file, '/'); + if (!file_ptr) { + file_ptr = strrchr(file, '\\'); } - } - if (lookup_path_search) { - if (lookup_path_cur != lookup_path) { - lookup_path_cur --; - parent = lookup_path_cur[0]; - goto retry; + if (file_ptr) { + file = file_ptr + 1; } + + fputs(file, stream); + fputs(": ", stream); } - } - if (elem != buff) { - ecs_os_free(elem); + if (line) { + fprintf(stream, "%d: ", line); + } } - return cur; -error: - return 0; -} - -ecs_entity_t ecs_set_scope( - ecs_world_t *world, - ecs_entity_t scope) -{ - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_stage_t *stage = flecs_stage_from_world(&world); + fputs(msg, stream); - ecs_entity_t cur = stage->scope; - stage->scope = scope; + fputs("\n", stream); - return cur; -error: - return 0; + if (level == -4) { + dump_backtrace(stream); + } } -ecs_entity_t ecs_get_scope( - const ecs_world_t *world) +void ecs_os_dbg( + const char *file, + int32_t line, + const char *msg) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); - return stage->scope; -error: - return 0; + if (ecs_os_api.log_) { + ecs_os_api.log_(1, file, line, msg); + } } -ecs_entity_t* ecs_set_lookup_path( - ecs_world_t *world, - const ecs_entity_t *lookup_path) +void ecs_os_trace( + const char *file, + int32_t line, + const char *msg) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - ecs_stage_t *stage = flecs_stage_from_world(&world); - - ecs_entity_t *cur = stage->lookup_path; - stage->lookup_path = (ecs_entity_t*)lookup_path; - - return cur; -error: - return NULL; + if (ecs_os_api.log_) { + ecs_os_api.log_(0, file, line, msg); + } } -ecs_entity_t* ecs_get_lookup_path( - const ecs_world_t *world) +void ecs_os_warn( + const char *file, + int32_t line, + const char *msg) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); - const ecs_stage_t *stage = flecs_stage_from_readonly_world(world); - return stage->lookup_path; -error: - return NULL; + if (ecs_os_api.log_) { + ecs_os_api.log_(-2, file, line, msg); + } } -const char* ecs_set_name_prefix( - ecs_world_t *world, - const char *prefix) +void ecs_os_err( + const char *file, + int32_t line, + const char *msg) { - ecs_poly_assert(world, ecs_world_t); - const char *old_prefix = world->name_prefix; - world->name_prefix = prefix; - return old_prefix; + if (ecs_os_api.log_) { + ecs_os_api.log_(-3, file, line, msg); + } } -ecs_entity_t ecs_add_path_w_sep( - ecs_world_t *world, - ecs_entity_t entity, - ecs_entity_t parent, - const char *path, - const char *sep, - const char *prefix) +void ecs_os_fatal( + const char *file, + int32_t line, + const char *msg) { - ecs_check(world != NULL, ECS_INVALID_PARAMETER, NULL); + if (ecs_os_api.log_) { + ecs_os_api.log_(-4, file, line, msg); + } +} - if (!sep) { - sep = "."; - } +static +void ecs_os_gettime(ecs_time_t *time) { + ecs_assert(ecs_os_has_time() == true, ECS_MISSING_OS_API, NULL); + + uint64_t now = ecs_os_now(); + uint64_t sec = now / 1000000000; - if (!path) { - if (!entity) { - entity = ecs_new_id(world); - } + assert(sec < UINT32_MAX); + assert((now - sec * 1000000000) < UINT32_MAX); - if (parent) { - ecs_add_pair(world, entity, EcsChildOf, entity); - } + time->sec = (uint32_t)sec; + time->nanosec = (uint32_t)(now - sec * 1000000000); +} - return entity; - } +static +void* ecs_os_api_malloc(ecs_size_t size) { + ecs_os_api_malloc_count ++; + ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); + return malloc((size_t)size); +} - parent = get_parent_from_path(world, parent, &path, prefix, entity == 0); +static +void* ecs_os_api_calloc(ecs_size_t size) { + ecs_os_api_calloc_count ++; + ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); + return calloc(1, (size_t)size); +} - char buff[ECS_NAME_BUFFER_LENGTH]; - const char *ptr = path; - const char *ptr_start = path; - char *elem = buff; - int32_t len, size = ECS_NAME_BUFFER_LENGTH; +static +void* ecs_os_api_realloc(void *ptr, ecs_size_t size) { + ecs_assert(size > 0, ECS_INVALID_PARAMETER, NULL); - ecs_entity_t cur = parent; + if (ptr) { + ecs_os_api_realloc_count ++; + } else { + /* If not actually reallocing, treat as malloc */ + ecs_os_api_malloc_count ++; + } + + return realloc(ptr, (size_t)size); +} - char *name = NULL; +static +void ecs_os_api_free(void *ptr) { + if (ptr) { + ecs_os_api_free_count ++; + } + free(ptr); +} - while ((ptr = path_elem(ptr, sep, &len))) { - if (len < size) { - ecs_os_memcpy(elem, ptr_start, len); - } else { - if (size == ECS_NAME_BUFFER_LENGTH) { - elem = NULL; - } +static +char* ecs_os_api_strdup(const char *str) { + if (str) { + int len = ecs_os_strlen(str); + char *result = ecs_os_malloc(len + 1); + ecs_assert(result != NULL, ECS_OUT_OF_MEMORY, NULL); + ecs_os_strcpy(result, str); + return result; + } else { + return NULL; + } +} - elem = ecs_os_realloc(elem, len + 1); - ecs_os_memcpy(elem, ptr_start, len); - size = len + 1; +/* Replace dots with underscores */ +static +char *module_file_base(const char *module, char sep) { + char *base = ecs_os_strdup(module); + ecs_size_t i, len = ecs_os_strlen(base); + for (i = 0; i < len; i ++) { + if (base[i] == '.') { + base[i] = sep; } + } - elem[len] = '\0'; - ptr_start = ptr; + return base; +} - ecs_entity_t e = ecs_lookup_child(world, cur, elem); - if (!e) { - if (name) { - ecs_os_free(name); - } +static +char* ecs_os_api_module_to_dl(const char *module) { + ecs_strbuf_t lib = ECS_STRBUF_INIT; - name = ecs_os_strdup(elem); + /* Best guess, use module name with underscores + OS library extension */ + char *file_base = module_file_base(module, '_'); - /* If this is the last entity in the path, use the provided id */ - bool last_elem = false; - if (!path_elem(ptr, sep, NULL)) { - e = entity; - last_elem = true; - } +# if defined(ECS_TARGET_LINUX) || defined(ECS_TARGET_FREEBSD) + ecs_strbuf_appendstr(&lib, "lib"); + ecs_strbuf_appendstr(&lib, file_base); + ecs_strbuf_appendstr(&lib, ".so"); +# elif defined(ECS_TARGET_DARWIN) + ecs_strbuf_appendstr(&lib, "lib"); + ecs_strbuf_appendstr(&lib, file_base); + ecs_strbuf_appendstr(&lib, ".dylib"); +# elif defined(ECS_TARGET_WINDOWS) + ecs_strbuf_appendstr(&lib, file_base); + ecs_strbuf_appendstr(&lib, ".dll"); +# endif - if (!e) { - if (last_elem) { - ecs_entity_t prev = ecs_set_scope(world, 0); - e = ecs_new(world, 0); - ecs_set_scope(world, prev); - } else { - e = ecs_new_id(world); - } - } + ecs_os_free(file_base); - if (cur) { - ecs_add_pair(world, e, EcsChildOf, cur); - } + return ecs_strbuf_get(&lib); +} - ecs_set_name(world, e, name); - } +static +char* ecs_os_api_module_to_etc(const char *module) { + ecs_strbuf_t lib = ECS_STRBUF_INIT; - cur = e; + /* Best guess, use module name with dashes + /etc */ + char *file_base = module_file_base(module, '-'); + + ecs_strbuf_appendstr(&lib, file_base); + ecs_strbuf_appendstr(&lib, "/etc"); + + ecs_os_free(file_base); + + return ecs_strbuf_get(&lib); +} + +void ecs_os_set_api_defaults(void) +{ + /* Don't overwrite if already initialized */ + if (ecs_os_api_initialized != 0) { + return; } - if (entity && (cur != entity)) { - ecs_throw(ECS_ALREADY_DEFINED, name); + if (ecs_os_api_initializing != 0) { + return; } - if (name) { - ecs_os_free(name); + ecs_os_api_initializing = true; + + /* Memory management */ + ecs_os_api.malloc_ = ecs_os_api_malloc; + ecs_os_api.free_ = ecs_os_api_free; + ecs_os_api.realloc_ = ecs_os_api_realloc; + ecs_os_api.calloc_ = ecs_os_api_calloc; + + /* Strings */ + ecs_os_api.strdup_ = ecs_os_api_strdup; + + /* Time */ + ecs_os_api.get_time_ = ecs_os_gettime; + + /* Logging */ + ecs_os_api.log_ = log_msg; + + /* Modules */ + if (!ecs_os_api.module_to_dl_) { + ecs_os_api.module_to_dl_ = ecs_os_api_module_to_dl; } - if (elem != buff) { - ecs_os_free(elem); + if (!ecs_os_api.module_to_etc_) { + ecs_os_api.module_to_etc_ = ecs_os_api_module_to_etc; } - return cur; -error: - return 0; + ecs_os_api.abort_ = abort; + +# ifdef FLECS_OS_API_IMPL + /* Initialize defaults to OS API IMPL addon, but still allow for overriding + * by the application */ + ecs_set_os_api_impl(); + ecs_os_api_initialized = false; +# endif + + ecs_os_api_initializing = false; } -ecs_entity_t ecs_new_from_path_w_sep( - ecs_world_t *world, - ecs_entity_t parent, - const char *path, - const char *sep, - const char *prefix) -{ - if (!sep) { - sep = "."; +bool ecs_os_has_heap(void) { + return + (ecs_os_api.malloc_ != NULL) && + (ecs_os_api.calloc_ != NULL) && + (ecs_os_api.realloc_ != NULL) && + (ecs_os_api.free_ != NULL); +} + +bool ecs_os_has_threading(void) { + return + (ecs_os_api.mutex_new_ != NULL) && + (ecs_os_api.mutex_free_ != NULL) && + (ecs_os_api.mutex_lock_ != NULL) && + (ecs_os_api.mutex_unlock_ != NULL) && + (ecs_os_api.cond_new_ != NULL) && + (ecs_os_api.cond_free_ != NULL) && + (ecs_os_api.cond_wait_ != NULL) && + (ecs_os_api.cond_signal_ != NULL) && + (ecs_os_api.cond_broadcast_ != NULL) && + (ecs_os_api.thread_new_ != NULL) && + (ecs_os_api.thread_join_ != NULL); +} + +bool ecs_os_has_time(void) { + return + (ecs_os_api.get_time_ != NULL) && + (ecs_os_api.sleep_ != NULL) && + (ecs_os_api.now_ != NULL) && + (ecs_os_api.enable_high_timer_resolution_ != NULL); +} + +bool ecs_os_has_logging(void) { + return (ecs_os_api.log_ != NULL); +} + +bool ecs_os_has_dl(void) { + return + (ecs_os_api.dlopen_ != NULL) && + (ecs_os_api.dlproc_ != NULL) && + (ecs_os_api.dlclose_ != NULL); +} + +bool ecs_os_has_modules(void) { + return + (ecs_os_api.module_to_dl_ != NULL) && + (ecs_os_api.module_to_etc_ != NULL); +} + +void ecs_os_enable_high_timer_resolution(bool enable) { + if (ecs_os_api.enable_high_timer_resolution_) { + ecs_os_api.enable_high_timer_resolution_(enable); + } else { + ecs_assert(enable == false, ECS_MISSING_OS_API, + "enable_high_timer_resolution"); } +} - return ecs_add_path_w_sep(world, 0, parent, path, sep, prefix); +#if defined(ECS_TARGET_WINDOWS) +static char error_str[255]; +#endif + +const char* ecs_os_strerror(int err) { +# if defined(ECS_TARGET_WINDOWS) + strerror_s(error_str, 255, err); + return error_str; +# else + return strerror(err); +# endif } diff --git a/src/bootstrap.c b/src/bootstrap.c index b8432436b..e89154ddc 100644 --- a/src/bootstrap.c +++ b/src/bootstrap.c @@ -584,8 +584,12 @@ void flecs_bootstrap( /* Bootstrap type info (otherwise initialized by setting EcsComponent) */ flecs_init_type_info_t(world, EcsComponent); flecs_init_type_info_t(world, EcsIdentifier); + flecs_init_type_info_t(world, EcsComponentLifecycle); + flecs_init_type_info_t(world, EcsType); + flecs_init_type_info_t(world, EcsQuery); flecs_init_type_info_t(world, EcsTrigger); flecs_init_type_info_t(world, EcsObserver); + flecs_init_type_info_t(world, EcsIterable); /* Setup component lifecycle actions */ ecs_set_component_actions(world, EcsComponent, { diff --git a/src/table.c b/src/table.c index f497a29a3..5c7df16de 100644 --- a/src/table.c +++ b/src/table.c @@ -242,24 +242,24 @@ void init_storage_table( } static -ecs_flags32_t get_component_action_flags( - const ecs_type_info_t *c_info) +ecs_flags32_t type_info_flags( + const ecs_type_info_t *ti) { ecs_flags32_t flags = 0; - if (c_info->lifecycle.ctor) { + if (ti->lifecycle.ctor) { flags |= EcsTableHasCtors; } - if (c_info->lifecycle.dtor) { + if (ti->lifecycle.dtor) { flags |= EcsTableHasDtors; } - if (c_info->lifecycle.on_remove) { + if (ti->lifecycle.on_remove) { flags |= EcsTableHasDtors; } - if (c_info->lifecycle.copy) { + if (ti->lifecycle.copy) { flags |= EcsTableHasCopy; } - if (c_info->lifecycle.move) { + if (ti->lifecycle.move) { flags |= EcsTableHasMove; } @@ -271,11 +271,22 @@ void init_type_info( ecs_world_t *world, ecs_table_t *table) { - ecs_type_t type = table->storage_type; - if (!type) { + ecs_table_t *storage_table = table->storage_table; + if (!storage_table) { return; } + if (storage_table != table) { + /* Because the storage table is guaranteed to have the same components + * (but not tags) as this table, we can share the type info cache */ + table->type_info = storage_table->type_info; + table->flags |= storage_table->flags; + return; + } + + ecs_type_t type = table->storage_type; + ecs_assert(type != NULL, ECS_INTERNAL_ERROR, NULL); + ecs_id_t *ids = ecs_vector_first(type, ecs_id_t); int32_t i, count = ecs_vector_count(type); @@ -285,11 +296,10 @@ void init_type_info( ecs_id_t id = ids[i]; ecs_entity_t t = ecs_get_typeid(world, id); + /* Component type info must have been registered before using it */ const ecs_type_info_t *ti = flecs_get_type_info(world, t); - if (ti) { - table->flags |= get_component_action_flags(ti); - } - + ecs_assert(ti != NULL, ECS_INTERNAL_ERROR, NULL); + table->flags |= type_info_flags(ti); table->type_info[i] = (ecs_type_info_t*)ti; } } @@ -801,14 +811,15 @@ void flecs_table_free( ecs_os_free(table->dirty_state); ecs_os_free(table->storage_map); - if (table->type_info) { - ecs_os_free(table->type_info); - } - flecs_table_records_unregister(world, table); - if (table->storage_table && table->storage_table != table) { - flecs_table_release(world, table->storage_table); + ecs_table_t *storage_table = table->storage_table; + if (storage_table == table) { + if (table->type_info) { + ecs_os_free(table->type_info); + } + } else if (storage_table) { + flecs_table_release(world, storage_table); } if (!world->is_fini) { @@ -1274,7 +1285,7 @@ int32_t flecs_table_append( if (c_info_array) { c_info = c_info_array[i]; } - + grow_column(world, entities, column, c_info, 1, size, construct); ecs_assert(