TermStepper*
TextType_make_term_stepper(TextType *self)
{
UNUSED_VAR(self);
return (TermStepper*)TextTermStepper_new();
}
void
RawPost_Destroy_IMP(RawPosting *self) {
UNUSED_VAR(self);
THROW(ERR, "Illegal attempt to destroy RawPosting object");
}
int
BBSortEx_Compare_IMP(BBSortEx *self, void *va, void *vb) {
UNUSED_VAR(self);
return BB_compare((ByteBuf**)va, (ByteBuf**)vb);
}
Obj*
Hash_make_key(Hash *self, Obj *key, int32_t hash_sum) {
UNUSED_VAR(self);
UNUSED_VAR(hash_sum);
return Obj_Clone(key);
}
void func(asIScriptGeneric *g)
{
TEST_ENUM e = (TEST_ENUM)g->GetArgDWord(0);
UNUSED_VAR(e);
}
// This function should prepare system functions so that it will be faster to call them
int PrepareSystemFunction(asCScriptFunction *func, asSSystemFunctionInterface *internal, asCScriptEngine *engine)
{
#ifdef AS_MAX_PORTABILITY
UNUSED_VAR(func);
UNUSED_VAR(internal);
UNUSED_VAR(engine);
// This should never happen, as when AS_MAX_PORTABILITY is on, all functions
// are asCALL_GENERIC, which are prepared by PrepareSystemFunctionGeneric
asASSERT(false);
#else
// References are always returned as primitive data
if( func->returnType.IsReference() || func->returnType.IsObjectHandle() )
{
internal->hostReturnInMemory = false;
internal->hostReturnSize = sizeof(void*)/4;
internal->hostReturnFloat = false;
}
// Registered types have special flags that determine how they are returned
else if( func->returnType.IsObject() )
{
asDWORD objType = func->returnType.GetObjectType()->flags;
// Only value types can be returned by value
asASSERT( objType & asOBJ_VALUE );
if( !(objType & (asOBJ_APP_CLASS | asOBJ_APP_PRIMITIVE | asOBJ_APP_FLOAT | asOBJ_APP_ARRAY)) )
{
// If the return is by value then we need to know the true type
engine->WriteMessage("", 0, 0, asMSGTYPE_INFORMATION, func->GetDeclarationStr().AddressOf());
asCString str;
str.Format(TXT_CANNOT_RET_TYPE_s_BY_VAL, func->returnType.GetObjectType()->name.AddressOf());
engine->WriteMessage("", 0, 0, asMSGTYPE_ERROR, str.AddressOf());
engine->ConfigError(asINVALID_CONFIGURATION, 0, 0, 0);
}
else if( objType & asOBJ_APP_ARRAY )
{
// Array types are always returned in memory
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
internal->hostReturnFloat = false;
}
else if( objType & asOBJ_APP_CLASS )
{
internal->hostReturnFloat = false;
if( objType & COMPLEX_RETURN_MASK )
{
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
}
else
{
#ifdef HAS_128_BIT_PRIMITIVES
if( func->returnType.GetSizeInMemoryDWords() > 4 )
#else
if( func->returnType.GetSizeInMemoryDWords() > 2 )
#endif
{
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
}
else
{
internal->hostReturnInMemory = false;
internal->hostReturnSize = func->returnType.GetSizeInMemoryDWords();
#ifdef SPLIT_OBJS_BY_MEMBER_TYPES
if( func->returnType.GetObjectType()->flags & asOBJ_APP_CLASS_ALLFLOATS )
internal->hostReturnFloat = true;
#endif
}
#ifdef THISCALL_RETURN_SIMPLE_IN_MEMORY
if((internal->callConv == ICC_THISCALL ||
#ifdef AS_NO_THISCALL_FUNCTOR_METHOD
internal->callConv == ICC_VIRTUAL_THISCALL) &&
#else
internal->callConv == ICC_VIRTUAL_THISCALL ||
internal->callConv == ICC_THISCALL_OBJFIRST ||
internal->callConv == ICC_THISCALL_OBJLAST) &&
#endif
func->returnType.GetSizeInMemoryDWords() >= THISCALL_RETURN_SIMPLE_IN_MEMORY_MIN_SIZE)
{
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
}
#endif
#ifdef CDECL_RETURN_SIMPLE_IN_MEMORY
if((internal->callConv == ICC_CDECL ||
internal->callConv == ICC_CDECL_OBJLAST ||
internal->callConv == ICC_CDECL_OBJFIRST) &&
func->returnType.GetSizeInMemoryDWords() >= CDECL_RETURN_SIMPLE_IN_MEMORY_MIN_SIZE)
{
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
}
#endif
#ifdef STDCALL_RETURN_SIMPLE_IN_MEMORY
if( internal->callConv == ICC_STDCALL &&
func->returnType.GetSizeInMemoryDWords() >= STDCALL_RETURN_SIMPLE_IN_MEMORY_MIN_SIZE)
{
internal->hostReturnInMemory = true;
internal->hostReturnSize = sizeof(void*)/4;
}
#endif
}
#ifdef SPLIT_OBJS_BY_MEMBER_TYPES
// It's not safe to return objects by value because different registers
// will be used depending on the memory layout of the object.
// Ref: http://www.x86-64.org/documentation/abi.pdf
// Ref: http://www.agner.org/optimize/calling_conventions.pdf
// If the application informs that the class should be treated as all integers, then we allow it
if( !internal->hostReturnInMemory &&
!(func->returnType.GetObjectType()->flags & (asOBJ_APP_CLASS_ALLINTS | asOBJ_APP_CLASS_ALLFLOATS)) )
{
engine->WriteMessage("", 0, 0, asMSGTYPE_INFORMATION, func->GetDeclarationStr().AddressOf());
asCString str;
str.Format(TXT_DONT_SUPPORT_RET_TYPE_s_BY_VAL, func->returnType.Format(func->nameSpace).AddressOf());
engine->WriteMessage("", 0, 0, asMSGTYPE_ERROR, str.AddressOf());
engine->ConfigError(asINVALID_CONFIGURATION, 0, 0, 0);
}
#endif
}
Err*
Err_make(Err *self) {
UNUSED_VAR(self);
return Err_new(CB_new(0));
}
// Respond to arrow keys by moving the camera frame of reference
void SpecialKeys(int key, int _x, int _y)
{
// Not using these variables
UNUSED_VAR(_x);
UNUSED_VAR(_y);
bool cameraUpdate = false;
bool updateLookAt = true;
Vect position;
Vect dir;
pCamera->getDir(dir);
Vect lookAt;
pCamera->getPos(position);
if (key == GLUT_KEY_F1)
{
p1->SpeedUP();
}
if (key == GLUT_KEY_F2)
{
p1->SlowDown();
}
if (key == GLUT_KEY_F3)
{
p1->ForwardPlay();
}
if (key == GLUT_KEY_F4)
{
p1->BackwardPlay();
}
if (key == GLUT_KEY_F6 )
{
p1->Loop();
}
if (key == GLUT_KEY_F5)
{
p1->QueueNextAnimation();
}
if(key == GLUT_KEY_HOME)
{
pCamera->startOrbit();
}
if(key == GLUT_KEY_END)
{
pCamera->stopOrbit();
}
if(cameraUpdate)
{
if(updateLookAt)
{
lookAt = position+(-dir);
}
else
{
lookAt = -dir;
}
pCamera->setOrientAndPosition(Vect(0,1,0),lookAt,position);
}
glutPostRedisplay();
}
bool_t
FH_grow(FileHandle *self, int64_t length) {
UNUSED_VAR(self);
UNUSED_VAR(length);
return true;
}
u32_t
RawPost_dec_refcount(RawPosting* self)
{
UNUSED_VAR(self);
return 1;
}
LexiconReader*
LexReader_Aggregator_IMP(LexiconReader *self, Vector *readers,
I32Array *offsets) {
UNUSED_VAR(self);
return (LexiconReader*)PolyLexReader_new(readers, offsets);
}
void
RawPost_destroy(RawPosting *self)
{
UNUSED_VAR(self);
THROW("Illegal attempt to destroy RawPosting object");
}
CharBuf*
TextType_make_blank(TextType *self)
{
UNUSED_VAR(self);
return CB_new(0);
}
int8_t
TextType_primitive_id(TextType *self)
{
UNUSED_VAR(self);
return FType_TEXT;
}
ByteBuf*
HLWriter_tv_buf(HighlightWriter *self, Inversion *inversion)
{
char *last_text = "";
size_t last_len = 0;
ByteBuf *tv_buf = BB_new(20 + Inversion_Get_Size(inversion) * 8);
uint32_t num_postings = 0;
char *dest;
Token **tokens;
uint32_t freq;
UNUSED_VAR(self);
// Leave space for a c32 indicating the number of postings.
BB_Set_Size(tv_buf, C32_MAX_BYTES);
Inversion_Reset(inversion);
while ( (tokens = Inversion_Next_Cluster(inversion, &freq)) != NULL ) {
Token *token = *tokens;
int32_t overlap = StrHelp_overlap(last_text, token->text,
last_len, token->len);
char *ptr;
char *orig;
size_t old_size = BB_Get_Size(tv_buf);
size_t new_size = old_size
+ C32_MAX_BYTES // overlap
+ C32_MAX_BYTES // length of string diff
+ (token->len - overlap) // diff char data
+ C32_MAX_BYTES // num prox
+ (C32_MAX_BYTES * freq * 3); // pos data
// Allocate for worst-case scenario.
ptr = BB_Grow(tv_buf, new_size);
orig = ptr;
ptr += old_size;
// Track number of postings.
num_postings += 1;
// Append the string diff to the tv_buf.
NumUtil_encode_c32(overlap, &ptr);
NumUtil_encode_c32( (token->len - overlap), &ptr);
memcpy(ptr, (token->text + overlap), (token->len - overlap));
ptr += token->len - overlap;
// Save text and text_len for comparison next loop.
last_text = token->text;
last_len = token->len;
// Append the number of positions for this term.
NumUtil_encode_c32(freq, &ptr);
do {
// Add position, start_offset, and end_offset to tv_buf.
NumUtil_encode_c32(token->pos, &ptr);
NumUtil_encode_c32(token->start_offset, &ptr);
NumUtil_encode_c32(token->end_offset, &ptr);
} while (--freq && (token = *++tokens));
// Set new byte length.
BB_Set_Size(tv_buf, ptr - orig);
}
// Go back and start the term vector string with the posting count.
dest = BB_Get_Buf(tv_buf);
NumUtil_encode_padded_c32(num_postings, &dest);
return tv_buf;
}
CharBuf*
TextSortCache_make_blank(TextSortCache *self)
{
UNUSED_VAR(self);
return CB_new_from_trusted_utf8("", 0);
}
int32_t
HLWriter_format(HighlightWriter *self)
{
UNUSED_VAR(self);
return HLWriter_current_file_format;
}
ByteBuf*
HLWriter_tv_buf(HighlightWriter *self, Inversion *inversion)
{
char *last_text = "";
size_t last_len = 0;
ByteBuf *tv_buf = BB_new(20 + inversion->size * 8); /* generous */
u32_t num_postings = 0;
char *dest;
Token **tokens;
u32_t freq;
UNUSED_VAR(self); /* heh. */
/* Leave space for a c32 indicating the number of postings. */
BB_Set_Size(tv_buf, C32_MAX_BYTES);
Inversion_Reset(inversion);
while ( (tokens = Inversion_Next_Cluster(inversion, &freq)) != NULL ) {
Token *token = *tokens;
i32_t overlap = StrHelp_string_diff(last_text, token->text,
last_len, token->len);
char *ptr;
size_t new_size = BB_Get_Size(tv_buf)
+ C32_MAX_BYTES /* overlap */
+ C32_MAX_BYTES /* length of string diff */
+ (token->len - overlap) /* diff char data */
+ C32_MAX_BYTES /* num prox */
+ (C32_MAX_BYTES * freq * 3); /* pos data */
/* Allocate for worst-case scenario. */
BB_Grow(tv_buf, new_size);
ptr = BBEND(tv_buf);
/* Track number of postings. */
num_postings += 1;
/* Append the string diff to the tv_buf. */
Math_encode_c32(overlap, &ptr);
Math_encode_c32( (token->len - overlap), &ptr);
memcpy(ptr, (token->text + overlap), (token->len - overlap));
ptr += token->len - overlap;
/* Save text and text_len for comparison next loop. */
last_text = token->text;
last_len = token->len;
/* Append the number of positions for this term. */
Math_encode_c32(freq, &ptr);
do {
/* Add position, start_offset, and end_offset to tv_buf. */
Math_encode_c32(token->pos, &ptr);
Math_encode_c32(token->start_offset, &ptr);
Math_encode_c32(token->end_offset, &ptr);
} while (--freq && (token = *++tokens));
/* Set new byte length. */
BB_Set_Size(tv_buf, ptr - tv_buf->ptr);
}
/* Go back and start the term vector string with the number of postings. */
dest = tv_buf->ptr;
Math_encode_padded_c32(num_postings, &dest);
return tv_buf;
}
HighlightReader*
HLReader_Aggregator_IMP(HighlightReader *self, Vector *readers,
I32Array *offsets) {
UNUSED_VAR(self);
return (HighlightReader*)PolyHLReader_new(readers, offsets);
}
float
Compiler_sum_of_squared_weights(Compiler *self) {
UNUSED_VAR(self);
return 1.0f;
}
Similarity*
FullTextType_Make_Similarity_IMP(FullTextType *self) {
UNUSED_VAR(self);
return Sim_new();
}
void
Compiler_apply_norm_factor(Compiler *self, float factor) {
UNUSED_VAR(self);
UNUSED_VAR(factor);
}
uint32_t
HashTombStone_dec_refcount(HashTombStone* self) {
UNUSED_VAR(self);
return 1;
}
int32_t
LexWriter_format(LexiconWriter *self)
{
UNUSED_VAR(self);
return LexWriter_current_file_format;
}
static void
S_do_consolidate(CompoundFileWriter *self, CompoundFileWriterIVARS *ivars) {
UNUSED_VAR(self);
Folder *folder = ivars->folder;
Hash *metadata = Hash_new(0);
Hash *sub_files = Hash_new(0);
Vector *files = Folder_List(folder, NULL);
Vector *merged = Vec_new(Vec_Get_Size(files));
String *cf_file = (String*)SSTR_WRAP_UTF8("cf.dat", 6);
OutStream *outstream = Folder_Open_Out(folder, (String*)cf_file);
bool rename_success;
if (!outstream) { RETHROW(INCREF(Err_get_error())); }
// Start metadata.
Hash_Store_Utf8(metadata, "files", 5, INCREF(sub_files));
Hash_Store_Utf8(metadata, "format", 6,
(Obj*)Str_newf("%i32", CFWriter_current_file_format));
Vec_Sort(files);
for (uint32_t i = 0, max = Vec_Get_Size(files); i < max; i++) {
String *infilename = (String*)Vec_Fetch(files, i);
if (!Str_Ends_With_Utf8(infilename, ".json", 5)) {
InStream *instream = Folder_Open_In(folder, infilename);
Hash *file_data = Hash_new(2);
int64_t offset, len;
if (!instream) { RETHROW(INCREF(Err_get_error())); }
// Absorb the file.
offset = OutStream_Tell(outstream);
OutStream_Absorb(outstream, instream);
len = OutStream_Tell(outstream) - offset;
// Record offset and length.
Hash_Store_Utf8(file_data, "offset", 6,
(Obj*)Str_newf("%i64", offset));
Hash_Store_Utf8(file_data, "length", 6,
(Obj*)Str_newf("%i64", len));
Hash_Store(sub_files, infilename, (Obj*)file_data);
Vec_Push(merged, INCREF(infilename));
// Add filler NULL bytes so that every sub-file begins on a file
// position multiple of 8.
OutStream_Align(outstream, 8);
InStream_Close(instream);
DECREF(instream);
}
}
// Write metadata to cfmeta file.
String *cfmeta_temp = (String*)SSTR_WRAP_UTF8("cfmeta.json.temp", 16);
String *cfmeta_file = (String*)SSTR_WRAP_UTF8("cfmeta.json", 11);
Json_spew_json((Obj*)metadata, (Folder*)ivars->folder, cfmeta_temp);
rename_success = Folder_Rename(ivars->folder, cfmeta_temp, cfmeta_file);
if (!rename_success) { RETHROW(INCREF(Err_get_error())); }
// Clean up.
OutStream_Close(outstream);
DECREF(outstream);
DECREF(files);
DECREF(metadata);
/*
HashIterator *iter = HashIter_new(sub_files);
while (HashIter_Next(iter)) {
String *merged_file = HashIter_Get_Key(iter);
if (!Folder_Delete(folder, merged_file)) {
String *mess = MAKE_MESS("Can't delete '%o'", merged_file);
DECREF(sub_files);
Err_throw_mess(ERR, mess);
}
}
DECREF(iter);
*/
DECREF(sub_files);
for (uint32_t i = 0, max = Vec_Get_Size(merged); i < max; i++) {
String *merged_file = (String*)Vec_Fetch(merged, i);
if (!Folder_Delete(folder, merged_file)) {
String *mess = MAKE_MESS("Can't delete '%o'", merged_file);
DECREF(merged);
Err_throw_mess(ERR, mess);
}
}
DECREF(merged);
}
Vector*
ProximityCompiler_Highlight_Spans_IMP(ProximityCompiler *self,
Searcher *searcher, DocVector *doc_vec,
String *field) {
ProximityCompilerIVARS *const ivars = ProximityCompiler_IVARS(self);
ProximityQueryIVARS *const parent_ivars
= ProximityQuery_IVARS((ProximityQuery*)ivars->parent);
Vector *const terms = parent_ivars->terms;
Vector *const spans = Vec_new(0);
const uint32_t num_terms = Vec_Get_Size(terms);
UNUSED_VAR(searcher);
// Bail if no terms or field doesn't match.
if (!num_terms) { return spans; }
if (!Str_Equals(field, (Obj*)parent_ivars->field)) { return spans; }
Vector *term_vectors = Vec_new(num_terms);
BitVector *posit_vec = BitVec_new(0);
BitVector *other_posit_vec = BitVec_new(0);
for (uint32_t i = 0; i < num_terms; i++) {
Obj *term = Vec_Fetch(terms, i);
TermVector *term_vector
= DocVec_Term_Vector(doc_vec, field, (String*)term);
// Bail if any term is missing.
if (!term_vector) {
break;
}
Vec_Push(term_vectors, (Obj*)term_vector);
if (i == 0) {
// Set initial positions from first term.
I32Array *positions = TV_Get_Positions(term_vector);
for (uint32_t j = I32Arr_Get_Size(positions); j > 0; j--) {
BitVec_Set(posit_vec, I32Arr_Get(positions, j - 1));
}
}
else {
// Filter positions using logical "and".
I32Array *positions = TV_Get_Positions(term_vector);
BitVec_Clear_All(other_posit_vec);
for (uint32_t j = I32Arr_Get_Size(positions); j > 0; j--) {
int32_t pos = I32Arr_Get(positions, j - 1) - i;
if (pos >= 0) {
BitVec_Set(other_posit_vec, pos);
}
}
BitVec_And(posit_vec, other_posit_vec);
}
}
// Proceed only if all terms are present.
uint32_t num_tvs = Vec_Get_Size(term_vectors);
if (num_tvs == num_terms) {
TermVector *first_tv = (TermVector*)Vec_Fetch(term_vectors, 0);
TermVector *last_tv
= (TermVector*)Vec_Fetch(term_vectors, num_tvs - 1);
I32Array *tv_start_positions = TV_Get_Positions(first_tv);
I32Array *tv_end_positions = TV_Get_Positions(last_tv);
I32Array *tv_start_offsets = TV_Get_Start_Offsets(first_tv);
I32Array *tv_end_offsets = TV_Get_End_Offsets(last_tv);
uint32_t terms_max = num_terms - 1;
I32Array *valid_posits = BitVec_To_Array(posit_vec);
uint32_t num_valid_posits = I32Arr_Get_Size(valid_posits);
uint32_t j = 0;
float weight = ProximityCompiler_Get_Weight(self);
uint32_t i = 0;
// Add only those starts/ends that belong to a valid position.
for (uint32_t posit_tick = 0; posit_tick < num_valid_posits; posit_tick++) {
int32_t valid_start_posit = I32Arr_Get(valid_posits, posit_tick);
int32_t valid_end_posit = valid_start_posit + terms_max;
int32_t start_offset = 0, end_offset = 0;
for (uint32_t max = I32Arr_Get_Size(tv_start_positions); i < max; i++) {
if (I32Arr_Get(tv_start_positions, i) == valid_start_posit) {
start_offset = I32Arr_Get(tv_start_offsets, i);
break;
}
}
for (uint32_t max = I32Arr_Get_Size(tv_end_positions); j < max; j++) {
if (I32Arr_Get(tv_end_positions, j) == valid_end_posit) {
end_offset = I32Arr_Get(tv_end_offsets, j);
break;
}
}
Vec_Push(spans, (Obj*)Span_new(start_offset,
end_offset - start_offset, weight));
i++, j++;
}
DECREF(valid_posits);
}
DECREF(other_posit_vec);
DECREF(posit_vec);
DECREF(term_vectors);
return spans;
}
uint32_t
RawPost_Dec_RefCount_IMP(RawPosting* self) {
UNUSED_VAR(self);
return 1;
}
int32_t
DefDelWriter_Format_IMP(DefaultDeletionsWriter *self) {
UNUSED_VAR(self);
return DefDelWriter_current_file_format;
}
static void zp_field_clear(field_t f) {
UNUSED_VAR(f);
}
/*ARGSUSED*/ void GLAPIENTRY __gl_noCombineData( GLdouble coords[3],
void *data[4],
GLfloat weight[4],
void **outData,
void *polygonData ) {UNUSED_VAR(coords);UNUSED_VAR(data);UNUSED_VAR(weight);UNUSED_VAR(outData);UNUSED_VAR(polygonData);}
