Merge branch 'master' into multitrait

bhaller · bhaller · commit cd8d650ad3eb · 2026-05-30T15:23:12.000+01:00
diff --git a/VERSIONS b/VERSIONS
@@ -7,6 +7,7 @@ Note that not every commit will be logged here; that is what the Github commit h
 
 development head (in the master branch):
 	add a rmultinom() function to draw from a multinomial distribution, matching rmultinom() in R
+	update to tskit 1.0.3, kastore 0.3.5, to get final changes for the json_struct codec stuff (no longer directly supported in C)
 
 
 multitrait branch:
diff --git a/treerec/tskit/core.c b/treerec/tskit/core.c
@@ -141,66 +141,6 @@ tsk_generate_uuid(char *dest, int TSK_UNUSED(flags))
     return ret;
 }
 
-int
-tsk_json_struct_metadata_get_blob(char *metadata, tsk_size_t metadata_length,
-    char **json, tsk_size_t *json_length, char **blob,
-    tsk_size_t *blob_length)
-{
-    int ret;
-    uint8_t version;
-    uint64_t json_length_u64;
-    uint64_t binary_length_u64;
-    uint64_t header_and_json_length;
-    uint64_t total_length;
-    uint8_t *bytes;
-    char *blob_start;
-    char *json_start;
-
-    if (metadata == NULL || json == NULL || json_length == NULL || blob == NULL
-        || blob_length == NULL) {
-        ret = tsk_trace_error(TSK_ERR_BAD_PARAM_VALUE);
-        goto out;
-    }
-    bytes = (uint8_t *) metadata;
-    if (metadata_length < TSK_JSON_BINARY_HEADER_SIZE) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_TRUNCATED);
-        goto out;
-    }
-    if (memcmp(bytes, _tsk_json_binary_magic, sizeof(_tsk_json_binary_magic)) != 0) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_BAD_MAGIC);
-        goto out;
-    }
-    version = bytes[4];
-    if (version != 1) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_BAD_VERSION);
-        goto out;
-    }
-    json_length_u64 = tsk_load_u64_le(bytes + 5);
-    binary_length_u64 = tsk_load_u64_le(bytes + 13);
-    if (json_length_u64 > UINT64_MAX - (uint64_t) TSK_JSON_BINARY_HEADER_SIZE) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_INVALID_LENGTH);
-        goto out;
-    }
-    header_and_json_length = (uint64_t) TSK_JSON_BINARY_HEADER_SIZE + json_length_u64;
-    if (binary_length_u64 > UINT64_MAX - header_and_json_length) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_INVALID_LENGTH);
-        goto out;
-    }
-    total_length = header_and_json_length + binary_length_u64;
-    if ((uint64_t) metadata_length < total_length) {
-        ret = tsk_trace_error(TSK_ERR_JSON_STRUCT_METADATA_TRUNCATED);
-        goto out;
-    }
-    json_start = (char *) bytes + TSK_JSON_BINARY_HEADER_SIZE;
-    blob_start = (char *) bytes + TSK_JSON_BINARY_HEADER_SIZE + json_length_u64;
-    *json = json_start;
-    *json_length = (tsk_size_t) json_length_u64;
-    *blob = blob_start;
-    *blob_length = (tsk_size_t) binary_length_u64;
-    ret = 0;
-out:
-    return ret;
-}
 static const char *
 tsk_strerror_internal(int err)
 {
diff --git a/treerec/tskit/haplotype_matching.c b/treerec/tskit/haplotype_matching.c
@@ -572,15 +572,15 @@ static inline bool
 element_in(
     const uint64_t *restrict A, tsk_id_t u, const tsk_id_t state, tsk_size_t num_words)
 {
-    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t)(state / 64);
+    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);
     return (A[index] & (1ULL << (state % 64))) != 0;
 }
 
 static inline void
 set_optimal_value(
     uint64_t *restrict A, tsk_id_t u, const tsk_size_t num_words, tsk_id_t state)
 {
-    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t)(state / 64);
+    tsk_size_t index = ((tsk_size_t) u) * num_words + (tsk_size_t) (state / 64);
     tsk_bug_assert(((tsk_size_t) state) / 64 < num_words);
     A[index] |= 1ULL << (state % 64);
 }
