int native_dirmonitor_new(Ref *r, const char *path)
{
FileMonitor *fm = FileMonitor_new();
{
wchar_t *wpath = filename_to_utf16(path, NULL);
fm->hDir = CreateFileW(wpath, FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
free(wpath);
}
if (fm->hDir == INVALID_HANDLE_VALUE) {
fs->throw_error_select(THROW_CANNOT_OPEN_FILE__STR, Str_new(path, -1));
free(fm);
return FALSE;
}
fm->ref = r;
fm->overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
fm->valid = TRUE;
if (!refresh_dirmonitor(fm, FALSE)) {
CloseHandle(fm->overlapped.hEvent);
CloseHandle(fm->hDir);
fs->throw_error_select(THROW_CANNOT_OPEN_FILE__STR, Str_new(path, -1));
return FALSE;
}
r->v[INDEX_FILEMONITOR_STRUCT] = ptr_Value(fm);
return TRUE;
}
static int markdown_new(Value *vret, Value *v, RefNode *node)
{
RefNode *cls_markdown = FUNC_VP(node);
Ref *ref;
Markdown *md;
RefNode *type = fs->Value_type(*v);
// 継承可能なクラス
if (type == fs->cls_fn) {
ref = fs->ref_new(cls_markdown);
*vret = vp_Value(ref);
} else {
ref = Value_vp(*v);
*vret = fs->Value_cp(*v);
}
md = malloc(sizeof(Markdown));
memset(md, 0, sizeof(Markdown));
ref->v[INDEX_MARKDOWN_MD] = ptr_Value(md);
fs->Mem_init(&md->mem, 1024);
md->tabstop = 4;
md->heading_level = 1;
md->footnote_id = 1;
md->heading_p = &md->heading;
md->footnote_p = &md->footnote;
fs->Hash_init(&md->hilight, &md->mem, 16);
return TRUE;
}
int map_iterator(Value *vret, Value *v, RefNode *node)
{
RefMap *rm = Value_vp(*v);
int type = FUNC_INT(node);
Ref *r = ref_new(cls_mapiter);
rm->lock_count++;
r->v[INDEX_MAPITER_VAL] = Value_cp(*v);
r->v[INDEX_MAPITER_TYPE] = int32_Value(type);
r->v[INDEX_MAPITER_PTR] = ptr_Value(NULL);
r->v[INDEX_MAPITER_IDX] = int32_Value(0);
*vret = vp_Value(r);
return TRUE;
}
static int conn_memory(Value *vret, Value *v, RefNode *node)
{
sqlite3 *conn = NULL;
Ref *r = fs->ref_new(cls_sqlite);
int result = sqlite3_open(":memory:", &conn);
*vret = vp_Value(r);
if (result != SQLITE_OK || conn == NULL) {
fs->throw_errorf(mod_sqlite, "SQLiteError", "Cannot connect sqlite (memory)");
return FALSE;
}
r->v[INDEX_SQLITE_CONN] = ptr_Value(conn);
r->v[INDEX_SQLITE_FUNC] = vp_Value(fs->refarray_new(0));
return TRUE;
}
static int conn_new(Value *vret, Value *v, RefNode *node)
{
int flag = SQLITE_OPEN_READONLY;
sqlite3 *conn = NULL;
int result = SQLITE_OK;
Ref *r = fs->ref_new(cls_sqlite);
Str path_s;
char *path = fs->file_value_to_path(&path_s, v[1], 0);
*vret = vp_Value(r);
if (path == NULL) {
return FALSE;
}
if (fg->stk_top > v + 2) {
RefStr *m = Value_vp(v[2]);
if (str_eq(m->c, m->size, "r", -1)) {
} else if (str_eq(m->c, m->size, "w", -1)) {
flag = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
} else {
fs->throw_errorf(fs->mod_lang, "ValueError", "Unknown open mode %q", m->c);
free(path);
return FALSE;
}
}
result = sqlite3_open_v2(path, &conn, flag, NULL);
if (result != SQLITE_OK || conn == NULL) {
fs->throw_error_select(THROW_CANNOT_OPEN_FILE__STR, path_s);
free(path);
return FALSE;
}
r->v[INDEX_SQLITE_CONN] = ptr_Value(conn);
r->v[INDEX_SQLITE_FUNC] = vp_Value(fs->refarray_new(0));
free(path);
return TRUE;
}
static int mapiter_next(Value *vret, Value *v, RefNode *node)
{
Ref *r = Value_ref(*v);
RefMap *map = Value_vp(r->v[INDEX_MAPITER_VAL]);
int idx = Value_integral(r->v[INDEX_MAPITER_IDX]);
HashValueEntry *ep = Value_ptr(r->v[INDEX_MAPITER_PTR]);
if (ep != NULL) {
ep = ep->next;
}
while (ep == NULL && idx < map->entry_num) {
ep = map->entry[idx];
idx++;
}
r->v[INDEX_MAPITER_IDX] = int32_Value(idx);
r->v[INDEX_MAPITER_PTR] = ptr_Value(ep);
if (ep != NULL) {
switch (Value_integral(r->v[INDEX_MAPITER_TYPE])) {
case ITERATOR_KEY:
*vret = Value_cp(ep->key);
break;
case ITERATOR_VAL:
*vret = Value_cp(ep->val);
break;
default: {
Ref *r2 = ref_new(fv->cls_entry);
*vret = vp_Value(r2);
r2->v[INDEX_ENTRY_KEY] = Value_cp(ep->key);
r2->v[INDEX_ENTRY_VAL] = Value_cp(ep->val);
break;
}
}
} else {
throw_stopiter();
return FALSE;
}
return TRUE;
}
Value handle_Value(void *handle)
{
return ptr_Value(handle);
}
