static EEL_xno n2_tcp_read(EEL_vm *vm)
{
EEL_value *args = vm->heap + vm->argv;
EB_socket *ebs;
EEL_object *so;
int count;
char buf[258];
if(EEL_TYPE(args) != md.net2_socket_cid)
return EEL_XWRONGTYPE;
ebs = o2EB_socket(args->objref.v);
if(!ebs->rs)
return EEL_XDEVICECLOSED;
count = NET2_TCPRead(ebs->rs->n2socket, buf, sizeof(buf) - 1);
if(!count)
{
eel_nil2v(vm->heap + vm->resv);
return 0;
}
buf[count] = 0;
so = eel_ds_nnew(vm, buf, count);
if(!so)
return EEL_XMEMORY;
eel_o2v(vm->heap + vm->resv, so);
return 0;
}
static EEL_xno m_construct(EEL_vm *vm, EEL_classes cid,
EEL_value *initv, int initc, EEL_value *result)
{
EEL_xno x;
EEL_value v;
EEL_module *m;
EEL_object *eo;
eel_clean_modules(vm);
eo = eel_o_alloc(vm, sizeof(EEL_module), cid);
if(!eo)
return EEL_XMEMORY;
m = o2EEL_module(eo);
memset(m, 0, sizeof(EEL_module));
m->id = VMP->state->module_id_counter++;
x = eel_o_construct(vm, EEL_CTABLE, NULL, 0, &v);
if(x)
{
eel_o_free(eo);
return x;
}
m->exports = v.objref.v;
eel_o2v(result, eo);
return 0;
}
static EEL_xno eb_version(EEL_vm *vm)
{
EEL_object *a;
EEL_value v;
EEL_xno x = eel_o_construct(vm, EEL_CARRAY, NULL, 0, &v);
if(x)
return x;
a = v.objref.v;
eel_l2v(&v, EEL_MAJOR_VERSION);
x = eel_setlindex(a, 0, &v);
if(!x)
{
eel_l2v(&v, EEL_MINOR_VERSION);
x = eel_setlindex(a, 1, &v);
if(!x)
{
eel_l2v(&v, EEL_MICRO_VERSION);
x = eel_setlindex(a, 2, &v);
}
}
if(x)
{
eel_disown(a);
return x;
}
eel_o2v(vm->heap + vm->resv, a);
return 0;
}
/*----------------------------------------------------------
IPaddress class
----------------------------------------------------------*/
static EEL_xno ipa_construct(EEL_vm *vm, EEL_types type,
EEL_value *initv, int initc, EEL_value *result)
{
IPaddress *ipa;
EEL_object *eo = eel_o_alloc(vm, sizeof(IPaddress), type);
if(!eo)
return EEL_XMEMORY;
ipa = o2IPaddress(eo);
switch(initc)
{
case 0:
ipa->host = INADDR_NONE;
ipa->port = 9999;
break;
case 1:
if(EEL_TYPE(initv) == md.ipaddress_cid)
{
IPaddress *src = o2IPaddress(initv->objref.v);
memcpy(ipa, src, sizeof(IPaddress));
}
else
{
/* Create server socket */
if(SDLNet_ResolveHost(ipa, NULL, eel_v2l(initv)) != 0)
{
eel_o_free(eo);
return EEL_XDEVICEOPEN;
}
}
break;
case 2:
{
const char *s;
switch((EEL_classes)EEL_TYPE(initv))
{
case EEL_CSTRING:
case EEL_CDSTRING:
s = eel_v2s(initv);
default:
s = NULL;
}
/* Connect as client */
if(SDLNet_ResolveHost(ipa, s, eel_v2l(initv + 1)) != 0)
{
eel_o_free(eo);
return EEL_XDEVICEOPEN;
}
break;
}
default:
eel_o_free(eo);
return EEL_XARGUMENTS;
}
eel_o2v(result, eo);
return 0;
}
static EEL_xno ipa_clone(EEL_vm *vm,
const EEL_value *src, EEL_value *dst, EEL_types t)
{
EEL_object *co = eel_o_alloc(vm, sizeof(IPaddress), t);
if(!co)
return EEL_XMEMORY;
memcpy(o2IPaddress(co), o2IPaddress(src->objref.v), sizeof(IPaddress));
eel_o2v(dst, co);
return 0;
}
static EEL_xno n2s_construct(EEL_vm *vm, EEL_types type,
EEL_value *initv, int initc, EEL_value *result)
{
REAL_EB_socket *rs;
EB_socket *ebs;
EEL_object *eo;
rs = malloc(sizeof(REAL_EB_socket));
if(!rs)
return EEL_XMEMORY;
eo = eel_o_alloc(vm, sizeof(EB_socket), type);
if(!eo)
{
free(rs);
return EEL_XMEMORY;
}
ebs = o2EB_socket(eo);
ebs->rs = rs;
rs->pollperiod = 50;
rs->sender = NULL;
rs->fifo.buffer = NULL;
rs->closed = 0;
rs->status = EEL_XOK;
switch(initc)
{
case 1:
if(initv->type == EEL_TINTEGER)
{
rs->n2socket = eel_v2l(initv);
if(rs->n2socket > NET2_MAX_SOCKETS)
{
eel_o_free(eo);
return EEL_XHIGHINDEX;
}
}
else
{
IPaddress *ipa;
if(EEL_TYPE(initv) != md.ipaddress_cid)
{
eel_o_free(eo);
return EEL_XWRONGTYPE;
}
ipa = o2IPaddress(initv->objref.v);
rs->n2socket = NET2_TCPConnectToIP(ipa);
if(rs->n2socket < 0)
{
eel_o_free(eo);
return EEL_XDEVICEOPEN;
}
}
break;
case 2:
rs->n2socket = NET2_TCPConnectTo(eel_v2s(initv),
eel_v2l(initv + 1));
if(rs->n2socket < 0)
{
eel_o_free(eo);
return EEL_XDEVICEOPEN;
}
break;
default:
eel_o_free(eo);
return EEL_XARGUMENTS;
}
if(eb_sockets && (rs->n2socket >= 0))
eb_sockets[rs->n2socket] = eo;
eel_o2v(result, eo);
return 0;
}
