ETERM *space_delete(ETERM *fromp, ETERM *argp) { // get the args ETERM *space_refp = erl_element(1, argp); erlmunk_space *s; int space_id = ERL_REF_NUMBER(space_refp); HASH_FIND_INT(erlmunk_spaces, &space_id, s); // remove all subscribers for(erlmunk_subscriber *subscriber = s->subscribers; subscriber != NULL; subscriber = subscriber->hh.next) { space_remove_subscriber(s, subscriber); } // remove all bodies for(erlmunk_body *b = s->bodies; b != NULL; b = b->hh.next) { erlmunk_body_data *data = cpBodyGetUserData(b->body); if (data->term != NULL) erl_free_compound(data->term); free(data); cpSpaceRemoveBody(s->space, b->body); cpBodyDestroy(b->body); cpBodyFree(b->body); space_remove_body_hash(s, b); } return NULL; }
int main() { ETERM *tuplep, *intp; ETERM *fnp, *argp; int res; byte buf[100]; long allocated, freed; erl_init(NULL, 0); while (read_cmd(buf) > 0) { tuplep = erl_decode(buf); fnp = erl_element(1, tuplep); argp = erl_element(2, tuplep); if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) { res = foo(ERL_INT_VALUE(argp)); } else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 17) == 0) { res = bar(ERL_INT_VALUE(argp)); } intp = erl_mk_int(res); erl_encode(intp, buf); write_cmd(buf, erl_term_len(intp)); erl_free_compound(tuplep); erl_free_term(fnp); erl_free_term(argp); erl_free_term(intp); } }
ETERM *space_remove_body(ETERM *fromp, ETERM *argp) { // get the args ETERM *space_refp = erl_element(1, argp); ETERM *idp = erl_element(2, argp); erlmunk_space *s; int space_id = ERL_REF_NUMBER(space_refp); HASH_FIND_INT(erlmunk_spaces, &space_id, s); int body_id = ERL_INT_VALUE(idp); erlmunk_body *b = NULL; HASH_FIND_INT(s->bodies, &body_id, b); if (b == NULL) return NULL; // DEBUGF(("removing body #%d\n", body_id)); // remove the user data associated with the body erlmunk_body_data *data = cpBodyGetUserData(b->body); if (data->term != NULL) erl_free_compound(data->term); free(data); cpBodyEachShape(b->body, shapeRemove, NULL); cpSpaceRemoveBody(s->space, b->body); space_remove_body_hash(s, b); cpBodyDestroy(b->body); cpBodyFree(b->body); return NULL; }
void send_result() { fprintf(log, "returning at len %d\n", erl_term_len(result)); respond(result); erl_free_compound(result); result = 0; }
int main() { ETERM *tuplep; ETERM *fnp; ETERM *args; byte buf[100]; const char* func_name; #ifdef __WIN32__ /* Attention Windows programmers: you need [to pay Serge Aleynikov a * beer because he's the one who figured out how to get this to work * on windows :)] explicitly set mode of stdin/stdout to binary or * else the port program won't work. */ _setmode(_fileno(stdout), _O_BINARY); _setmode(_fileno(stdin), _O_BINARY); #endif eNotify_init(); erl_init(NULL, 0); while (read_cmd(buf) > 0) { tuplep = erl_decode(buf); fnp = erl_element(1, tuplep); func_name = (const char*)ERL_ATOM_PTR(fnp); args = erl_element(2, tuplep); // MATCH FIRST! -> REMEMBER THAT! if (strncmp(func_name, "get_error_desc", 14) == 0) { local_get_error_desc(args); } else if (strncmp(func_name, "add_watch", 9) == 0) { local_add_watch(args); } else if (strncmp(func_name, "remove_watch", 12) == 0) { local_remove_watch(args); } else { byte buf[10]; ETERM *nok = erl_mk_atom("undef"); // alloc nok erl_encode(nok, buf); write_cmd(buf, erl_term_len(nok)); erl_free_term(nok); // free nok } erl_free_compound(tuplep); erl_free_term(fnp); } return 0; }
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); }
ETERM *body_update_user_data(ETERM *fromp, ETERM *argp) { // DEBUGF(("body_update_user_data\n")); // get the args ETERM *space_refp = erl_element(1, argp); ETERM *idp = erl_element(2, argp); ETERM *keyp = erl_element(3, argp); ETERM *valuep = erl_element(4, argp); erlmunk_space *s; int space_id = ERL_REF_NUMBER(space_refp); HASH_FIND_INT(erlmunk_spaces, &space_id, s); int body_id = ERL_INT_VALUE(idp); erlmunk_body *b; HASH_FIND_INT(s->bodies, &body_id, b); if (b == NULL) return NULL; erlmunk_body_data *data = cpBodyGetUserData(b->body); ETERM *new_data_term = erl_lists_keyreplace(data->term, keyp, valuep); erl_free_compound(data->term); data->term = new_data_term; ETERM *new_valuep = erl_proplists_get_value(keyp, new_data_term); // obtain updated key value and return that ETERM *atom_ok = erl_mk_atom("ok"); ETERM **body_update_data_array = (ETERM **) malloc(sizeof(ETERM*) * 2); body_update_data_array[0] = atom_ok; body_update_data_array[1] = new_valuep; ETERM *body_update_data_tuple = erl_mk_tuple(body_update_data_array, 2); free(body_update_data_array); ETERM *reply_tuple = erl_mk_reply(fromp, body_update_data_tuple); ETERM *gen_cast_tuple = erl_mk_gen_cast(reply_tuple); return gen_cast_tuple; }
void * handle_command(void *buf){ ETERM *tuplep, *file; ETERM *fnp; tuplep = erl_decode(buf); fnp = erl_element(1, tuplep); char * path = "./priv/sample_images/ABST.00000000.tif"; IplImage *source = cvLoadImage( path, CV_LOAD_IMAGE_GRAYSCALE ); CvMat* pngImage = img(source); //if (strncmp(ERL_ATOM_PTR(fnp), "img", 3) == 0) { // no-op for now? //} file = erl_mk_binary((char *)pngImage->data.ptr, pngImage->cols); erl_encode(file, buf); write_cmd(buf, erl_term_len(file)); erl_free_compound(tuplep); erl_free_term(fnp); erl_free_term(file); }
int main() #endif { _setmode(0, _O_BINARY); _setmode(1, _O_BINARY); erl_init(NULL, 0); for (;;) { char buf[4*1024]; ETERM* term; char* message; int n; if (readn(0, buf, 2) <= 0) { /* fprintf(stderr, "error reading message header\n"); */ /* actually this is where we leave the infinite loop */ exit(1); } n = buf[0] * 256 + buf[1]; if (readn(0, buf, n) < 0) { fprintf(stderr, "error reading message contents\n"); exit(1); } term = erl_decode(buf); if (term == NULL) { fprintf(stderr, "erl_decode() failed\n"); exit(1); } n = erl_print_term(stdout, term); erl_free_compound(term); fprintf(stdout,"\r%d\n", n); fflush(stdout); } }
PyObject *py_erlang_rpc(PyObject * self, PyObject * args) { int fd, timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]; char *emod, *efun; PyObject *eargs, *pyer = NULL; ETERM *pyargs, *rex; ErlMessage emsg; int eret; if (!PyArg_ParseTuple(args, "issO|i:erlang_rpc", &fd, &emod, &efun, &eargs, &timeout)) { return NULL; } if (fd < 0) { goto clear; } pyargs = py_to_eterm(eargs); if (!pyargs) { goto clear; } if (erl_rpc_to(fd, emod, efun, pyargs)) { erl_err_msg("erl_rpc_to()"); goto clear2; } cycle: memset(&emsg, 0, sizeof(ErlMessage)); UWSGI_SET_BLOCKING; eret = erl_rpc_from(fd, timeout * 1000, &emsg); if (eret == ERL_TICK) { goto cycle; } else if (eret == ERL_MSG) { if (emsg.msg) { if (ERL_IS_TUPLE(emsg.msg)) { rex = erl_element(1, emsg.msg); if (!rex) { goto clear2; } if (!strncmp("rex", ERL_ATOM_PTR(rex), ERL_ATOM_SIZE(rex))) { erl_free_term(rex); rex = erl_element(2, emsg.msg); if (!rex) { goto clear2; } pyer = eterm_to_py(rex); erl_free_term(rex); } else { erl_free_term(rex); } } } if (emsg.msg) { erl_free_compound(emsg.msg); } if (emsg.to) { erl_free_compound(emsg.to); } if (emsg.from) { erl_free_compound(emsg.from); } if (!pyer) { goto clear2; } erl_free_compound(pyargs); UWSGI_UNSET_BLOCKING; return pyer; } else { erl_err_msg("erl_rpc_from()"); } clear2: UWSGI_UNSET_BLOCKING; erl_free_compound(pyargs); clear: Py_INCREF(Py_None); return Py_None; }
int main(int argc, char **argv) { ETERM *tuplep; ETERM *fnp, *argp; byte buf[1024]; sqlite3 *db; char *zErrMsg = 0; int rc; log = fopen("/tmp/sqlite_port.log", "a+"); fprintf(log, "******start log (%s)******\n", argv[1]); fflush(log); rc = sqlite3_open(argv[1], &db); if (rc) { sqlite3_close(db); exit(1); } erl_init(NULL, 0); while (read_cmd(buf) > 0) { tuplep = erl_decode(buf); fnp = erl_element(1, tuplep); argp = erl_element(2, tuplep); if (strncmp((const char *)ERL_ATOM_PTR(fnp), "close", 5) == 0) { fprintf(log, "closing sqlite3_close\n"); fflush(log); sqlite3_close(db); break; } else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "list_tables", 11) == 0) { fprintf(log, "calling list_tables\n"); result = 0; rc = sqlite3_exec(db, MASTER_QUERY, list_tables, 0, &zErrMsg); if (rc != SQLITE_OK) { send_error(zErrMsg); sqlite3_free(zErrMsg); } else if (result != 0) { send_result(); } else { // not an error and no results. still need to return something send_ok(); } fflush(log); } else if (strncmp((const char *)ERL_ATOM_PTR(fnp), "sql_exec", 8) == 0) { fprintf(log, "calling sqlite3_exec %s\n", erl_iolist_to_string(argp)); result = 0; rc = sqlite3_exec(db, erl_iolist_to_string(argp), callback, 0, &zErrMsg); if (rc != SQLITE_OK) { send_error(zErrMsg); sqlite3_free(zErrMsg); } else if (result != 0) { send_result(); } else { // not an error and no results. still need to return something send_ok(); } fflush(log); } erl_free_compound(tuplep); erl_free_term(fnp); erl_free_term(argp); } fprintf(log, "******end log******\n"); fclose(log); return 0; }
void erlang_loop(struct wsgi_request *wsgi_req) { ErlConnect econn; ErlMessage em; ETERM *eresponse; PyObject *callable = PyDict_GetItemString(uwsgi.embedded_dict, "erlang_func"); if (!callable) { PyErr_Print(); fprintf(stderr, "- you have not defined a uwsgi.erlang_func callable, Erlang message manager will be disabled until you define it -\n"); } PyObject *pargs = PyTuple_New(1); if (!pargs) { PyErr_Print(); fprintf(stderr, "- error preparing arg tuple for uwsgi.erlang_func callable, Erlang message manager will be disabled -\n"); } while (uwsgi.workers[uwsgi.mywid].manage_next_request) { UWSGI_CLEAR_STATUS; wsgi_req->poll.fd = erl_accept(uwsgi.erlangfd, &econn); if (wsgi_req->poll.fd >= 0) { UWSGI_SET_ERLANGING; for (;;) { if (erl_receive_msg(wsgi_req->poll.fd, (unsigned char *) wsgi_req->buffer, uwsgi.buffer_size, &em) == ERL_MSG) { if (em.type == ERL_TICK) continue; if (!callable) { callable = PyDict_GetItemString(uwsgi.embedded_dict, "erlang_func"); } if (!callable) { fprintf(stderr, "- you still have not defined a uwsgi.erlang_func callable, Erlang message rejected -\n"); } PyObject *zero = eterm_to_py(em.msg); if (em.msg) { erl_free_compound(em.msg); } if (em.to) { erl_free_compound(em.to); } if (!zero) { PyErr_Print(); continue; } if (PyTuple_SetItem(pargs, 0, zero)) { PyErr_Print(); continue; } PyObject *erlang_result = PyEval_CallObject(callable, pargs); //Py_DECREF(zero); if (erlang_result) { eresponse = py_to_eterm(erlang_result); if (eresponse) { erl_send(wsgi_req->poll.fd, em.from, eresponse); erl_free_compound(eresponse); } Py_DECREF(erlang_result); } if (em.from) { erl_free_compound(em.from); } uwsgi.workers[0].requests++; uwsgi.workers[uwsgi.mywid].requests++; if (uwsgi.shared->options[UWSGI_OPTION_LOGGING]) erlang_log(); } else { break; } } erl_close_connection(wsgi_req->poll.fd); UWSGI_UNSET_ERLANGING; } } }
PyObject *py_erlang_send_message(PyObject * self, PyObject * args) { ETERM *pymessage; ETERM *pid; int erfd; PyObject *ermessage, *erdest, *zero; int er_number, er_serial, er_creation; char *er_node; if (!PyArg_ParseTuple(args, "iOO|i:erlang_send_message", &erfd, &erdest, &ermessage)) { return NULL; } if (erfd < 0) { goto clear; } if (!PyString_Check(erdest) && !PyDict_Check(erdest)) { goto clear; } pymessage = py_to_eterm(ermessage); if (!pymessage) { goto clear; } if (PyString_Check(erdest)) { if (!erl_reg_send(erfd, PyString_AsString(erdest), pymessage)) { erl_err_msg("erl_reg_send()"); goto clear2; } } else if (PyDict_Check(erdest)) { zero = PyDict_GetItemString(erdest, "node"); if (!zero) { goto clear2; } if (!PyString_Check(zero)) { goto clear2; } er_node = PyString_AsString(zero); zero = PyDict_GetItemString(erdest, "number"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_number = PyInt_AsLong(zero); zero = PyDict_GetItemString(erdest, "serial"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_serial = PyInt_AsLong(zero); zero = PyDict_GetItemString(erdest, "creation"); if (!zero) { goto clear2; } if (!PyInt_Check(zero)) { goto clear2; } er_creation = PyInt_AsLong(zero); pid = erl_mk_pid((const char *) er_node, er_number, er_serial, er_creation); if (!pid) { goto clear2; } if (!erl_send(erfd, pid, pymessage)) { erl_err_msg("erl_send()"); erl_free_term(pid); goto clear2; } erl_free_term(pid); } else { goto clear; } erl_free_compound(pymessage); Py_INCREF(Py_True); return Py_True; clear2: erl_free_compound(pymessage); clear: PyErr_Print(); Py_INCREF(Py_None); return Py_None; }
int main(int argc, char* argv[]) { ETERM *tuplep, *fnp, *pathp, *binp, *widthp, *heightp; ETERM *res_tuplep; ETERM *res_arrp[2]; ETERM *res_ok_atomp, *res_error_atomp, *res_error_cause_atomp; int idx = 1; byte *buf = malloc(INIT_BUF_SIZE); int buf_len = INIT_BUF_SIZE; int res_len; erl_init(NULL, 0); //Create common atoms(ok, error) res_ok_atomp = erl_mk_atom("ok"); res_error_atomp = erl_mk_atom("error"); res_error_cause_atomp = erl_mk_atom("resize failed"); while (read_cmd(&buf, &buf_len) > 0) { tuplep = erl_decode(buf); fnp = erl_element(idx++, tuplep); pathp = erl_element(idx++, tuplep); binp = erl_element(idx++, tuplep); widthp = erl_element(idx++, tuplep); heightp = erl_element(idx++, tuplep); if (strncmp(ERL_ATOM_PTR(fnp), "resize", 6) == 0) { char* algop = ERL_ATOM_PTR(fnp) + 6; resizerl_handler* rhp = (strncmp(algop, "_opencv", 7) == 0) ? resizerl_impls[0] : NULL; if (rhp == NULL) { exit(1); } // ERL_INT_VALUE, ERL_BIN_PTR, ERL_BIN_SIZE void* dp = NULL; rhp->exec(ERL_BIN_PTR(binp), ERL_BIN_SIZE(binp), ERL_BIN_PTR(pathp), ERL_BIN_SIZE(pathp), ERL_INT_VALUE(widthp), ERL_INT_VALUE(heightp), &dp); if (dp == NULL) { exit(2); } unsigned char* dst; int dst_size; rhp->get_result(dp, &dst, &dst_size); res_arrp[0] = res_ok_atomp; res_arrp[1] = erl_mk_binary((const char*)dst, dst_size); res_tuplep = erl_mk_tuple(res_arrp, 2); res_len = erl_term_len(res_tuplep); if (res_len > buf_len) { byte* new_buf = (byte*)realloc((void*)buf, res_len); if (new_buf == NULL) { exit(3); } buf = new_buf; buf_len = res_len; } erl_encode(res_tuplep, buf); write_cmd(buf, erl_term_len(res_tuplep)); erl_free_term(res_arrp[1]); erl_free_term(res_tuplep); rhp->release(&dp); } else { res_arrp[0] = res_error_atomp; res_arrp[1] = res_error_cause_atomp; res_tuplep = erl_mk_tuple(res_arrp, 2); if (res_len > buf_len) { byte* new_buf = (byte*)realloc((void*)buf, res_len); if (new_buf == NULL) { exit(4); } buf = new_buf; buf_len = res_len; } erl_encode(res_tuplep, buf); write_cmd(buf, erl_term_len(res_tuplep)); erl_free_term(res_tuplep); } erl_free_compound(tuplep); erl_free_term(fnp); erl_free_term(pathp); erl_free_term(binp); erl_free_term(widthp); erl_free_term(heightp); idx = 1; } // normal return 0; }
void watcher(void* data) { TRACE(("watcher thread started!")); info_t* threadinfo = (info_t*)data; int triggerfd, cnt, ret; char attrdata[1024]; struct pollfd ufd; if (!ERL_IS_PID(threadinfo->topid)) { fprintf(stderr, "PID is not a pid. wat."); pthread_exit(NULL); } TRACE(("watcher thread got fname(%d): %s", strlen(threadinfo->fname), threadinfo->fname)); //TRACE(("watcher got PID <.%d.%d> and fd %d", // ERL_PID_NUMBER(&threadinfo->topid), // ERL_PID_SERIAL(&threadinfo->topid), // threadinfo->erlvm_fd)); fprintf(stderr, "watcher got PID "); erl_print_term(stderr, threadinfo->topid); fprintf(stderr, "\n"); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to open file %s", threadinfo->fname)); perror("unable to open file"); goto end_watcher; } ufd.events = POLLPRI | POLLERR; // dummy read cnt = read(ufd.fd, attrdata, 1023); TRACE(("dummy read got value %d", cnt)); TRACE(("starting up main watcher loop")); while ((ret = poll(&ufd, 1, 10000)) >= 0) { TRACE(("began watcher loop")); if (ret == 0) { TRACE(("watcher thread poll() timed out, continuing.")); continue; } if (ufd.revents & (POLLPRI|POLLERR)) { TRACE(("watcher caught an event!")); close(ufd.fd); if ((ufd.fd = open(threadinfo->fname, O_RDONLY)) < 0) { TRACE(("unable to re-open file %s", threadinfo->fname)); perror("unable to re-open file"); break; } cnt = read(ufd.fd, attrdata, 1023); attrdata[cnt] = '\0'; TRACE(("watcher got %d bytes: %s", cnt, attrdata)); ETERM* notification = erl_format("{data, ~s}", attrdata); int sendret = erl_send(threadinfo->erlvm_fd, threadinfo->topid, notification); if (!sendret) { switch(erl_errno) { case(EINVAL): fprintf(stderr, "unable to send notification: bad PID\n"); break; case(ENOMEM): fprintf(stderr, "unable to send notification: no memory\n"); break; case(EIO): fprintf(stderr, "unable to send notification: I/O error\n"); break; default: fprintf(stderr, "unable to send notification: unspecified error\n"); break; } } else { TRACE(("sent notification")); } free(notification); } else { printf("watcher got something weird! revents = %d\n", ufd.revents); } ufd.revents = 0; TRACE(("finishing watcher loop")); } end_watcher: erl_free_compound(threadinfo->topid); free(threadinfo->fname); pthread_t* dying = threadinfo->self; free(threadinfo); free(dying); TRACE(("watcher thread exiting")); pthread_exit(NULL); }
int main(int argc, char **argv) { libusb_context *ctx = NULL; dongleHandle dongle; int option; int address; int bus; ETERM *tuplep; ETERM *functionp; unsigned char buf[1024]; const char* func_name; address = -1; bus = -1; while ((option = getopt(argc, argv, "p:b:")) != -1) { switch (option) { case 'p': address = atoi(optarg); break; case 'b': bus = atoi(optarg); break; default: return 1; } } if (bus == -1 || address == -1) { return 1; } erl_init(NULL, 0); initDongle(ctx); dongle = getDongle(ctx, address, bus); if (dongle == NULL) { ERL_WRITE_ERROR("not_found"); exitDongle(ctx); return 1; } while (read_cmd(buf) > 0) { tuplep = erl_decode(buf); functionp = erl_element(1, tuplep); func_name = (const char*)ERL_ATOM_PTR(functionp); if (strncmp(func_name, "derive", 6) == 0){ hsm_derive(dongle, tuplep); } else if (strncmp(func_name, "import", 6) == 0){ hsm_import(dongle, tuplep); } else if (strncmp(func_name, "pin", 3) == 0){ hsm_pin(dongle, tuplep); } else if (strncmp(func_name, "pubkey", 6) == 0){ hsm_pubkey(dongle, tuplep); } else if (strncmp(func_name, "random", 6) == 0){ hsm_random(dongle, tuplep); } else if (strncmp(func_name, "sign", 4) == 0){ hsm_sign(dongle, tuplep); } else if (strncmp(func_name, "verify", 6) == 0){ hsm_verify(dongle, tuplep); } else if (strncmp(func_name, "close", 5) == 0){ break; } else { ERL_WRITE_ERROR("undef") } erl_free_compound(tuplep); erl_free_term(functionp); } closeDongle(dongle); exitDongle(ctx); ETERM *atom; atom = erl_mk_atom("closed"); unsigned char closed_buf[erl_term_len(atom)]; erl_encode(atom, closed_buf); write_cmd(closed_buf, erl_term_len(atom)); erl_free_term(atom); fprintf(stderr, "CLOSED"); return 0; }
PyObject *py_erlang_recv_message(PyObject * self, PyObject * args) { int erfd; struct pollfd erpoll; ErlMessage emsg; PyObject *pyer = NULL; unsigned char erlang_buffer[8192]; int eret; int timeout = uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]; if (!PyArg_ParseTuple(args, "i|i:erlang_recv_message", &erfd, &timeout)) { return NULL; } if (erfd < 0) { goto clear; } erpoll.fd = erfd; erpoll.events = POLLIN; cycle: memset(&emsg, 0, sizeof(ErlMessage)); UWSGI_SET_BLOCKING; if (timeout > 0) { eret = poll(&erpoll, 1, timeout * 1000); if (eret < 0) { uwsgi_error("poll()"); goto clear; } else if (eret == 0) { goto clear; } } if (erl_receive_msg(erfd, erlang_buffer, 8192, &emsg) == ERL_MSG) { if (emsg.type == ERL_TICK) { goto cycle; } if (emsg.msg) { pyer = eterm_to_py(emsg.msg); } if (emsg.msg) { erl_free_compound(emsg.msg); } if (emsg.to) { erl_free_compound(emsg.to); } if (emsg.from) { erl_free_compound(emsg.from); } if (!pyer) { goto clear; } UWSGI_UNSET_BLOCKING; return pyer; } clear: UWSGI_UNSET_BLOCKING; Py_INCREF(Py_None); return Py_None; }
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; }