@@ -815,7 +815,7 @@ tsk_ls_hmm_redistribute_transitions(tsk_ls_hmm_t *self)
      * iterating over the roots. See the existing parsimony implementations
      * for an example. */
     for (root = tsk_tree_get_left_root(&self->tree); root != TSK_NULL;
-         root = right_sib[root]) {
+        root = right_sib[root]) {
         stack[0].tree_node = root;
         stack[0].old_state = T_old[T_index[root]].value_index;
         stack[0].new_state
@@ -966,7 +966,7 @@ tsk_ls_hmm_run_forward(tsk_ls_hmm_t *self, int32_t *haplotype)
     }
 
     for (t_ret = tsk_tree_first(&self->tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_next(&self->tree)) {
+        t_ret = tsk_tree_next(&self->tree)) {
         ret = tsk_ls_hmm_update_tree(self, TSK_DIR_FORWARD);
         if (ret != 0) {
             goto out;
@@ -1166,7 +1166,7 @@ tsk_ls_hmm_run_backward(
     }
 
     for (t_ret = tsk_tree_last(&self->tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_prev(&self->tree)) {
+        t_ret = tsk_tree_prev(&self->tree)) {
         ret = tsk_ls_hmm_update_tree(self, TSK_DIR_REVERSE);
         if (ret != 0) {
             goto out;
@@ -1492,7 +1492,7 @@ tsk_compressed_matrix_decode(tsk_compressed_matrix_t *self, double *values)
     }
 
     for (t_ret = tsk_tree_first(&tree); t_ret == TSK_TREE_OK;
-         t_ret = tsk_tree_next(&tree)) {
+        t_ret = tsk_tree_next(&tree)) {
         ret = tsk_tree_get_sites(&tree, &sites, &num_tree_sites);
         if (ret != 0) {
             goto out;
diff --git a/treerec/tskit/kastore/kastore.h b/treerec/tskit/kastore/kastore.h
@@ -157,7 +157,7 @@ to the API or ABI are introduced, i.e., the addition of a new function.
 The library patch version. Incremented when any changes not relevant to the
 to the API or ABI are introduced, i.e., internal refactors of bugfixes.
 */
-#define KAS_VERSION_PATCH   1
+#define KAS_VERSION_PATCH   2
 /** @} */
 
 #define KAS_HEADER_SIZE             64
diff --git a/treerec/tskit/tables.c b/treerec/tskit/tables.c
@@ -100,7 +100,7 @@ check_offset_overflow(tsk_size_t current_size, tsk_size_t additional_elements)
            || current_size > (max_val - additional_elements);
 }
 
-#define TSK_NUM_ROWS_UNSET ((tsk_size_t) -1)
+#define TSK_NUM_ROWS_UNSET   ((tsk_size_t) - 1)
 #define TSK_MAX_COL_NAME_LEN 64
 
 static int
@@ -8255,8 +8255,8 @@ pair_to_integer(tsk_id_t a, tsk_id_t b, tsk_size_t N)
 static inline void
 integer_to_pair(int64_t index, tsk_size_t N, tsk_id_t *a, tsk_id_t *b)
 {
-    *a = (tsk_id_t)(index / (int64_t) N);
-    *b = (tsk_id_t)(index % (int64_t) N);
+    *a = (tsk_id_t) (index / (int64_t) N);
+    *b = (tsk_id_t) (index % (int64_t) N);
 }
 
 static int64_t
@@ -8997,7 +8997,7 @@ simplifier_check_state(simplifier_t *self)
     for (j = 0; j < self->input_tables.nodes.num_rows; j++) {
         last_position = -1;
         for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;
-             list_node = list_node->next) {
+            list_node = list_node->next) {
             tsk_bug_assert(
                 self->input_tables.mutations.node[list_node->mutation] == (tsk_id_t) j);
             site = self->input_tables.mutations.site[list_node->mutation];
@@ -9028,7 +9028,7 @@ simplifier_check_state(simplifier_t *self)
         child = self->buffered_children[j];
         tsk_bug_assert(self->child_edge_map_head[child] != NULL);
         for (int_list = self->child_edge_map_head[child]; int_list != NULL;
-             int_list = int_list->next) {
+            int_list = int_list->next) {
             tsk_bug_assert(int_list->left < int_list->right);
             if (int_list->next != NULL) {
                 tsk_bug_assert(int_list->right < int_list->next->left);
@@ -9108,7 +9108,7 @@ simplifier_print_state(simplifier_t *self, FILE *out)
         child = self->buffered_children[j];
         fprintf(out, "%lld -> ", (long long) j);
         for (int_list = self->child_edge_map_head[child]; int_list != NULL;
-             int_list = int_list->next) {
+            int_list = int_list->next) {
             fprintf(out, "(%f, %f), ", int_list->left, int_list->right);
         }
         fprintf(out, "\n");
@@ -9123,7 +9123,7 @@ simplifier_print_state(simplifier_t *self, FILE *out)
         if (self->node_mutation_list_map_head[j] != NULL) {
             fprintf(out, "%lld\t-> [", (long long) j);
             for (list_node = self->node_mutation_list_map_head[j]; list_node != NULL;
-                 list_node = list_node->next) {
+                list_node = list_node->next) {
                 fprintf(out, "%lld,", (long long) list_node->mutation);
             }
             fprintf(out, "]\n");
@@ -10187,7 +10187,7 @@ simplifier_insert_input_roots(simplifier_t *self)
     const double *node_time = self->tables->nodes.time;
 
     for (input_id = 0; input_id < (tsk_id_t) self->input_tables.nodes.num_rows;
-         input_id++) {
+        input_id++) {
         x = self->ancestor_map_head[input_id];
         if (x != NULL) {
             output_id = self->node_id_map[input_id];
@@ -10736,11 +10736,11 @@ tsk_table_collection_check_individual_integrity(
 
     for (j = 0; j < (tsk_size_t) num_individuals; j++) {
         for (k = individuals.parents_offset[j]; k < individuals.parents_offset[j + 1];
-             k++) {
+            k++) {
             /* Check parent references are valid */
             if (individuals.parents[k] != TSK_NULL
                 && (individuals.parents[k] < 0
-                       || individuals.parents[k] >= num_individuals)) {
+                    || individuals.parents[k] >= num_individuals)) {
                 ret = tsk_trace_error(TSK_ERR_INDIVIDUAL_OUT_OF_BOUNDS);
                 goto out;
             }
@@ -11250,20 +11250,20 @@ tsk_table_collection_equals(const tsk_table_collection_t *self,
     if (!(options & TSK_CMP_IGNORE_TABLES)) {
         ret = ret
               && tsk_individual_table_equals(
-                     &self->individuals, &other->individuals, options)
+                  &self->individuals, &other->individuals, options)
               && tsk_node_table_equals(&self->nodes, &other->nodes, options)
               && tsk_edge_table_equals(&self->edges, &other->edges, options)
               && tsk_migration_table_equals(
-                     &self->migrations, &other->migrations, options)
+                  &self->migrations, &other->migrations, options)
               && tsk_site_table_equals(&self->sites, &other->sites, options)
               && tsk_mutation_table_equals(&self->mutations, &other->mutations, options)
               && tsk_population_table_equals(
-                     &self->populations, &other->populations, options);
+                  &self->populations, &other->populations, options);
         /* TSK_CMP_IGNORE_TABLES implies TSK_CMP_IGNORE_PROVENANCE */
         if (!(options & TSK_CMP_IGNORE_PROVENANCE)) {
             ret = ret
                   && tsk_provenance_table_equals(
-                         &self->provenances, &other->provenances, options);
+                      &self->provenances, &other->provenances, options);
         }
     }
     /* TSK_CMP_IGNORE_TS_METADATA is implied by TSK_CMP_IGNORE_METADATA */
@@ -11273,19 +11273,19 @@ tsk_table_collection_equals(const tsk_table_collection_t *self,
     if (!(options & TSK_CMP_IGNORE_TS_METADATA)) {
         ret = ret
               && (self->metadata_length == other->metadata_length
-                     && self->metadata_schema_length == other->metadata_schema_length
-                     && tsk_memcmp(self->metadata, other->metadata,
-                            self->metadata_length * sizeof(char))
-                            == 0
-                     && tsk_memcmp(self->metadata_schema, other->metadata_schema,
-                            self->metadata_schema_length * sizeof(char))
-                            == 0);
+                  && self->metadata_schema_length == other->metadata_schema_length
+                  && tsk_memcmp(self->metadata, other->metadata,
+                         self->metadata_length * sizeof(char))
+                         == 0
+                  && tsk_memcmp(self->metadata_schema, other->metadata_schema,
+                         self->metadata_schema_length * sizeof(char))
+                         == 0);
     }
 
     if (!(options & TSK_CMP_IGNORE_REFERENCE_SEQUENCE)) {
         ret = ret
               && tsk_reference_sequence_equals(
-                     &self->reference_sequence, &other->reference_sequence, options);
+                  &self->reference_sequence, &other->reference_sequence, options);
     }
     return ret;
 }
@@ -12057,7 +12057,7 @@ tsk_table_collection_dumpf(
         { "format/name", (const void *) &TSK_FILE_FORMAT_NAME,
             TSK_FILE_FORMAT_NAME_LENGTH, KAS_INT8 },
         { "format/version",
-            (const void *) &(uint32_t[]){
+            (const void *) &(uint32_t[]) {
                 TSK_FILE_FORMAT_VERSION_MAJOR, TSK_FILE_FORMAT_VERSION_MINOR },
             2, KAS_UINT32 },
         { "sequence_length", (const void *) &self->sequence_length, 1, KAS_FLOAT64 },
@@ -13302,7 +13302,7 @@ tsk_table_collection_union(tsk_table_collection_t *self,
     /* Now we know the full individual map we can remap the parents of the new
      * individuals*/
     for (k = (tsk_id_t) self->individuals.parents_offset[num_individuals_self];
-         k < (tsk_id_t) self->individuals.parents_length; k++) {
+        k < (tsk_id_t) self->individuals.parents_length; k++) {
         if (self->individuals.parents[k] != TSK_NULL) {
             self->individuals.parents[k] = individual_map[self->individuals.parents[k]];
         }
diff --git a/treerec/tskit/tables.h b/treerec/tskit/tables.h
@@ -4607,7 +4607,7 @@ tsk_id_t tsk_table_collection_check_integrity(
 /* Undocumented methods */
 
 /* Flags for ibd_segments */
-#define TSK_IBD_STORE_PAIRS (1 << 0)
+#define TSK_IBD_STORE_PAIRS    (1 << 0)
 #define TSK_IBD_STORE_SEGMENTS (1 << 1)
 
 /* TODO be systematic about where "result" should be in the params
diff --git a/treerec/tskit/trees.c b/treerec/tskit/trees.c
