/* Create a macro definition that aliases to a function name directly, since
* this method may not be overridden. */
static char*
S_final_method_def(CFCMethod *method, CFCClass *klass) {
const char *self_type = CFCType_to_c(CFCMethod_self_type(method));
const char *full_func_sym = CFCMethod_implementing_func_sym(method);
const char *arg_names
= CFCParamList_name_list(CFCMethod_get_param_list(method));
size_t meth_sym_size = CFCMethod_full_method_sym(method, klass, NULL, 0);
char *full_meth_sym = (char*)MALLOCATE(meth_sym_size);
CFCMethod_full_method_sym(method, klass, full_meth_sym, meth_sym_size);
size_t offset_sym_size = CFCMethod_full_offset_sym(method, klass, NULL, 0);
char *full_offset_sym = (char*)MALLOCATE(offset_sym_size);
CFCMethod_full_offset_sym(method, klass, full_offset_sym, offset_sym_size);
const char pattern[] = "extern size_t %s;\n#define %s(%s) \\\n %s((%s)%s)\n";
size_t size = sizeof(pattern)
+ strlen(full_offset_sym)
+ strlen(full_meth_sym)
+ strlen(arg_names)
+ strlen(full_func_sym)
+ strlen(self_type)
+ strlen(arg_names)
+ 20;
char *method_def = (char*)MALLOCATE(size);
sprintf(method_def, pattern, full_offset_sym, full_meth_sym, arg_names,
full_func_sym, self_type, arg_names);
FREEMEM(full_offset_sym);
FREEMEM(full_meth_sym);
return method_def;
}
TermVector*
TV_Deserialize_IMP(TermVector *self, InStream *instream) {
String *field = Freezer_read_string(instream);
String *text = Freezer_read_string(instream);
size_t num_pos = InStream_Read_C64(instream);
// Read positional data.
int32_t *posits = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
int32_t *starts = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
int32_t *ends = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
for (size_t i = 0; i < num_pos; i++) {
posits[i] = InStream_Read_C32(instream);
starts[i] = InStream_Read_C32(instream);
ends[i] = InStream_Read_C32(instream);
}
I32Array *positions = I32Arr_new_steal(posits, num_pos);
I32Array *start_offsets = I32Arr_new_steal(starts, num_pos);
I32Array *end_offsets = I32Arr_new_steal(ends, num_pos);
TV_init(self, field, text, positions, start_offsets, end_offsets);
DECREF(positions);
DECREF(start_offsets);
DECREF(end_offsets);
DECREF(text);
DECREF(field);
return self;
}
TermVector*
TV_deserialize(TermVector *self, InStream *instream)
{
u32_t i;
CharBuf *field = (CharBuf*)CB_deserialize(NULL, instream);
CharBuf *text = (CharBuf*)CB_deserialize(NULL, instream);
u32_t num_pos = InStream_Read_C32(instream);
i32_t *posits, *starts, *ends;
I32Array *positions, *start_offsets, *end_offsets;
/* Read positional data. */
posits = MALLOCATE(num_pos, i32_t);
starts = MALLOCATE(num_pos, i32_t);
ends = MALLOCATE(num_pos, i32_t);
for (i = 0; i < num_pos; i++) {
posits[i] = InStream_Read_C32(instream);
starts[i] = InStream_Read_C32(instream);
ends[i] = InStream_Read_C32(instream);
}
positions = I32Arr_new_steal(posits, num_pos);
start_offsets = I32Arr_new_steal(starts, num_pos);
end_offsets = I32Arr_new_steal(ends, num_pos);
self = self ? self : (TermVector*)VTable_Make_Obj(&TERMVECTOR);
self = TV_init(self, field, text, positions, start_offsets, end_offsets);
DECREF(positions);
DECREF(start_offsets);
DECREF(end_offsets);
DECREF(text);
DECREF(field);
return self;
}
Vector*
IxManager_Recycle_IMP(IndexManager *self, PolyReader *reader,
DeletionsWriter *del_writer, int64_t cutoff,
bool optimize) {
Vector *seg_readers = PolyReader_Get_Seg_Readers(reader);
size_t num_seg_readers = Vec_Get_Size(seg_readers);
SegReader **candidates
= (SegReader**)MALLOCATE(num_seg_readers * sizeof(SegReader*));
size_t num_candidates = 0;
for (size_t i = 0; i < num_seg_readers; i++) {
SegReader *seg_reader = (SegReader*)Vec_Fetch(seg_readers, i);
if (SegReader_Get_Seg_Num(seg_reader) > cutoff) {
candidates[num_candidates++] = seg_reader;
}
}
Vector *recyclables = Vec_new(num_candidates);
if (optimize) {
for (size_t i = 0; i < num_candidates; i++) {
Vec_Push(recyclables, INCREF(candidates[i]));
}
FREEMEM(candidates);
return recyclables;
}
// Sort by ascending size in docs, choose sparsely populated segments.
qsort(candidates, num_candidates, sizeof(SegReader*), S_compare_doc_count);
int32_t *counts = (int32_t*)MALLOCATE(num_candidates * sizeof(int32_t));
for (uint32_t i = 0; i < num_candidates; i++) {
counts[i] = SegReader_Doc_Count(candidates[i]);
}
I32Array *doc_counts = I32Arr_new_steal(counts, num_candidates);
uint32_t threshold = IxManager_Choose_Sparse(self, doc_counts);
DECREF(doc_counts);
// Move SegReaders to be recycled.
for (uint32_t i = 0; i < threshold; i++) {
Vec_Store(recyclables, i, INCREF(candidates[i]));
}
// Find segments where at least 10% of all docs have been deleted.
for (uint32_t i = threshold; i < num_candidates; i++) {
SegReader *seg_reader = candidates[i];
String *seg_name = SegReader_Get_Seg_Name(seg_reader);
double doc_max = SegReader_Doc_Max(seg_reader);
double num_deletions = DelWriter_Seg_Del_Count(del_writer, seg_name);
double del_proportion = num_deletions / doc_max;
if (del_proportion >= 0.1) {
Vec_Push(recyclables, INCREF(seg_reader));
}
}
FREEMEM(candidates);
return recyclables;
}
CFCParcel*
CFCParcel_init(CFCParcel *self, const char *name, const char *cnick,
CFCVersion *version) {
// Validate name.
if (!name || !S_validate_name_or_cnick(name)) {
CFCUtil_die("Invalid name: '%s'", name ? name : "[NULL]");
}
self->name = CFCUtil_strdup(name);
// Validate or derive cnick.
if (cnick) {
if (!S_validate_name_or_cnick(cnick)) {
CFCUtil_die("Invalid cnick: '%s'", cnick);
}
self->cnick = CFCUtil_strdup(cnick);
}
else {
// Default cnick to name.
self->cnick = CFCUtil_strdup(name);
}
// Default to version v0.
if (version) {
self->version = (CFCVersion*)CFCBase_incref((CFCBase*)version);
}
else {
self->version = CFCVersion_new("v0");
}
// Derive prefix, Prefix, PREFIX.
size_t cnick_len = strlen(self->cnick);
size_t prefix_len = cnick_len ? cnick_len + 1 : 0;
size_t amount = prefix_len + 1;
self->prefix = (char*)MALLOCATE(amount);
self->Prefix = (char*)MALLOCATE(amount);
self->PREFIX = (char*)MALLOCATE(amount);
memcpy(self->Prefix, self->cnick, cnick_len);
if (cnick_len) {
self->Prefix[cnick_len] = '_';
self->Prefix[cnick_len + 1] = '\0';
}
else {
self->Prefix[cnick_len] = '\0';
}
for (size_t i = 0; i < amount; i++) {
self->prefix[i] = tolower(self->Prefix[i]);
self->PREFIX[i] = toupper(self->Prefix[i]);
}
self->prefix[prefix_len] = '\0';
self->Prefix[prefix_len] = '\0';
self->PREFIX[prefix_len] = '\0';
return self;
}
static void
S_set_prereqs(CFCParcel *self, CFCJson *node, const char *path) {
size_t num_prereqs = CFCJson_get_num_children(node) / 2;
CFCJson **children = CFCJson_get_children(node);
CFCPrereq **prereqs
= (CFCPrereq**)MALLOCATE((num_prereqs + 1) * sizeof(CFCPrereq*));
for (size_t i = 0; i < num_prereqs; ++i) {
const char *name = CFCJson_get_string(children[2*i]);
CFCJson *value = children[2*i+1];
int value_type = CFCJson_get_type(value);
CFCVersion *version = NULL;
if (value_type == CFCJSON_STRING) {
version = CFCVersion_new(CFCJson_get_string(value));
}
else if (value_type != CFCJSON_NULL) {
CFCUtil_die("Invalid prereq value (filepath '%s')", path);
}
prereqs[i] = CFCPrereq_new(name, version);
CFCBase_decref((CFCBase*)version);
}
prereqs[num_prereqs] = NULL;
// Assume that prereqs are empty.
FREEMEM(self->prereqs);
self->prereqs = prereqs;
self->num_prereqs = num_prereqs;
}
PolySearcher*
PolySearcher_init(PolySearcher *self, Schema *schema, VArray *searchers) {
const uint32_t num_searchers = VA_Get_Size(searchers);
int32_t *starts_array = (int32_t*)MALLOCATE(num_searchers * sizeof(int32_t));
int32_t doc_max = 0;
Searcher_init((Searcher*)self, schema);
PolySearcherIVARS *const ivars = PolySearcher_IVARS(self);
ivars->searchers = (VArray*)INCREF(searchers);
ivars->starts = NULL; // Safe cleanup.
for (uint32_t i = 0; i < num_searchers; i++) {
Searcher *searcher
= (Searcher*)CERTIFY(VA_Fetch(searchers, i), SEARCHER);
Schema *candidate = Searcher_Get_Schema(searcher);
Class *orig_class = Schema_Get_Class(schema);
Class *candidate_class = Schema_Get_Class(candidate);
// Confirm that searchers all use the same schema.
if (orig_class != candidate_class) {
THROW(ERR, "Conflicting schemas: '%o', '%o'",
Schema_Get_Class_Name(schema),
Schema_Get_Class_Name(candidate));
}
// Derive doc_max and relative start offsets.
starts_array[i] = (int32_t)doc_max;
doc_max += Searcher_Doc_Max(searcher);
}
ivars->doc_max = doc_max;
ivars->starts = I32Arr_new_steal(starts_array, num_searchers);
return self;
}
ByteBuf*
Folder_slurp_file(Folder *self, const CharBuf *path) {
InStream *instream = Folder_Open_In(self, path);
ByteBuf *retval = NULL;
if (!instream) {
RETHROW(INCREF(Err_get_error()));
}
else {
uint64_t length = InStream_Length(instream);
if (length >= SIZE_MAX) {
InStream_Close(instream);
DECREF(instream);
THROW(ERR, "File %o is too big to slurp (%u64 bytes)", path,
length);
}
else {
size_t size = (size_t)length;
char *ptr = (char*)MALLOCATE((size_t)size + 1);
InStream_Read_Bytes(instream, ptr, size);
ptr[size] = '\0';
retval = BB_new_steal_bytes(ptr, size, size + 1);
InStream_Close(instream);
DECREF(instream);
}
}
return retval;
}
Blob*
Freezer_deserialize_blob(Blob *blob, InStream *instream) {
size_t size = InStream_Read_C32(instream);
char *buf = (char*)MALLOCATE(size);
InStream_Read_Bytes(instream, buf, size);
return Blob_init_steal(blob, buf, size);
}
// Create all the spans needed by HeatMap_Flatten_Spans, based on the source
// offsets and lengths... but leave the scores at 0.
static Vector*
S_flattened_but_empty_spans(Vector *spans) {
const size_t num_spans = Vec_Get_Size(spans);
int32_t *bounds = (int32_t*)MALLOCATE((num_spans * 2) * sizeof(int32_t));
// Assemble a list of all unique start/end boundaries.
for (size_t i = 0; i < num_spans; i++) {
Span *span = (Span*)Vec_Fetch(spans, i);
bounds[i] = Span_Get_Offset(span);
bounds[i + num_spans] = Span_Get_Offset(span) + Span_Get_Length(span);
}
qsort(bounds, num_spans * 2, sizeof(int32_t), S_compare_i32);
size_t num_bounds = 0;
int32_t last = INT32_MAX;
for (size_t i = 0; i < num_spans * 2; i++) {
if (bounds[i] != last) {
bounds[num_bounds++] = bounds[i];
last = bounds[i];
}
}
// Create one Span for each zone between two bounds.
Vector *flattened = Vec_new(num_bounds - 1);
for (size_t i = 0; i < num_bounds - 1; i++) {
int32_t start = bounds[i];
int32_t length = bounds[i + 1] - start;
Vec_Push(flattened, (Obj*)Span_new(start, length, 0.0f));
}
FREEMEM(bounds);
return flattened;
}
static void
S_init_arena(MemoryPool *self, size_t amount) {
ByteBuf *bb;
// Indicate which arena we're using at present.
self->tick++;
if (self->tick < (int32_t)VA_Get_Size(self->arenas)) {
// In recycle mode, use previously acquired memory.
bb = (ByteBuf*)VA_Fetch(self->arenas, self->tick);
if (amount >= BB_Get_Size(bb)) {
BB_Grow(bb, amount);
BB_Set_Size(bb, amount);
}
}
else {
// In add mode, get more mem from system.
size_t buf_size = (amount + 1) > self->arena_size
? (amount + 1)
: self->arena_size;
char *ptr = (char*)MALLOCATE(buf_size);
bb = BB_new_steal_bytes(ptr, buf_size - 1, buf_size);
VA_Push(self->arenas, (Obj*)bb);
}
// Recalculate consumption to take into account blocked off space.
self->consumed = 0;
for (int32_t i = 0; i < self->tick; i++) {
ByteBuf *bb = (ByteBuf*)VA_Fetch(self->arenas, i);
self->consumed += BB_Get_Size(bb);
}
self->buf = BB_Get_Buf(bb);
self->limit = self->buf + BB_Get_Size(bb);
}
CFCPerlSub*
CFCPerlSub_init(CFCPerlSub *self, CFCParamList *param_list,
const char *class_name, const char *alias,
int use_labeled_params) {
CFCUTIL_NULL_CHECK(param_list);
CFCUTIL_NULL_CHECK(class_name);
CFCUTIL_NULL_CHECK(alias);
self->param_list = (CFCParamList*)CFCBase_incref((CFCBase*)param_list);
self->class_name = CFCUtil_strdup(class_name);
self->alias = CFCUtil_strdup(alias);
self->use_labeled_params = use_labeled_params;
self->perl_name = CFCUtil_sprintf("%s::%s", class_name, alias);
size_t c_name_len = strlen(self->perl_name) + sizeof("XS_") + 1;
self->c_name = (char*)MALLOCATE(c_name_len);
int j = 3;
memcpy(self->c_name, "XS_", j);
for (int i = 0, max = (int)strlen(self->perl_name); i < max; i++) {
char c = self->perl_name[i];
if (c == ':') {
while (self->perl_name[i + 1] == ':') { i++; }
self->c_name[j++] = '_';
}
else {
self->c_name[j++] = c;
}
}
self->c_name[j] = 0; // NULL-terminate.
return self;
}
static char*
S_camel_to_lower(const char *camel) {
if (camel[0] == '\0') { return CFCUtil_strdup(""); }
size_t alloc = 1;
for (size_t i = 1; camel[i]; i++) {
if (CFCUtil_isupper(camel[i]) && CFCUtil_islower(camel[i+1])) {
alloc += 1;
}
alloc += 1;
}
char *lower = (char*)MALLOCATE(alloc + 1);
lower[0] = CFCUtil_tolower(camel[0]);
size_t j = 1;
for (size_t i = 1; camel[i]; i++) {
// Only insert underscore if next char is lowercase.
if (CFCUtil_isupper(camel[i]) && CFCUtil_islower(camel[i+1])) {
lower[j++] = '_';
}
lower[j++] = CFCUtil_tolower(camel[i]);
}
lower[j] = '\0';
return lower;
}
static ORMatcher*
S_ormatcher_init2(ORMatcher *self, ORMatcherIVARS *ivars, Vector *children,
Similarity *sim) {
// Init.
PolyMatcher_init((PolyMatcher*)self, children, sim);
ivars->size = 0;
// Derive.
ivars->max_size = (uint32_t)Vec_Get_Size(children);
// Allocate.
ivars->heap = (HeapedMatcherDoc**)CALLOCATE(ivars->max_size + 1, sizeof(HeapedMatcherDoc*));
// Create a pool of HMDs. Encourage CPU cache hits by using a single
// allocation for all of them.
size_t amount_to_malloc = (ivars->max_size + 1) * sizeof(HeapedMatcherDoc);
ivars->blob = (char*)MALLOCATE(amount_to_malloc);
ivars->pool = (HeapedMatcherDoc**)CALLOCATE(ivars->max_size + 1, sizeof(HeapedMatcherDoc*));
for (uint32_t i = 1; i <= ivars->max_size; i++) {
size_t offset = i * sizeof(HeapedMatcherDoc);
HeapedMatcherDoc *hmd = (HeapedMatcherDoc*)(ivars->blob + offset);
ivars->pool[i] = hmd;
}
// Prime queue.
for (uint32_t i = 0; i < ivars->max_size; i++) {
Matcher *matcher = (Matcher*)Vec_Fetch(children, i);
if (matcher) {
S_add_element(self, ivars, (Matcher*)INCREF(matcher), 0);
}
}
return self;
}
// Create all the spans needed by HeatMap_Flatten_Spans, based on the source
// offsets and lengths... but leave the scores at 0.
static VArray*
S_flattened_but_empty_spans(VArray *spans)
{
const uint32_t num_spans = VA_Get_Size(spans);
int32_t *bounds = (int32_t*)MALLOCATE((num_spans * 2) * sizeof(int32_t));
// Assemble a list of all unique start/end boundaries.
for (uint32_t i = 0; i < num_spans; i++) {
Span *span = (Span*)VA_Fetch(spans, i);
bounds[i] = span->offset;
bounds[i + num_spans] = span->offset + span->length;
}
Sort_quicksort(bounds, num_spans * 2, sizeof(uint32_t),
S_compare_i32, NULL);
uint32_t num_bounds = 0;
int32_t last = I32_MAX;
for (uint32_t i = 0; i < num_spans * 2; i++) {
if (bounds[i] != last) {
bounds[num_bounds++] = bounds[i];
last = bounds[i];
}
}
// Create one Span for each zone between two bounds.
VArray *flattened = VA_new(num_bounds - 1);
for (uint32_t i = 0; i < num_bounds - 1; i++) {
int32_t start = bounds[i];
int32_t length = bounds[i + 1] - start;
VA_Push(flattened, (Obj*)Span_new(start, length, 0.0f));
}
FREEMEM(bounds);
return flattened;
}
Obj*
TextSortCache_Value_IMP(TextSortCache *self, int32_t ord) {
TextSortCacheIVARS *const ivars = TextSortCache_IVARS(self);
if (ord == ivars->null_ord) {
return NULL;
}
InStream_Seek(ivars->ix_in, ord * sizeof(int64_t));
int64_t offset = InStream_Read_I64(ivars->ix_in);
if (offset == NULL_SENTINEL) {
return NULL;
}
else {
uint32_t next_ord = ord + 1;
int64_t next_offset;
while (1) {
InStream_Seek(ivars->ix_in, next_ord * sizeof(int64_t));
next_offset = InStream_Read_I64(ivars->ix_in);
if (next_offset != NULL_SENTINEL) { break; }
next_ord++;
}
// Read character data into String.
size_t len = (size_t)(next_offset - offset);
char *ptr = (char*)MALLOCATE(len + 1);
InStream_Seek(ivars->dat_in, offset);
InStream_Read_Bytes(ivars->dat_in, ptr, len);
ptr[len] = '\0';
return (Obj*)Str_new_steal_utf8(ptr, len);
}
}
Inversion*
Normalizer_transform(Normalizer *self, Inversion *inversion) {
// allocate additional space because utf8proc_reencode adds a
// terminating null char
int32_t static_buffer[INITIAL_BUFSIZE + 1];
int32_t *buffer = static_buffer;
ssize_t bufsize = INITIAL_BUFSIZE;
Token *token;
while (NULL != (token = Inversion_Next(inversion))) {
ssize_t len = utf8proc_decompose((uint8_t*)token->text, token->len,
buffer, bufsize, self->options);
if (len > bufsize) {
// buffer too small, (re)allocate
if (buffer != static_buffer) {
FREEMEM(buffer);
}
// allocate additional INITIAL_BUFSIZE items
bufsize = len + INITIAL_BUFSIZE;
buffer = (int32_t*)MALLOCATE((bufsize + 1) * sizeof(int32_t));
len = utf8proc_decompose((uint8_t*)token->text, token->len,
buffer, bufsize, self->options);
}
if (len < 0) {
continue;
}
len = utf8proc_reencode(buffer, len, self->options);
if (len >= 0) {
if (len > (ssize_t)token->len) {
FREEMEM(token->text);
token->text = (char*)MALLOCATE(len + 1);
}
memcpy(token->text, buffer, len + 1);
token->len = len;
}
}
if (buffer != static_buffer) {
FREEMEM(buffer);
}
Inversion_Reset(inversion);
return (Inversion*)INCREF(inversion);
}
static void
test_new(TestBatchRunner *runner) {
static char chars[] = "A string " SMILEY " with a smile.";
{
char *buffer = (char*)MALLOCATE(sizeof(chars));
strcpy(buffer, chars);
String *thief = Str_new_steal_utf8(buffer, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(thief, chars, sizeof(chars) - 1),
"Str_new_steal_utf8");
DECREF(thief);
}
{
char *buffer = (char*)MALLOCATE(sizeof(chars));
strcpy(buffer, chars);
String *thief
= Str_new_steal_trusted_utf8(buffer, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(thief, chars, sizeof(chars) - 1),
"Str_new_steal_trusted_utf8");
DECREF(thief);
}
{
String *wrapper = Str_new_wrap_utf8(chars, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(wrapper, chars, sizeof(chars) - 1),
"Str_new_wrap_utf8");
DECREF(wrapper);
}
{
String *wrapper = Str_new_wrap_trusted_utf8(chars, sizeof(chars) - 1);
TEST_TRUE(runner, Str_Equals_Utf8(wrapper, chars, sizeof(chars) - 1),
"Str_new_wrap_trusted_utf8");
DECREF(wrapper);
}
{
String *smiley_str = Str_new_from_char(smiley_cp);
TEST_TRUE(runner, Str_Equals_Utf8(smiley_str, smiley, smiley_len),
"Str_new_from_char");
DECREF(smiley_str);
}
}
String*
Str_Cat_Trusted_Utf8_IMP(String *self, const char* ptr, size_t size) {
size_t result_size = self->size + size;
char *result_ptr = (char*)MALLOCATE(result_size + 1);
memcpy(result_ptr, self->ptr, self->size);
memcpy(result_ptr + self->size, ptr, size);
result_ptr[result_size] = '\0';
String *result = (String*)Class_Make_Obj(STRING);
return Str_init_steal_trusted_utf8(result, result_ptr, result_size);
}
char*
CFCBindMeth_typedef_dec(struct CFCMethod *method, CFCClass *klass) {
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
const char *ret_type = CFCType_to_c(CFCMethod_get_return_type(method));
size_t full_typedef_size = CFCMethod_full_typedef(method, klass, NULL, 0);
char *full_typedef = (char*)MALLOCATE(full_typedef_size);
CFCMethod_full_typedef(method, klass, full_typedef, full_typedef_size);
size_t size = strlen(params)
+ strlen(ret_type)
+ strlen(full_typedef)
+ 20
+ sizeof("\0");
char *buf = (char*)MALLOCATE(size);
sprintf(buf, "typedef %s\n(*%s)(%s);\n", ret_type, full_typedef, params);
FREEMEM(full_typedef);
return buf;
}
CharBuf*
CB_init(CharBuf *self, size_t size) {
// Derive.
self->ptr = (char*)MALLOCATE(size);
// Assign.
self->size = 0;
self->cap = size;
return self;
}
ORScorer*
ORScorer_init(ORScorer *self, VArray *children, Similarity *sim) {
S_ormatcher_init2((ORMatcher*)self, children, sim);
self->doc_id = 0;
self->scores = (float*)MALLOCATE(self->num_kids * sizeof(float));
// Establish the state of all child matchers being past the current doc
// id, by invoking ORMatcher's Next() method.
ORMatcher_next((ORMatcher*)self);
return self;
}
static TermVector*
S_extract_tv_from_tv_buf(String *field, String *term_text,
ByteBuf *tv_buf) {
TermVector *retval = NULL;
const char *posdata = BB_Get_Buf(tv_buf);
const char *posdata_end = posdata + BB_Get_Size(tv_buf);
int32_t *positions = NULL;
int32_t *starts = NULL;
int32_t *ends = NULL;
uint32_t num_pos = 0;
if (posdata != posdata_end) {
num_pos = NumUtil_decode_c32(&posdata);
positions = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
starts = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
ends = (int32_t*)MALLOCATE(num_pos * sizeof(int32_t));
}
// Expand C32s.
for (uint32_t i = 0; i < num_pos; i++) {
positions[i] = NumUtil_decode_c32(&posdata);
starts[i] = NumUtil_decode_c32(&posdata);
ends[i] = NumUtil_decode_c32(&posdata);
}
if (posdata != posdata_end) {
THROW(ERR, "Bad encoding of posdata");
}
else {
I32Array *posits_map = I32Arr_new_steal(positions, num_pos);
I32Array *starts_map = I32Arr_new_steal(starts, num_pos);
I32Array *ends_map = I32Arr_new_steal(ends, num_pos);
retval = TV_new(field, term_text, posits_map, starts_map, ends_map);
DECREF(posits_map);
DECREF(starts_map);
DECREF(ends_map);
}
return retval;
}
static void
S_init_sub_readers(PolyReader *self, VArray *sub_readers) {
PolyReaderIVARS *const ivars = PolyReader_IVARS(self);
uint32_t num_sub_readers = VA_Get_Size(sub_readers);
int32_t *starts = (int32_t*)MALLOCATE(num_sub_readers * sizeof(int32_t));
Hash *data_readers = Hash_new(0);
DECREF(ivars->sub_readers);
DECREF(ivars->offsets);
ivars->sub_readers = (VArray*)INCREF(sub_readers);
// Accumulate doc_max, subreader start offsets, and DataReaders.
ivars->doc_max = 0;
for (uint32_t i = 0; i < num_sub_readers; i++) {
SegReader *seg_reader = (SegReader*)VA_Fetch(sub_readers, i);
Hash *components = SegReader_Get_Components(seg_reader);
CharBuf *api;
DataReader *component;
starts[i] = ivars->doc_max;
ivars->doc_max += SegReader_Doc_Max(seg_reader);
Hash_Iterate(components);
while (Hash_Next(components, (Obj**)&api, (Obj**)&component)) {
VArray *readers = (VArray*)Hash_Fetch(data_readers, (Obj*)api);
if (!readers) {
readers = VA_new(num_sub_readers);
Hash_Store(data_readers, (Obj*)api, (Obj*)readers);
}
VA_Store(readers, i, INCREF(component));
}
}
ivars->offsets = I32Arr_new_steal(starts, num_sub_readers);
CharBuf *api;
VArray *readers;
Hash_Iterate(data_readers);
while (Hash_Next(data_readers, (Obj**)&api, (Obj**)&readers)) {
DataReader *datareader
= (DataReader*)CERTIFY(S_first_non_null(readers), DATAREADER);
DataReader *aggregator
= DataReader_Aggregator(datareader, readers, ivars->offsets);
if (aggregator) {
CERTIFY(aggregator, DATAREADER);
Hash_Store(ivars->components, (Obj*)api, (Obj*)aggregator);
}
}
DECREF(data_readers);
DeletionsReader *del_reader
= (DeletionsReader*)Hash_Fetch(
ivars->components, (Obj*)VTable_Get_Name(DELETIONSREADER));
ivars->del_count = del_reader ? DelReader_Del_Count(del_reader) : 0;
}
static char*
S_invalid_callback_def(CFCMethod *method) {
size_t meth_sym_size = CFCMethod_full_method_sym(method, NULL, NULL, 0);
char *full_method_sym = (char*)MALLOCATE(meth_sym_size);
CFCMethod_full_method_sym(method, NULL, full_method_sym, meth_sym_size);
const char *override_sym = CFCMethod_full_override_sym(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *params = CFCParamList_to_c(param_list);
CFCVariable **param_vars = CFCParamList_get_variables(param_list);
// Thwart compiler warnings.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
char *unused = S_build_unused_vars(param_vars);
char *unreachable = S_maybe_unreachable(return_type);
char pattern[] =
"%s\n"
"%s(%s) {%s\n"
" CFISH_THROW(CFISH_ERR, \"Can't override %s via binding\");%s\n"
"}\n";
size_t size = sizeof(pattern)
+ strlen(ret_type_str)
+ strlen(override_sym)
+ strlen(params)
+ strlen(unused)
+ strlen(full_method_sym)
+ strlen(unreachable)
+ 20;
char *callback_def = (char*)MALLOCATE(size);
sprintf(callback_def, pattern, ret_type_str, override_sym, params, unused,
full_method_sym, unreachable);
FREEMEM(full_method_sym);
FREEMEM(unreachable);
FREEMEM(unused);
return callback_def;
}
Blob*
Blob_init(Blob *self, const void *bytes, size_t size) {
char *copy = (char*)MALLOCATE(size);
if (size > 0) {
memcpy(copy, bytes, size);
}
self->buf = copy;
self->size = size;
self->owns_buf = true;
return self;
}
String*
Str_new_from_char(int32_t code_point) {
const size_t MAX_UTF8_BYTES = 4;
char *ptr = (char*)MALLOCATE(MAX_UTF8_BYTES + 1);
size_t size = StrHelp_encode_utf8_char(code_point, (uint8_t*)ptr);
ptr[size] = '\0';
String *self = (String*)Class_Make_Obj(STRING);
self->ptr = ptr;
self->size = size;
self->origin = self;
return self;
}
ORScorer*
ORScorer_init(ORScorer *self, Vector *children, Similarity *sim) {
ORScorerIVARS *const ivars = ORScorer_IVARS(self);
S_ormatcher_init2((ORMatcher*)self, (ORMatcherIVARS*)ivars, children, sim);
ivars->doc_id = 0;
ivars->scores = (float*)MALLOCATE(ivars->num_kids * sizeof(float));
// Establish the state of all child matchers being past the current doc
// id, by invoking ORMatcher's Next() method.
ORMatcher_Next_IMP((ORMatcher*)self);
return self;
}
static char*
S_pod_escape(const char *content) {
size_t len = strlen(content);
size_t result_len = 0;
size_t result_cap = len + 256;
char *result = (char*)MALLOCATE(result_cap + 1);
for (size_t i = 0; i < len; i++) {
const char *subst = content + i;
size_t subst_size = 1;
switch (content[i]) {
case '<':
// Escape "less than".
subst = "E<lt>";
subst_size = 5;
break;
case '>':
// Escape "greater than".
subst = "E<gt>";
subst_size = 5;
break;
case '|':
// Escape vertical bar.
subst = "E<verbar>";
subst_size = 9;
break;
case '=':
// Escape equal sign at start of line.
if (i == 0 || content[i-1] == '\n') {
subst = "E<61>";
subst_size = 5;
}
break;
default:
break;
}
if (result_len + subst_size > result_cap) {
result_cap += 256;
result = (char*)REALLOCATE(result, result_cap + 1);
}
memcpy(result + result_len, subst, subst_size);
result_len += subst_size;
}
result[result_len] = '\0';
return result;
}
static I32Array*
S_generate_match_list(int32_t first, int32_t max, int32_t doc_inc) {
int32_t count = (int32_t)ceil(((float)max - first) / doc_inc);
int32_t *doc_ids = (int32_t*)MALLOCATE(count * sizeof(int32_t));
int32_t doc_id = first;
int32_t i = 0;
for (; doc_id < max; doc_id += doc_inc, i++) {
doc_ids[i] = doc_id;
}
if (i != count) { THROW(ERR, "Screwed up somehow: %i32 %i32", i, count); }
return I32Arr_new_steal(doc_ids, count);
}