_INLINE_
static _pSLAssoc_Array_Element_Type *
assoc_aput (SLang_Assoc_Array_Type *a, _pSLAssoc_Array_Element_Type *e,
SLstr_Type *str, unsigned long hash)
{
SLang_Object_Type obj;
if (-1 == SLang_pop (&obj))
return NULL;
if ((obj.o_data_type != a->type)
#if USE_NEW_ANYTYPE_CODE
&& (a->type != SLANG_ANY_TYPE)
#endif
)
{
(void) SLang_push (&obj);
if ((-1 == SLclass_typecast (a->type, 1, 0))
|| (-1 == SLang_pop (&obj)))
return NULL;
}
if (NULL == (e = store_object (a, e, str, hash, &obj)))
SLang_free_object (&obj);
return e;
}
int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_transfer_progress *stats)
{
int error = -1;
size_t processed;
struct git_pack_header *hdr = &idx->hdr;
git_mwindow_file *mwf = &idx->pack->mwf;
assert(idx && data && stats);
processed = stats->indexed_objects;
if ((error = append_to_pack(idx, data, size)) < 0)
return error;
hash_partially(idx, (unsigned char*) data, (int)size);
/* Make sure we set the new size of the pack */
idx->pack->mwf.size += size;
if (!idx->parsed_header) {
unsigned int total_objects;
if ((unsigned)idx->pack->mwf.size < sizeof(struct git_pack_header))
return 0;
if ((error = parse_header(&idx->hdr, idx->pack)) < 0)
return error;
idx->parsed_header = 1;
idx->nr_objects = ntohl(hdr->hdr_entries);
idx->off = sizeof(struct git_pack_header);
/* for now, limit to 2^32 objects */
assert(idx->nr_objects == (size_t)((unsigned int)idx->nr_objects));
if (idx->nr_objects == (size_t)((unsigned int)idx->nr_objects))
total_objects = (unsigned int)idx->nr_objects;
else
total_objects = UINT_MAX;
idx->pack->idx_cache = git_oidmap_alloc();
GITERR_CHECK_ALLOC(idx->pack->idx_cache);
idx->pack->has_cache = 1;
if (git_vector_init(&idx->objects, total_objects, objects_cmp) < 0)
return -1;
if (git_vector_init(&idx->deltas, total_objects / 2, NULL) < 0)
return -1;
stats->received_objects = 0;
stats->local_objects = 0;
stats->total_deltas = 0;
stats->indexed_deltas = 0;
processed = stats->indexed_objects = 0;
stats->total_objects = total_objects;
if ((error = do_progress_callback(idx, stats)) != 0)
return error;
}
/* Now that we have data in the pack, let's try to parse it */
/* As the file grows any windows we try to use will be out of date */
git_mwindow_free_all(mwf);
while (processed < idx->nr_objects) {
git_packfile_stream *stream = &idx->stream;
git_off_t entry_start = idx->off;
size_t entry_size;
git_otype type;
git_mwindow *w = NULL;
if (idx->pack->mwf.size <= idx->off + 20)
return 0;
if (!idx->have_stream) {
error = git_packfile_unpack_header(&entry_size, &type, mwf, &w, &idx->off);
if (error == GIT_EBUFS) {
idx->off = entry_start;
return 0;
}
if (error < 0)
goto on_error;
git_mwindow_close(&w);
idx->entry_start = entry_start;
git_hash_init(&idx->hash_ctx);
if (type == GIT_OBJ_REF_DELTA || type == GIT_OBJ_OFS_DELTA) {
error = advance_delta_offset(idx, type);
if (error == GIT_EBUFS) {
idx->off = entry_start;
return 0;
}
if (error < 0)
goto on_error;
idx->have_delta = 1;
} else {
idx->have_delta = 0;
hash_header(&idx->hash_ctx, entry_size, type);
}
idx->have_stream = 1;
error = git_packfile_stream_open(stream, idx->pack, idx->off);
if (error < 0)
goto on_error;
}
if (idx->have_delta) {
error = read_object_stream(idx, stream);
} else {
error = hash_object_stream(idx, stream);
}
idx->off = stream->curpos;
if (error == GIT_EBUFS)
return 0;
/* We want to free the stream reasorces no matter what here */
idx->have_stream = 0;
git_packfile_stream_free(stream);
if (error < 0)
goto on_error;
if (idx->have_delta) {
error = store_delta(idx);
} else {
error = store_object(idx);
}
if (error < 0)
goto on_error;
if (!idx->have_delta) {
stats->indexed_objects = (unsigned int)++processed;
}
stats->received_objects++;
if ((error = do_progress_callback(idx, stats)) != 0)
goto on_error;
}
return 0;
on_error:
git_mwindow_free_all(mwf);
return error;
}
/****************************************************************************
* Return a list containing the empirical column frequency distributions
* for all alignments in the input.
*
* Each file in the list of filenames is read and the species list is
* determined. The counts of each occurring column are tallied.
* All files with the same species lists get their counts combined.
*
* The returned list contains one distribution per species list that
* occurs in some alignment.
****************************************************************************/
OBJECT_LIST_T* get_alignment_column_freqs_list
(ALPH_T alph,
STRING_LIST_T* filenames,
BOOLEAN_T remove_allgap_seqs)
{
int file_index;
int num_filenames = get_num_strings(filenames);
ARRAY_T* alignment_column_freqs = NULL;
OBJECT_LIST_T* alignment_column_freqs_list
= new_object_list(equal_string_lists,
(void*)copy_string_list,
free_string_list,
free_array);
// Consider each alignment in turn.
for(file_index = 0; file_index < num_filenames; file_index++) {
char* filename = get_nth_string(file_index, filenames);
if (verbosity >= NORMAL_VERBOSE && !(file_index % 1)) {
fprintf(
stderr,
"Computing column freqs: alignment file number %d of %d total files.\n",
file_index+1, num_filenames
);
}
// Read the alignment
int ref_seq_index = 0;
ALIGNMENT_T* alignment =
read_alignment_from_file(filename, TRUE, remove_allgap_seqs, &ref_seq_index);
STRING_LIST_T* alignment_species = get_species_names(alignment);
// Try to retrieve the counts so far for this list of species.
alignment_column_freqs =
(ARRAY_T*)retrieve_object(
alignment_species,
alignment_column_freqs_list
);
// Found counts for current species list?
if (alignment_column_freqs) {
// Add counts from current alignment.
(void) build_alignment_column_counts(alph, alignment, alignment_column_freqs);
// Note: objects in lists are references, so no need to re-store
// after modification.
}
// Didn't find counts for this species list, so create new array of counts.
else {
alignment_column_freqs = build_alignment_column_counts(alph, alignment, NULL);
store_object(
(void*)alignment_column_freqs,
(void*)alignment_species,
0.0, // Score
alignment_column_freqs_list
);
}
// free space used by alignment
free_alignment(alignment);
} // each filename
fprintf(stderr, "\n");
// Convert counts to frequencies by retrieving each array of counts
// and dividing by the total counts for that list of species.
while (
(alignment_column_freqs = retrieve_next_object(alignment_column_freqs_list)
) != NULL )
{
int i;
int num_freqs = get_array_length(alignment_column_freqs);
double total_counts;
// Get total counts.
for (i=total_counts=0; i<num_freqs; i++) {
total_counts += get_array_item(i, alignment_column_freqs);
}
// Get frequencies.
for (i=0; i<num_freqs; i++) {
double f = get_array_item(i, alignment_column_freqs);
set_array_item(i, f/total_counts, alignment_column_freqs);
#ifdef DEBUG
int asize = alph_size(alph, ALPH_SIZE);
int num_leaves = NINT(log(num_freqs)/log(asize));
char* alignment_col = mm_malloc((num_leaves + 1) * sizeof(char));
unhash_alignment_col(
alph,
i, //col_index
alignment_col,
num_leaves
);
printf("%s %g %g\n", alignment_col, f, f/total_counts);
myfree(alignment_col);
#endif
} // get frequencies
} // while more species lists
return(alignment_column_freqs_list);
} // get_alignment_column_freqs_list
