void
update_callback(void *arg, int sqlite_operation_type, char const *sqlite_database, char const *sqlite_table, sqlite3_int64 sqlite_rowid)
{
esqlite_connection *db = (esqlite_connection *)arg;
esqlite_command *cmd = NULL;
ERL_NIF_TERM type, table, rowid;
cmd = command_create();
if(db == NULL)
return;
if(!cmd)
return;
rowid = enif_make_int64(cmd->env, sqlite_rowid);
table = enif_make_string(cmd->env, sqlite_table, ERL_NIF_LATIN1);
switch(sqlite_operation_type) {
case SQLITE_INSERT:
type = make_atom(cmd->env, "insert");
break;
case SQLITE_DELETE:
type = make_atom(cmd->env, "delete");
break;
case SQLITE_UPDATE:
type = make_atom(cmd->env, "update");
break;
default:
return;
}
cmd->type = cmd_notification;
cmd->arg = enif_make_tuple3(cmd->env, type, table, rowid);
push_command(cmd->env, db, cmd);
}
static int
purge_module(int module)
{
Eterm* code;
Eterm* end;
Module* modp;
int i;
/*
* Correct module?
*/
if ((modp = erts_get_module(make_atom(module))) == NULL) {
return -2;
}
/*
* Any code to purge?
*/
if (modp->old_code == 0) {
if (display_loads) {
erts_printf("No code to purge for %T\n", make_atom(module));
}
return -1;
}
/*
* Remove the old code.
*/
ASSERT(erts_total_code_size >= modp->old_code_length);
erts_total_code_size -= modp->old_code_length;
code = modp->old_code;
end = (Eterm *)((char *)code + modp->old_code_length);
erts_cleanup_funs_on_purge(code, end);
beam_catches_delmod(modp->old_catches, code, modp->old_code_length);
erts_free(ERTS_ALC_T_CODE, (void *) code);
modp->old_code = NULL;
modp->old_code_length = 0;
modp->old_catches = BEAM_CATCHES_NIL;
/*
* Remove the code from the address table too.
*/
for (i = 0; i < num_loaded_modules; i++) {
if (modules[i].start == code) {
num_loaded_modules--;
while (i < num_loaded_modules) {
modules[i] = modules[i+1];
i++;
}
mid_module = &modules[num_loaded_modules/2];
return 0;
}
}
ASSERT(0); /* Not found? */
return 0;
}
static ERL_NIF_TERM
do_get_autocommit(ErlNifEnv *env, esqlite_connection *conn)
{
if(sqlite3_get_autocommit(conn->db) != 0) {
return make_atom(env, "true");
} else {
return make_atom(env, "false");
}
}
static ERL_NIF_TERM
make_sqlite3_error_tuple(ErlNifEnv *env, int error_code, sqlite3 *db)
{
const char *error_code_msg = get_sqlite3_return_code_msg(error_code);
const char *msg = get_sqlite3_error_msg(error_code, db);
return enif_make_tuple2(env, make_atom(env, "error"),
enif_make_tuple2(env, make_atom(env, error_code_msg),
enif_make_string(env, msg, ERL_NIF_LATIN1)));
}
static ERL_NIF_TERM
do_multi_step(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt, const ERL_NIF_TERM arg)
{
ERL_NIF_TERM status;
ERL_NIF_TERM rows = enif_make_list_from_array(env, NULL, 0);
ERL_NIF_TERM *rowBuffer = NULL;
int rowBufferSize = 0;
int chunk_size = 0;
enif_get_int(env, arg, &chunk_size);
int rc = sqlite3_step(stmt);
while (rc == SQLITE_ROW && chunk_size-- > 0)
{
if (!rowBufferSize)
rowBufferSize = sqlite3_column_count(stmt);
if (rowBuffer == NULL)
rowBuffer = (ERL_NIF_TERM *) enif_alloc(sizeof(ERL_NIF_TERM)*rowBufferSize);
rows = enif_make_list_cell(env, make_row(env, stmt, rowBuffer, rowBufferSize), rows);
if (chunk_size > 0)
rc = sqlite3_step(stmt);
}
switch(rc) {
case SQLITE_ROW:
status = make_atom(env, "rows");
break;
case SQLITE_BUSY:
status = make_atom(env, "$busy");
break;
case SQLITE_DONE:
/*
* Automatically reset the statement after a done so
* column_names will work after the statement is done.
*
* Not resetting the statement can lead to vm crashes.
*/
sqlite3_reset(stmt);
status = make_atom(env, "$done");
break;
default:
/* We use prepare_v2, so any error code can be returned. */
return make_sqlite3_error_tuple(env, rc, db);
}
enif_free(rowBuffer);
return enif_make_tuple2(env, status, rows);
}
MCPasteboard *MCScreenDC::getselection(void)
{
MCXPasteboard *t_pasteboard ;
if ( !ownsclipboard())
m_Selection_store -> GetExternalTypes(MCclipboardatom, make_atom("REV_SELECTION_TYPES"), NULLWindow);
// Create the pasteboard we will use, wrapping the clipboard
t_pasteboard = new MCXPasteboard ( XA_PRIMARY,make_atom("REV_SELECTION"), m_Selection_store );
t_pasteboard -> SetWindows( XGetSelectionOwner(dpy, XA_PRIMARY), NULLWindow );
return t_pasteboard ;
}
MCPasteboard *MCScreenDC::getclipboard(void)
{
MCXPasteboard *t_pasteboard ;
if ( !ownsclipboard())
m_Clipboard_store -> GetExternalTypes(MCclipboardatom, make_atom("REV_CLIPBOARD_TYPES"), NULLWindow);
// Create the pasteboard we will use, wrapping the clipboard
t_pasteboard = new MCXPasteboard ( MCclipboardatom,make_atom("REV_CLIPBOARD"), m_Clipboard_store );
t_pasteboard -> SetWindows( XGetSelectionOwner(dpy, MCclipboardatom), NULLWindow );
return t_pasteboard ;
}
static int
purge_module(int module)
{
BeamInstr* code;
BeamInstr* end;
Module* modp;
/*
* Correct module?
*/
if ((modp = erts_get_module(make_atom(module))) == NULL) {
return -2;
}
/*
* Any code to purge?
*/
if (modp->old_code == 0) {
if (display_loads) {
erts_printf("No code to purge for %T\n", make_atom(module));
}
return -1;
}
/*
* Unload any NIF library
*/
if (modp->old_nif != NULL) {
erts_unload_nif(modp->old_nif);
modp->old_nif = NULL;
}
/*
* Remove the old code.
*/
ASSERT(erts_total_code_size >= modp->old_code_length);
erts_total_code_size -= modp->old_code_length;
code = modp->old_code;
end = (BeamInstr *)((char *)code + modp->old_code_length);
erts_cleanup_funs_on_purge(code, end);
beam_catches_delmod(modp->old_catches, code, modp->old_code_length);
erts_free(ERTS_ALC_T_CODE, (void *) code);
modp->old_code = NULL;
modp->old_code_length = 0;
modp->old_catches = BEAM_CATCHES_NIL;
remove_from_address_table(code);
return 0;
}
/*
* NIF callbacks
*/
static int
load(ErlNifEnv* env, void** priv, ERL_NIF_TERM info)
{
htpasswd_st* st = enif_alloc(sizeof(htpasswd_st));
if(st == NULL) {
return 1;
}
st->atom_true = make_atom(env, "true");
st->atom_false = make_atom(env, "false");
*priv = (void*) st;
return 0;
}
/*
* Parse a term.
*/
static bool parse_term_op(context_t cxt, term_t *val, unsigned priority)
{
term_t lval;
if (!parse_term_head(cxt, &lval))
return false;
do
{
char *op_name = (char *)gc_malloc(TOKEN_MAXLEN+1);
token_t tok = token_peek(cxt, NULL, op_name);
unsigned op_priority;
assoc_t op_assoc;
if (!parse_maybe_op(tok) ||
!binop_lookup(cxt->opinfo, op_name, &op_assoc, &op_priority, NULL,
NULL) ||
op_priority > priority)
{
*val = lval;
gc_free(op_name);
return true;
}
if (op_priority == priority)
{
switch (op_assoc)
{
case YFX:
*val = lval;
return true;
case XFY:
break;
case XFX:
parse_error(cxt, "operator `!y%s!d' associativity error",
op_name);
gc_free(op_name);
return false;
}
}
if (!token_expect(cxt, tok))
{
gc_free(op_name);
return false;
}
term_t rval;
if (!parse_term_op(cxt, &rval, op_priority))
{
gc_free(op_name);
return false;
}
atom_t atom = make_atom(gc_strdup(op_name), 2);
gc_free(op_name);
func_t f = make_func(atom, lval, rval);
lval = term_func(f);
}
while (true);
}
// ファイルディスクリプタの状態を返す
CELLP fmode_f(CELLP arg)
{
int i;
ATOMP ap;
STR s;
if (arg->id != _CELL) {
return error(NEA);
}
if (arg->car->id != _FIX) {
return error(IFD);
}
i = (int)((NUMP)(arg->car))->value.fix;
if (i < 0 || i >= NFILES) {
return error(IFD);
}
if (fp[i].ptr == NULL) {
return (CELLP)nil;
}
s = (STR)modestr[fp[i].mode];
if ((ap = old_atom(s)) == NULL) {
return (CELLP)make_atom(s);
}
return (CELLP)ap;
}
CELLP readch_f(CELLP arg)
{
char ch[2] = {0};
int i;
FILE* nfp = cur_fpi;
ATOMP ap;
dirin(arg); ec;
if (_isatty(_fileno(cur_fpi))) {
i = _getch();
} else {
i = fgetc(cur_fpi);
}
if (i == EOF) {
return (CELLP)eofread;
}
ch[0] = i;
ch[1] = '\0';
cur_fpi = nfp;
if ((ap = old_atom((STR)ch)) == NULL) {
return (CELLP)make_atom((STR)ch);
}
return (CELLP)ap;
}
static ERL_NIF_TERM
do_column_names(ErlNifEnv *env, sqlite3_stmt *stmt)
{
int i, size;
const char *name;
ERL_NIF_TERM *array;
ERL_NIF_TERM column_names;
size = sqlite3_column_count(stmt);
if(size <= 0)
return make_error_tuple(env, "no_columns");
array = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM) * size);
if(!array)
return make_error_tuple(env, "no_memory");
for(i = 0; i < size; i++) {
name = sqlite3_column_name(stmt, i);
if(name == NULL) {
free(array);
return make_error_tuple(env, "sqlite3_malloc_failure");
}
array[i] = make_atom(env, name);
}
column_names = enif_make_tuple_from_array(env, array, size);
free(array);
return column_names;
}
static ERL_NIF_TERM
do_column_types(ErlNifEnv *env, sqlite3_stmt *stmt)
{
int i, size;
const char *type;
ERL_NIF_TERM *array;
ERL_NIF_TERM column_types;
size = sqlite3_column_count(stmt);
if(size == 0)
return enif_make_tuple(env, 0);
else if(size < 0)
return make_error_tuple(env, "invalid_column_count");
array = (ERL_NIF_TERM *) enif_alloc(sizeof(ERL_NIF_TERM) * size);
if(!array)
return make_error_tuple(env, "no_memory");
for(i = 0; i < size; i++) {
type = sqlite3_column_decltype(stmt, i);
if(type == NULL) {
type = "nil";
}
array[i] = make_atom(env, type);
}
column_types = enif_make_tuple_from_array(env, array, size);
enif_free(array);
return column_types;
}
BIF_RETTYPE loaded_0(BIF_ALIST_0)
{
ErtsCodeIndex code_ix = erts_active_code_ix();
Module* modp;
Eterm previous = NIL;
Eterm* hp;
int i;
int j = 0;
for (i = 0; i < module_code_size(code_ix); i++) {
if ((modp = module_code(i, code_ix)) != NULL &&
((modp->curr.code_length != 0) ||
(modp->old.code_length != 0))) {
j++;
}
}
if (j > 0) {
hp = HAlloc(BIF_P, j*2);
for (i = 0; i < module_code_size(code_ix); i++) {
if ((modp=module_code(i,code_ix)) != NULL &&
((modp->curr.code_length != 0) ||
(modp->old.code_length != 0))) {
previous = CONS(hp, make_atom(modp->module), previous);
hp += 2;
}
}
}
BIF_RET(previous);
}
BIF_RETTYPE loaded_0(BIF_ALIST_0)
{
Eterm previous = NIL;
Eterm* hp;
int i;
int j = 0;
for (i = 0; i < module_code_size(); i++) {
if (module_code(i) != NULL &&
((module_code(i)->code_length != 0) ||
(module_code(i)->old_code_length != 0))) {
j++;
}
}
if (j > 0) {
hp = HAlloc(BIF_P, j*2);
for (i = 0; i < module_code_size(); i++) {
if (module_code(i) != NULL &&
((module_code(i)->code_length != 0) ||
(module_code(i)->old_code_length != 0))) {
previous = CONS(hp, make_atom(module_code(i)->module),
previous);
hp += 2;
}
}
}
BIF_RET(previous);
}
static ERL_NIF_TERM
do_bind(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt, const ERL_NIF_TERM arg)
{
int parameter_count = sqlite3_bind_parameter_count(stmt);
int i, is_list, r;
ERL_NIF_TERM list, head, tail;
unsigned int list_length;
is_list = enif_get_list_length(env, arg, &list_length);
if(!is_list)
return make_error_tuple(env, "bad_arg_list");
if(parameter_count != list_length)
return make_error_tuple(env, "args_wrong_length");
sqlite3_reset(stmt);
list = arg;
for(i=0; i < list_length; i++) {
enif_get_list_cell(env, list, &head, &tail);
r = bind_cell(env, head, stmt, i+1);
if(r == -1)
return make_error_tuple(env, "wrong_type");
if(r != SQLITE_OK)
return make_sqlite3_error_tuple(env, r, db);
list = tail;
}
return make_atom(env, "ok");
}
static ERL_NIF_TERM
push_command(ErlNifEnv *env, esqlite_connection *conn, esqlite_command *cmd) {
if(!queue_push(conn->commands, cmd))
return make_error_tuple(env, "command_push_failed");
return make_atom(env, "ok");
}
// Checks that there is a clipboard manager running
// and that it supports clipboard persistance
bool MCScreenDC::check_clipboard_manager(void)
{
Atom clipboard_manager;
clipboard_manager = make_atom ("CLIPBOARD_MANAGER");
return XGetSelectionOwner (dpy, clipboard_manager) != None;
}
static ERL_NIF_TERM
do_open(ErlNifEnv *env, esqlite_connection *db, const ERL_NIF_TERM arg)
{
char filename[MAX_PATHNAME];
unsigned int size;
int rc;
ERL_NIF_TERM error;
size = enif_get_string(env, arg, filename, MAX_PATHNAME, ERL_NIF_LATIN1);
if(size <= 0)
return make_error_tuple(env, "invalid_filename");
/* Open the database.
*/
rc = sqlite3_open(filename, &db->db);
if(rc != SQLITE_OK) {
error = make_sqlite3_error_tuple(env, rc, db->db);
sqlite3_close(db->db);
db->db = NULL;
return error;
}
return make_atom(env, "ok");
}
static void defsubr(STR name, CELLP funcp, char type)
{
ATOMP ap;
ap = make_atom(name);
ap->ftype = type;
ap->fptr = (CELLP)funcp;
}
ERL_NIF_TERM
dec_error(Decoder* d, const char* atom)
{
ERL_NIF_TERM pos = enif_make_int(d->env, d->i+1);
ERL_NIF_TERM msg = make_atom(d->env, atom);
ERL_NIF_TERM ret = enif_make_tuple2(d->env, pos, msg);
return enif_make_tuple2(d->env, d->atoms->atom_error, ret);
}
void test(void) {
int i;
for (i = 1; i <= 5; i++) {
make_atom(i * 10);
}
f();
}
ErlNifResourceType*
enif_open_resource_type(ErlNifEnv* env,
const char* module_str,
const char* name_str,
ErlNifResourceDtor* dtor,
ErlNifResourceFlags flags,
ErlNifResourceFlags* tried)
{
ErlNifResourceType* type = NULL;
ErlNifResourceFlags op = flags;
Eterm module_am, name_am;
ASSERT(erts_smp_thr_progress_is_blocking());
ASSERT(module_str == NULL); /* for now... */
module_am = make_atom(env->mod_nif->mod->module);
name_am = enif_make_atom(env, name_str);
type = find_resource_type(module_am, name_am);
if (type == NULL) {
if (flags & ERL_NIF_RT_CREATE) {
type = erts_alloc(ERTS_ALC_T_NIF,
sizeof(struct enif_resource_type_t));
type->dtor = dtor;
type->module = module_am;
type->name = name_am;
erts_refc_init(&type->refc, 1);
type->owner = env->mod_nif;
type->prev = &resource_type_list;
type->next = resource_type_list.next;
type->next->prev = type;
type->prev->next = type;
op = ERL_NIF_RT_CREATE;
}
}
else {
if (flags & ERL_NIF_RT_TAKEOVER) {
steal_resource_type(type);
op = ERL_NIF_RT_TAKEOVER;
}
else {
type = NULL;
}
}
if (type != NULL) {
type->owner = env->mod_nif;
type->dtor = dtor;
if (type->dtor != NULL) {
erts_refc_inc(&type->owner->rt_dtor_cnt, 1);
}
erts_refc_inc(&type->owner->rt_cnt, 1);
}
if (tried != NULL) {
*tried = op;
}
return type;
}
static ERL_NIF_TERM
do_step(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt)
{
int rc = sqlite3_step(stmt);
if(rc == SQLITE_ROW)
return make_row(env, stmt);
if(rc == SQLITE_DONE)
return make_atom(env, "$done");
if(rc == SQLITE_BUSY)
return make_atom(env, "$busy");
if(rc == SQLITE_ERROR)
return make_sqlite3_error_tuple(env, rc, db);
if(rc == SQLITE_MISUSE)
return make_error_tuple(env, "misuse");
return make_error_tuple(env, "unexpected_return_value");
}
static int
_load_module(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
ErlNifResourceFlags flags;
CAN_handle_type = enif_open_resource_type(env, MODULE, "CAN_handle_type",
NULL, ERL_NIF_RT_CREATE, &flags);
can_atom = make_atom(env, "can");
enif_fprintf(stdout, "*** " MODULE " loaded\n");
return 0;
}
static ERL_NIF_TERM
do_reset(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt)
{
int rc = sqlite3_reset(stmt);
if(rc == SQLITE_OK)
return make_atom(env, "ok");
return make_sqlite3_error_tuple(env, rc, db);
}
static ERL_NIF_TERM
update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
md5ctx* ctx;
ErlNifBinary bin;
if(argc != 2)
return enif_make_badarg(env);
if(!enif_get_resource(env, argv[0], md5_type, (void**) &ctx))
return enif_make_badarg(env);
if(!enif_inspect_binary(env, argv[1], &bin))
return enif_make_badarg(env);
if(ctx->finalized)
return make_atom(env, "already_finalized");
if(!MD5_Update(&(ctx->md5), bin.data, bin.size))
return make_atom(env, "update_error");
return make_atom(env, "ok");
}
static ERL_NIF_TERM
do_close(ErlNifEnv *env, esqlite_connection *conn, const ERL_NIF_TERM arg)
{
int rc;
rc = sqlite3_close(conn->db);
if(rc != SQLITE_OK)
return make_sqlite3_error_tuple(env, rc, conn->db);
conn->db = NULL;
return make_atom(env, "ok");
}
static ERL_NIF_TERM
do_set_update_hook(ErlNifEnv *env, esqlite_connection *db, const ERL_NIF_TERM arg)
{
if(!enif_get_local_pid(env, arg, &db->notification_pid))
return make_error_tuple(env, "invalid_pid");
sqlite3_update_hook(db->db, NULL, NULL);
if(sqlite3_update_hook(db->db, update_callback, db) != SQLITE_OK)
return make_error_tuple(env, "sqlite3_update_hook_fail");
return make_atom(env, "ok");
}
