static int callback(void *notUsed, int argc, char **argv, char **azColName)
{
ETERM **record_list;
int i;
if (result == 0) {
result = erl_mk_empty_list();
}
record_list = malloc(argc * sizeof(ETERM *));
fprintf(log, "runs %d\n", argc);
for (i = 0; i < argc; i++) {
fprintf(log, "%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
if (argv[i]) {
record_list[i] = erl_mk_string(argv[i]);
}
else {
record_list[i] = erl_mk_empty_list();
}
}
fprintf(log, "\n");
fflush(log);
result = erl_cons(erl_mk_tuple(record_list, argc), result);
free(record_list);
return 0;
}
void local_add_watch(ETERM* args)
{
ETERM *pathp = erl_element(1, args);
int pathLength = ERL_BIN_SIZE(pathp);
char *path = ERL_BIN_PTR(pathp);
ETERM *notifyFilterp = erl_element(2, args);
unsigned int notifyFilter_ui = ERL_INT_UVALUE(notifyFilterp);
long notifyFilter = (long)notifyFilter_ui;
ETERM *watchSubdirsp = erl_element(3, args);
int watchSubdirs = ERL_INT_VALUE(watchSubdirsp);
int watchID = eNotify_addWatch(path, pathLength, notifyFilter, watchSubdirs);
// Prepare response
ETERM *tuplep;
ETERM *tupleArray[2];
if (watchID < 0)
{
long errorCode = (long)(-watchID);
char errorDesc[1024];
eNotify_getErrorDesc(errorCode, errorDesc, 1024);
tupleArray[0] = erl_mk_atom("error");
tupleArray[1] = erl_mk_string(errorDesc);
}
else if (0 == watchID)
{
// this may happen if there's a problem converting
// a path from utf8 to UTF16
tupleArray[0] = erl_mk_atom("error");
tupleArray[1] = erl_mk_string("internal_error");
}
else
{
tupleArray[0] = erl_mk_atom("ok");
tupleArray[1] = erl_mk_int(watchID);
}
char buf[1024];
tuplep = erl_mk_tuple(tupleArray, 2);
erl_encode(tuplep, buf);
write_cmd(buf, erl_term_len(tuplep));
erl_free_array(tupleArray, 2); // free contents from tupleArray
}
void local_get_error_desc(ETERM* args)
{
byte buf[100];
ETERM *resp;
ETERM *errorCodep = erl_element(1, args);
long errorCode = (long)ERL_INT_VALUE(errorCodep);
char errorDesc[1024];
eNotify_getErrorDesc(errorCode, errorDesc, 1024);
// Build response
resp = erl_mk_string(errorDesc); // alloc resp
erl_encode(resp, buf);
write_cmd(buf, erl_term_len(resp));
erl_free_term(resp); // free resp
}
void send_error(char *err_msg)
{
ETERM *tup_list[2];
ETERM *to_send;
tup_list[0] = erl_mk_atom("sql_error");
tup_list[1] = erl_mk_string(err_msg);
to_send = erl_mk_tuple(tup_list, 2);
fprintf(log, "SQL Error: %s\n", err_msg);
respond(to_send);
erl_free_term(tup_list[0]);
erl_free_term(tup_list[1]);
erl_free_compound(to_send);
}
static ETERM*
all_types(void)
{
ETERM* t;
ETERM* terms[3];
int i;
static char a_binary[] = "A binary";
#define CONS_AND_FREE(expr, tail) \
do { \
ETERM* term = expr; \
ETERM* nl = erl_cons(term, tail); \
erl_free_term(term); \
erl_free_term(tail); \
tail = nl; \
} while (0)
t = erl_mk_empty_list();
CONS_AND_FREE(erl_mk_atom("I am an atom"), t);
CONS_AND_FREE(erl_mk_binary("A binary", sizeof(a_binary)-1), t);
CONS_AND_FREE(erl_mk_float(3.0), t);
CONS_AND_FREE(erl_mk_int(0), t);
CONS_AND_FREE(erl_mk_int(-1), t);
CONS_AND_FREE(erl_mk_int(1), t);
CONS_AND_FREE(erl_mk_string("A string"), t);
terms[0] = erl_mk_atom("element1");
terms[1] = erl_mk_int(42);
terms[2] = erl_mk_int(767);
CONS_AND_FREE(erl_mk_tuple(terms, ASIZE(terms)), t);
for (i = 0; i < ASIZE(terms); i++) {
erl_free_term(terms[i]);
}
CONS_AND_FREE(erl_mk_pid("kalle@localhost", 3, 2, 1), t);
CONS_AND_FREE(erl_mk_pid("abcdefghijabcdefghij@localhost", 3, 2, 1), t);
CONS_AND_FREE(erl_mk_port("kalle@localhost", 4, 1), t);
CONS_AND_FREE(erl_mk_port("abcdefghijabcdefghij@localhost", 4, 1), t);
CONS_AND_FREE(erl_mk_ref("kalle@localhost", 6, 1), t);
CONS_AND_FREE(erl_mk_ref("abcdefghijabcdefghij@localhost", 6, 1), t);
return t;
#undef CONS_AND_FREE
}
ETERM *
make_cols()
{
ETERM **cols, *rc;
unsigned int i;
cols = (ETERM **)safe_malloc(numfields * sizeof(ETERM *));
for (i = 0; i < numfields; i++)
cols[i] = erl_mk_string(fields[i].name);
rc = erl_mk_list(cols, numfields);
for (i = 0; i < numfields; i++)
erl_free_term(cols[i]);
free(cols);
return rc;
}
int main(void)
#endif
{
ei_x_buff eix;
int index = 0;
ETERM **etermpp = NULL, *etermp = NULL;
char *charp = NULL;
unsigned char uchar, **ucharpp = NULL, *ucharp = NULL;
void *voidp = NULL;
Erl_Heap *erl_heapp = NULL;
int intx = 0;
int *intp = NULL;
unsigned int uintx, *uintp;
unsigned long *ulongp = NULL;
long longx = 0;
double doublex = 0.0;
short shortx = 42;
FILE *filep = NULL;
Erl_IpAddr erl_ipaddr = NULL;
ErlMessage *erlmessagep = NULL;
ErlConnect *erlconnectp = NULL;
struct hostent *hostp = NULL;
struct in_addr *inaddrp = NULL;
/* Converion to erl_interface format is in liberl_interface */
intx = erl_errno;
ei_encode_term(charp, &index, voidp);
ei_x_encode_term(&eix, voidp);
ei_decode_term(charp, &index, voidp);
erl_init(voidp, longx);
erl_connect_init(intx, charp,shortx);
erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx);
erl_connect(charp);
erl_xconnect(erl_ipaddr,charp);
erl_close_connection(intx);
erl_receive(intx, ucharp, intx);
erl_receive_msg(intx, ucharp, intx, erlmessagep);
erl_xreceive_msg(intx, ucharpp, intp, erlmessagep);
erl_send(intx, etermp, etermp);
erl_reg_send(intx, charp, etermp);
erl_rpc(intx,charp,charp,etermp);
erl_rpc_to(intx,charp,charp,etermp);
erl_rpc_from(intx,intx,erlmessagep);
erl_publish(intx);
erl_accept(intx,erlconnectp);
erl_thiscookie();
erl_thisnodename();
erl_thishostname();
erl_thisalivename();
erl_thiscreation();
erl_unpublish(charp);
erl_err_msg(charp);
erl_err_quit(charp);
erl_err_ret(charp);
erl_err_sys(charp);
erl_cons(etermp,etermp);
erl_copy_term(etermp);
erl_element(intx,etermp);
erl_hd(etermp);
erl_iolist_to_binary(etermp);
erl_iolist_to_string(etermp);
erl_iolist_length(etermp);
erl_length(etermp);
erl_mk_atom(charp);
erl_mk_binary(charp,intx);
erl_mk_empty_list();
erl_mk_estring(charp, intx);
erl_mk_float(doublex);
erl_mk_int(intx);
erl_mk_list(etermpp,intx);
erl_mk_pid(charp,uintx,uintx,uchar);
erl_mk_port(charp,uintx,uchar);
erl_mk_ref(charp,uintx,uchar);
erl_mk_long_ref(charp,uintx,uintx,uintx,uchar);
erl_mk_string(charp);
erl_mk_tuple(etermpp,intx);
erl_mk_uint(uintx);
erl_mk_var(charp);
erl_print_term(filep,etermp);
/* erl_sprint_term(charp,etermp); */
erl_size(etermp);
erl_tl(etermp);
erl_var_content(etermp, charp);
erl_format(charp);
erl_match(etermp, etermp);
erl_global_names(intx, intp);
erl_global_register(intx, charp, etermp);
erl_global_unregister(intx, charp);
erl_global_whereis(intx, charp, charp);
erl_init_malloc(erl_heapp,longx);
erl_alloc_eterm(uchar);
erl_eterm_release();
erl_eterm_statistics(ulongp,ulongp);
erl_free_array(etermpp,intx);
erl_free_term(etermp);
erl_free_compound(etermp);
erl_malloc(longx);
erl_free(voidp);
erl_compare_ext(ucharp, ucharp);
erl_decode(ucharp);
erl_decode_buf(ucharpp);
erl_encode(etermp,ucharp);
erl_encode_buf(etermp,ucharpp);
erl_ext_size(ucharp);
erl_ext_type(ucharp);
erl_peek_ext(ucharp,intx);
erl_term_len(etermp);
erl_gethostbyname(charp);
erl_gethostbyaddr(charp, intx, intx);
erl_gethostbyname_r(charp, hostp, charp, intx, intp);
erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
erl_init_resolve();
erl_distversion(intx);
erl_epmd_connect(inaddrp);
erl_epmd_port(inaddrp, charp, intp);
charp = ERL_ATOM_PTR(etermp);
intx = ERL_ATOM_SIZE(etermp);
ucharp = ERL_BIN_PTR(etermp);
intx = ERL_BIN_SIZE(etermp);
etermp = ERL_CONS_HEAD(etermp);
etermp = ERL_CONS_TAIL(etermp);
intx = ERL_COUNT(etermp);
doublex= ERL_FLOAT_VALUE(etermp);
uintx = ERL_INT_UVALUE(etermp);
intx = ERL_INT_VALUE(etermp);
intx = ERL_IS_ATOM(etermp);
intx = ERL_IS_BINARY(etermp);
intx = ERL_IS_CONS(etermp);
intx = ERL_IS_EMPTY_LIST(etermp);
intx = ERL_IS_FLOAT(etermp);
intx = ERL_IS_INTEGER(etermp);
intx = ERL_IS_LIST(etermp);
intx = ERL_IS_PID(etermp);
intx = ERL_IS_PORT(etermp);
intx = ERL_IS_REF(etermp);
intx = ERL_IS_TUPLE(etermp);
intx = ERL_IS_UNSIGNED_INTEGER(etermp);
uchar = ERL_PID_CREATION(etermp);
charp = ERL_PID_NODE(etermp);
uintx = ERL_PID_NUMBER(etermp);
uintx = ERL_PID_SERIAL(etermp);
uchar = ERL_PORT_CREATION(etermp);
charp = ERL_PORT_NODE(etermp);
uintx = ERL_PORT_NUMBER(etermp);
uchar = ERL_REF_CREATION(etermp);
intx = ERL_REF_LEN(etermp);
charp = ERL_REF_NODE(etermp);
uintx = ERL_REF_NUMBER(etermp);
uintp = ERL_REF_NUMBERS(etermp);
etermp = ERL_TUPLE_ELEMENT(etermp,intx);
intx = ERL_TUPLE_SIZE(etermp);
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EINVAL +
EIO +
EMSGSIZE +
ENOMEM +
ERL_ATOM +
ERL_BINARY +
ERL_ERROR +
ERL_EXIT +
ERL_FLOAT +
ERL_INTEGER +
ERL_LINK +
ERL_LIST +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_PID +
ERL_PORT +
ERL_REF +
ERL_REG_SEND +
ERL_SEND +
ERL_SMALL_BIG +
ERL_TICK +
ERL_TIMEOUT +
ERL_TUPLE +
ERL_UNLINK +
ERL_U_INTEGER +
ERL_U_SMALL_BIG +
ERL_VARIABLE +
ETIMEDOUT +
MAXNODELEN +
MAXREGLEN;
}
