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); }