LexiconWriter*
LexWriter_init(LexiconWriter *self, Schema *schema, Snapshot *snapshot,
Segment *segment, PolyReader *polyreader)
{
Architecture *arch = Schema_Get_Architecture(schema);
DataWriter_init((DataWriter*)self, schema, snapshot, segment, polyreader);
// Assign.
self->index_interval = Arch_Index_Interval(arch);
self->skip_interval = Arch_Skip_Interval(arch);
// Init.
self->ix_out = NULL;
self->ixix_out = NULL;
self->dat_out = NULL;
self->count = 0;
self->ix_count = 0;
self->dat_file = CB_new(30);
self->ix_file = CB_new(30);
self->ixix_file = CB_new(30);
self->counts = Hash_new(0);
self->ix_counts = Hash_new(0);
self->temp_mode = false;
self->term_stepper = NULL;
self->tinfo_stepper = (TermStepper*)MatchTInfoStepper_new(schema);
return self;
}
LexiconWriter*
LexWriter_init(LexiconWriter *self, Snapshot *snapshot, Segment *segment,
PolyReader *polyreader)
{
Schema *schema = PolyReader_Get_Schema(polyreader);
Architecture *arch = Schema_Get_Architecture(schema);
DataWriter_init((DataWriter*)self, snapshot, segment, polyreader);
/* Assign. */
self->index_interval = Arch_Index_Interval(arch);
self->skip_interval = Arch_Skip_Interval(arch);
/* Init. */
self->ix_out = NULL;
self->ixix_out = NULL;
self->dat_out = NULL;
self->count = 0;
self->ix_count = 0;
self->last_tinfo = TInfo_new(0,0,0,0);
self->last_text = CB_new(40);
self->dat_file = CB_new(30);
self->ix_file = CB_new(30);
self->ixix_file = CB_new(30);
self->counts = Hash_new(0);
self->ix_counts = Hash_new(0);
self->stepper = NULL;
self->temp_mode = false;
/* Derive. */
self->stepper = LexStepper_new((CharBuf*)&EMPTY, self->skip_interval);
return self;
}
TextTermStepper*
TextTermStepper_init(TextTermStepper *self)
{
TermStepper_init((TermStepper*)self);
self->value = (Obj*)CB_new(0);
return self;
}
void
ErrMsg_set_with_errno(const char *fmt, ...) {
int cur_errno = errno;
CharBuf *buf = CB_new(0);
va_list args;
va_start(args, fmt);
CB_VCatF(buf, fmt, args);
va_end(args);
CB_Cat_Trusted_Utf8(buf, ": ", 2);
const char *msg = ErrMsg_strerror(cur_errno);
if (msg != NULL) {
CB_Cat_Trusted_Utf8(buf, msg, strlen(msg));
}
else {
CB_catf(buf, "Unknown error: %i32", (int32_t)cur_errno);
}
Err_set_error(Err_new(CB_Yield_String(buf)));
DECREF(buf);
}
VArray*
Folder_list_r(Folder *self, const CharBuf *path) {
Folder *local_folder = Folder_Find_Folder(self, path);
VArray *list = VA_new(0);
if (local_folder) {
CharBuf *dir = CB_new(20);
CharBuf *prefix = CB_new(20);
if (path && CB_Get_Size(path)) {
CB_setf(prefix, "%o/", path);
}
S_add_to_file_list(local_folder, list, dir, prefix);
DECREF(prefix);
DECREF(dir);
}
return list;
}
Segment*
IxManager_make_new_segment(IndexManager *self, Snapshot *snapshot)
{
VArray *files = Snapshot_List(snapshot);
u32_t i, max;
i32_t highest_seg_num = 0;
CharBuf *seg_name = CB_new(20);
Segment *segment;
/* Find highest seg num. */
for (i = 0, max = VA_Get_Size(files); i < max; i++) {
CharBuf *file = (CharBuf*)VA_Fetch(files, i);
if (CB_Starts_With_Str(file, "seg_", 4)) {
i32_t seg_num = IxFileNames_extract_gen(file);
if (seg_num > highest_seg_num) {
highest_seg_num = seg_num;
}
}
}
/* Create segment with num one greater than current max. */
S_cat_seg_name(seg_name, highest_seg_num + 1);
segment = Seg_new(seg_name, self->folder);
DECREF(seg_name);
DECREF(files);
return segment;
}
bool
FSDH_entry_is_dir(FSDirHandle *self) {
FSDirHandleIVARS *const ivars = FSDH_IVARS(self);
struct dirent *sys_dir_entry = (struct dirent*)ivars->sys_dir_entry;
if (!sys_dir_entry) { return false; }
// If d_type is available, try to avoid a stat() call. If it's not, or if
// the type comes back as unknown, fall back to stat().
#ifdef CHY_HAS_DIRENT_D_TYPE
if (sys_dir_entry->d_type == DT_DIR) {
return true;
}
else if (sys_dir_entry->d_type != DT_UNKNOWN) {
return false;
}
#endif
struct stat stat_buf;
if (!ivars->fullpath) {
ivars->fullpath = CB_new(CB_Get_Size(ivars->dir) + 20);
}
CB_setf(ivars->fullpath, "%o%s%o", ivars->dir, CHY_DIR_SEP,
ivars->entry);
if (stat((char*)CB_Get_Ptr8(ivars->fullpath), &stat_buf) != -1) {
if (stat_buf.st_mode & S_IFDIR) { return true; }
}
return false;
}
void
TextTermStepper_read_key_frame(TextTermStepper *self, InStream *instream)
{
const uint32_t text_len = InStream_Read_C32(instream);
CharBuf *value;
char *ptr;
// Allocate space.
if (self->value == NULL) {
self->value = (Obj*)CB_new(text_len);
}
value = (CharBuf*)self->value;
ptr = CB_Grow(value, text_len);
// Set the value text.
InStream_Read_Bytes(instream, ptr, text_len);
CB_Set_Size(value, text_len);
if (!StrHelp_utf8_valid(ptr, text_len)) {
THROW(ERR, "Invalid UTF-8 sequence in '%o' at byte %i64",
InStream_Get_Filename(instream),
InStream_Tell(instream) - text_len);
}
// Null-terminate.
ptr[text_len] = '\0';
}
Hash*
Hash_deserialize(Hash *self, InStream *instream) {
uint32_t size = InStream_Read_C32(instream);
uint32_t num_charbufs = InStream_Read_C32(instream);
uint32_t num_other = size - num_charbufs;
CharBuf *key = num_charbufs ? CB_new(0) : NULL;
Hash_init(self, size);
// Read key-value pairs with CharBuf keys.
while (num_charbufs--) {
uint32_t len = InStream_Read_C32(instream);
char *key_buf = CB_Grow(key, len);
InStream_Read_Bytes(instream, key_buf, len);
key_buf[len] = '\0';
CB_Set_Size(key, len);
Hash_Store(self, (Obj*)key, THAW(instream));
}
DECREF(key);
// Read remaining key/value pairs.
while (num_other--) {
Obj *k = THAW(instream);
Hash_Store(self, k, THAW(instream));
DECREF(k);
}
return self;
}
CharBuf*
Json_to_json(Obj *dump) {
// Validate object type, only allowing hashes and arrays per JSON spec.
if (!dump || !(Obj_Is_A(dump, HASH) || Obj_Is_A(dump, VARRAY))) {
if (!tolerant) {
CharBuf *class_name = dump ? Obj_Get_Class_Name(dump) : NULL;
CharBuf *mess = MAKE_MESS("Illegal top-level object type: %o",
class_name);
Err_set_error(Err_new(mess));
return NULL;
}
}
// Encode.
CharBuf *json = CB_new(31);
if (!S_to_json(dump, json, 0)) {
DECREF(json);
ERR_ADD_FRAME(Err_get_error());
json = NULL;
}
else {
// Append newline.
CB_Cat_Trusted_Str(json, "\n", 1);
}
return json;
}
String*
Highlighter_Encode_IMP(Highlighter *self, String *text) {
UNUSED_VAR(self);
CharBuf *encode_buf = CB_new(0);
String *encoded = S_encode_entities(text, encode_buf);
DECREF(encode_buf);
return encoded;
}
static String*
S_str_vnewf(char *pattern, va_list args) {
CharBuf *buf = CB_new(strlen(pattern) + 10);
CB_VCatF(buf, pattern, args);
String *message = CB_Yield_String(buf);
DECREF(buf);
return message;
}
static void
test_escapes(TestBatch *batch) {
CharBuf *string = CB_new(10);
CharBuf *json_wanted = CB_new(10);
for (int i = 0; control_escapes[i] != NULL; i++) {
CB_Truncate(string, 0);
CB_Cat_Char(string, i);
const char *escaped = control_escapes[i];
CharBuf *json = Json_to_json((Obj*)string);
CharBuf *decoded = (CharBuf*)Json_from_json(json);
CB_setf(json_wanted, "\"%s\"", escaped);
CB_Trim(json);
TEST_TRUE(batch, json != NULL && CB_Equals(json_wanted, (Obj*)json),
"encode control escape: %s", escaped);
TEST_TRUE(batch, decoded != NULL && CB_Equals(string, (Obj*)decoded),
"decode control escape: %s", escaped);
DECREF(json);
DECREF(decoded);
}
for (int i = 0; quote_escapes_source[i] != NULL; i++) {
const char *source = quote_escapes_source[i];
const char *escaped = quote_escapes_json[i];
CB_setf(string, source, strlen(source));
CharBuf *json = Json_to_json((Obj*)string);
CharBuf *decoded = (CharBuf*)Json_from_json(json);
CB_setf(json_wanted, "\"%s\"", escaped);
CB_Trim(json);
TEST_TRUE(batch, json != NULL && CB_Equals(json_wanted, (Obj*)json),
"encode quote/backslash escapes: %s", source);
TEST_TRUE(batch, decoded != NULL && CB_Equals(string, (Obj*)decoded),
"decode quote/backslash escapes: %s", source);
DECREF(json);
DECREF(decoded);
}
DECREF(json_wanted);
DECREF(string);
}
DirHandle*
DH_init(DirHandle *self, const CharBuf *dir) {
DirHandleIVARS *const ivars = DH_IVARS(self);
ivars->dir = CB_Clone(dir);
ivars->entry = CB_new(32);
ABSTRACT_CLASS_CHECK(self, DIRHANDLE);
return self;
}
TextTermStepper*
TextTermStepper_init(TextTermStepper *self) {
TermStepper_init((TermStepper*)self);
TextTermStepperIVARS *const ivars = TextTermStepper_IVARS(self);
ivars->value = (Obj*)CB_new(0);
ivars->string = NULL;
return self;
}
CharBuf*
CB_newf(const char *pattern, ...) {
CharBuf *self = CB_new(strlen(pattern));
va_list args;
va_start(args, pattern);
CB_VCatF(self, pattern, args);
va_end(args);
return self;
}
String*
TestUtils_random_string(size_t length) {
CharBuf *buf = CB_new(length);
while (length--) {
CB_Cat_Char(buf, S_random_code_point());
}
String *string = CB_Yield_String(buf);
DECREF(buf);
return string;
}
void
Err_warn_at(const char *file, int line, const char *func,
const char *pattern, ...) {
va_list args;
CharBuf *message = CB_new(0);
va_start(args, pattern);
S_vcat_mess(message, file, line, func, pattern, args);
va_end(args);
Err_warn_mess(message);
}
CharBuf*
Err_make_mess(const char *file, int line, const char *func,
const char *pattern, ...) {
va_list args;
size_t guess_len = strlen(pattern) + strlen(file) + 20;
CharBuf *message = CB_new(guess_len);
va_start(args, pattern);
S_vcat_mess(message, file, line, func, pattern, args);
va_end(args);
return message;
}
void
CFISH_WARN(char *pattern, ...) {
va_list args;
CharBuf *const message = CB_new(strlen(pattern) + 10);
va_start(args, pattern);
CB_VCatF(message, pattern, args);
va_end(args);
Err_warn_mess(message);
}
FileHandle*
FH_do_open(FileHandle *self, const CharBuf *path, uint32_t flags) {
self->path = path ? CB_Clone(path) : CB_new(0);
self->flags = flags;
// Track number of live FileHandles released into the wild.
FH_object_count++;
ABSTRACT_CLASS_CHECK(self, FILEHANDLE);
return self;
}
String*
Str_newf(const char *pattern, ...) {
CharBuf *buf = CB_new(strlen(pattern));
va_list args;
va_start(args, pattern);
CB_VCatF(buf, pattern, args);
va_end(args);
String *self = CB_Yield_String(buf);
DECREF(buf);
return self;
}
CharBuf*
CFISH_MAKE_MESS(char *pattern, ...) {
va_list args;
CharBuf *const message = CB_new(strlen(pattern) + 10);
va_start(args, pattern);
CB_VCatF(message, pattern, args);
va_end(args);
return message;
}
void
ErrMsg_set(const char *fmt, ...) {
CharBuf *buf = CB_new(0);
va_list args;
va_start(args, fmt);
CB_VCatF(buf, fmt, args);
va_end(args);
Err_set_error(Err_new(CB_Yield_String(buf)));
DECREF(buf);
}
void
THROW(char *pattern, ...)
{
va_list args;
CharBuf *const message = CB_new(strlen(pattern) + 10);
va_start(args, pattern);
CB_VCatF(message, pattern, args);
va_end(args);
Err_throw_mess(message);
}
static void
test_Is_A(TestBatch *batch) {
CharBuf *charbuf = CB_new(0);
VTable *bb_vtable = CB_Get_VTable(charbuf);
CharBuf *klass = CB_Get_Class_Name(charbuf);
TEST_TRUE(batch, CB_Is_A(charbuf, CHARBUF), "CharBuf Is_A CharBuf.");
TEST_TRUE(batch, CB_Is_A(charbuf, OBJ), "CharBuf Is_A Obj.");
TEST_TRUE(batch, bb_vtable == CHARBUF, "Get_VTable");
TEST_TRUE(batch, CB_Equals(VTable_Get_Name(CHARBUF), (Obj*)klass),
"Get_Class_Name");
DECREF(charbuf);
}
String*
Highlighter_Highlight_IMP(Highlighter *self, String *text) {
HighlighterIVARS *const ivars = Highlighter_IVARS(self);
size_t size = Str_Get_Size(text)
+ Str_Get_Size(ivars->pre_tag)
+ Str_Get_Size(ivars->post_tag);
CharBuf *buf = CB_new(size);
CB_Cat(buf, ivars->pre_tag);
CB_Cat(buf, text);
CB_Cat(buf, ivars->post_tag);
String *retval = CB_Yield_String(buf);
DECREF(buf);
return retval;
}
String*
Method_Host_Name_IMP(Method *self) {
StringIterator *iter = StrIter_new(self->name, 0);
CharBuf *charbuf = CB_new(Str_Get_Size(self->name));
int32_t code_point;
while (STR_OOB != (code_point = StrIter_Next(iter))) {
if (code_point != '_') {
CB_Cat_Char(charbuf, code_point);
}
}
String *host_name = CB_Yield_String(charbuf);
DECREF(charbuf);
DECREF(iter);
return host_name;
}
static void
test_Find(TestBatch *batch) {
CharBuf *string = CB_new(10);
CharBuf *substring = S_get_cb("foo");
TEST_TRUE(batch, CB_Find(string, substring) == -1, "Not in empty string");
CB_setf(string, "foo");
TEST_TRUE(batch, CB_Find(string, substring) == 0, "Find complete string");
CB_setf(string, "afoo");
TEST_TRUE(batch, CB_Find(string, substring) == 1, "Find after first");
CB_Set_Size(string, 3);
TEST_TRUE(batch, CB_Find(string, substring) == -1, "Don't overrun");
CB_setf(string, "afood");
TEST_TRUE(batch, CB_Find(string, substring) == 1, "Find in middle");
DECREF(substring);
DECREF(string);
}
void
ErrMsg_set_with_win_error(const char *fmt, ...) {
char *win_error = Err_win_error();
CharBuf *buf = CB_new(0);
va_list args;
va_start(args, fmt);
CB_VCatF(buf, fmt, args);
va_end(args);
CB_Cat_Trusted_Utf8(buf, ": ", 2);
CB_Cat_Utf8(buf, win_error, strlen(win_error));
Err_set_error(Err_new(CB_Yield_String(buf)));
DECREF(buf);
FREEMEM(win_error);
}
