response_t queue_list(q_data_t **q_data) {
int temp = 0, i;
response_t r;
ETERM **list;
for(i = 0; i < MAX_Q_NUMS; i++)
if(q_data[i]->q_num >=0) temp++;
r.cs = erl_mk_atom("ok");
if(temp > 0 && (list = calloc(temp, sizeof(ETERM *))) != NULL) {
temp = 0;
for(i = 0; i < MAX_Q_NUMS; i++) {
if(q_data[i]->q_num >= 0 ) {
list[temp] = erl_mk_int(q_data[i]->q_num);
temp++;
}
}
r.rsp = erl_mk_list(list, temp);
for(i = 0; i < temp; i++)
erl_free_term(list[i]);
free(list);
} else {
r.rsp = erl_mk_empty_list();
}
return r;
}
static VALUE erlix_list_init(VALUE self,VALUE ary){
ErlixTerm *list;
ETERM **les;
VALUE e;
ErlixTerm *ep;
int i;
Data_Get_Struct(self,ErlixTerm,list);
if(NIL_P(ary)){
//empty list
list->term=erl_mk_empty_list();
return self;
}
if(TYPE(ary)==T_ARRAY){
if(RARRAY_LEN(ary)==0){
//empty list
list->term=erl_mk_empty_list();
}else{
//check: all elements' must be ErlixTerm or auto-convertable Type
for(i=0;i<RARRAY_LEN(ary);i++){
e=RARRAY_PTR(ary)[i];
if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
}
}
les=(ETERM**)malloc(sizeof(ETERM*)*(RARRAY_LEN(ary)));
for(i=0;i<RARRAY_LEN(ary);i++){
e=RARRAY_PTR(ary)[i];
if(IS_ETERM(e)){
Data_Get_Struct(e,ErlixTerm,ep);
*(les+i)=erl_copy_term(ep->term);
}else{
*(les+i)=erlix_auto_conv(e);
}
}
list->term=erl_mk_list(les,RARRAY_LEN(ary));
//for(i=0;i<RARRAY(ary)->len;i++){
// erl_free_term(*(les+i));
//}
free(les);
}
}else if(TYPE(ary)==T_STRING){
list->term=erl_mk_estring(RSTRING_PTR(ary), RSTRING_LEN(ary));
}
return self;
}
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;
}
ETERM *
make_rows(my_ulonglong count)
{
ETERM **rows, *rc;
unsigned int i;
rows = (ETERM **)safe_malloc(numrows * sizeof(ETERM *));
for (i = 0; i < count; i++) {
ETERM *rt;
switch (mysql_stmt_fetch(sth)) {
case 0:
rt = make_row();
rows[i] = erl_format("~w", rt);
erl_free_term(rt);
break;
case MYSQL_NO_DATA:
rt = erl_format("{error, {mysql_error, no_data}}");
write_msg(rt);
erl_free_term(rt);
exit(3);
case MYSQL_DATA_TRUNCATED:
rt = erl_format("{error, {mysql_error, data_truncated}}");
write_msg(rt);
erl_free_term(rt);
exit(3);
default:
rt = erl_format("{error, {mysql_error, ~i, ~s}}",
mysql_stmt_errno(sth), mysql_stmt_error(sth));
write_msg(rt);
erl_free_term(rt);
exit(3);
}
}
rc = erl_mk_list(rows, count);
for (i = 0; i < count; i++)
erl_free_term(rows[i]);
free(rows);
return rc;
}
static VALUE erlix_list_init2(int argc, VALUE* argv,VALUE self){
ErlixTerm *list;
ETERM **les;
VALUE e;
ErlixTerm *ep;
int i;
Data_Get_Struct(self,ErlixTerm,list);
if(argc==0){
//empty list
list->term=erl_mk_empty_list();
return self;
}
if(argc==1 && (ARRAY_P(*argv)||STRING_P(*argv))){
return erlix_list_init(self, *argv);
}
//check: all elements' must be ErlixTerm or auto-convertable Type
for(i=0;i<argc;i++){
e=*(argv+i);
if(!IS_ETERM(e) && !CAN_AUTO_CONV(e)){
rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
}
}
les=(ETERM**)malloc(sizeof(ETERM*)*argc);
for(i=0;i<argc;i++){
e=*(argv+i);
if(IS_ETERM(e)){
Data_Get_Struct(e,ErlixTerm,ep);
*(les+i)=erl_copy_term(ep->term);
}else{
*(les+i)=erlix_auto_conv(e);
}
}
list->term=erl_mk_list(les,argc);
//for(i=0;i<RARRAY(ary)->len;i++){
// erl_free_term(*(les+i));
//}
free(les);
return self;
}
static VALUE erlix_list_create(int argc,VALUE *argv,VALUE klass){
ETERM *rterm;
ETERM **les;
ErlixTerm *ep;
VALUE e;
int i;
if(argc==0){
//empty list
rterm=erl_mk_empty_list();
}else{
//check: all elements' must be ErlixTerm or auto-convertable Type
for(i=0;i<argc;i++){
e=argv[i];
if(!IS_ETERM(e) && !CAN_AUTO_CONV(argv[i])){
rb_raise(rb_eTypeError,"all list's elements must be ErlixTerm or Auto-Convertable-Type!");
}
}
les=(ETERM**)malloc(sizeof(ETERM*)*argc);
for(i=0;i<argc;i++){
e=argv[i];
if(IS_ETERM(e)){
Data_Get_Struct(e,ErlixTerm,ep);
*(les+i)=erl_copy_term(ep->term);
}else{
*(les+i)=erlix_auto_conv(e);
}
}
rterm=erl_mk_list(les,argc);
//for(i=0;i<argc;i++){
// erl_free_term(*(les+i));
//}
free(les);
}
return erlix_term(rterm);
}
t_array[0] = erl_mk_float(vect.x);
t_array[1] = erl_mk_float(vect.y);
t_array[2] = erl_mk_float(angle);
if (data->term == NULL)
t_array[3] = erl_mk_undefined();
else
t_array[3] = erl_copy_term(data->term);
ETERM *tuple = erl_mk_tuple(t_array, 4);
free(t_array);
ETERM *prop_value = erl_mk_int_prop_value(data->id, tuple);
l_array[nth_body++] = prop_value;
}
ETERM *a = erl_mk_atom("erlmunk_update");
ETERM *l = erl_mk_list(l_array, count);
free(l_array);
ETERM **data_array = (ETERM **) malloc(sizeof(ETERM) * 2);
data_array[0] = a;
data_array[1] = l;
ETERM *data = erl_mk_tuple(data_array, 2);
free(data_array);
ETERM *gen_cast = erl_mk_gen_cast(data);
if (erl_send(subscriber->client->fd, subscriber->from, gen_cast) != 1) {
DEBUGF(("failed to send data to subscriber"));
}
erl_free_compound(gen_cast);
}
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;
}
/**
* Read an integer giving the maximum size of a fragment.
*/
int main( int argc, char *argv[] ) {
int fail = 0;
erl_init(NULL,0);
#ifdef _DEBUG
openlog( "erlang-port", 0, LOG_USER );
syslog( LOG_INFO, "%s is alive\n", argv[0] );
#endif
while( ! fail ) {
ETERM *fragsize_term = NULL;
byte buf[100 /*WIRE_SIZEOF_INT*/];
if( read_lpm( buf, sizeof(buf) ) <= 0 ) {
#ifdef _DEBUG
syslog( LOG_ERR, "failed reading fragment size:\n" );
#endif
break;
}
fragsize_term = erl_decode( buf );
if( fragsize_term ) {
ETERM **array;
unsigned int count;
unsigned int SIZEOF_FRAGMENT
= ERL_INT_UVALUE(fragsize_term);
erl_free_term( fragsize_term );
if( SIZEOF_FRAGMENT == 0 /* the explicit signal to shutdown */ )
break;
#ifdef _DEBUG
syslog( LOG_INFO, "received sizeof fragment: %d\n", SIZEOF_FRAGMENT );
#endif
count = min_packet_count( SIZEOF_IMAGE, SIZEOF_FRAGMENT );
array = calloc( count, sizeof(ETERM*) );
if( array ) {
ETERM *frags;
for(int i = 0; i < count; i++ ) {
const size_t S
= i+1 < count
? SIZEOF_FRAGMENT
: (SIZEOF_IMAGE % SIZEOF_FRAGMENT);
array[i] = erl_mk_binary(
TEST_IMAGE + i*SIZEOF_FRAGMENT, S );
if( array[i] == NULL ) {
count = i; // ...for erl_free_array below.
fail = 1;
break;
}
}
if( fail )
goto cleanup;
frags = erl_mk_list( array, count );
if( frags ) {
const int nbyte = erl_term_len( frags );
byte *buf = calloc( nbyte, sizeof(byte) );
if( buf ) {
if( erl_encode( frags, buf ) == nbyte ) {
if( write_lpm( buf, nbyte ) != nbyte )
fail = 1;
} else
fail = 1;
free( buf );
} else
fail = 1;
} else
fail = 1;
cleanup:
erl_free_array( array, count );
free( array );
}
} else
break;
}
#ifdef _DEBUG
closelog();
#endif
return 0;
}
