long socket_udpsend(int id, const struct socket_udp_address *address, const void *data, int size) {
const uint8_t *udp_address;
int addrsize;
struct socket_req req;
struct socket * sock = &S.slot[HASH_ID(id)];
if (sock->id != id || sock->type == SOCKET_TYPE_INVALID) {
freebuffer((void *)data, size);
return -1;
}
memset(&req, 0, sizeof req);
req.req = SOCKET_REQ_SENDUDP;
req.u.send.id = id;
req.u.send.data = (char *)data;
req.u.send.size = size;
udp_address = (const uint8_t *)address;
switch (udp_address[0]) {
case PROTOCOL_UDP:
addrsize = 1 + 2 + 4;
break;
case PROTOCOL_UDPv6:
addrsize = 1 + 2 + 16;
break;
default:
freebuffer((void *)data, size);
return -1;
}
memcpy(req.u.sendudp.address, udp_address, addrsize);
socket_send_req(&req);
return sock->wb_size;
}
long socket_send(int id, const void *data, int size, int priority) {
struct socket_req req;
struct socket * sock = &S.slot[HASH_ID(id)];
if (sock->id != id || sock->type == SOCKET_TYPE_INVALID) {
freebuffer((void *)data, size);
return -1;
}
memset(&req, 0, sizeof req);
req.req = SOCKET_REQ_SEND;
req.u.send.id = id;
req.u.send.data = (char *)data;
req.u.send.size = size;
req.u.send.priority = priority;
socket_send_req(&req);
return sock->wb_size;
}
charset *parsecharset(const char *str, errmsg_t errmsg)
{
charset *cset = NULL;
buffer *cbuf = NULL;
const wchar_t *p, * const singleescapes = L"_sbqQx";
int hex1, hex2;
wchar_t ch;
wchar_t *wstr;
wstr = (wchar_t *) malloc((strlen(str) + 1) * sizeof(wchar_t));
if (!wstr) {
wcscpy(errmsg,outofmem);
goto pcserror;
}
if ((size_t)(-1) == mbstowcs(wstr, str, strlen(str) + 1)) {
wcscpy(errmsg,mbserror);
goto pcserror;
}
cset = malloc(sizeof (charset));
if (!cset) {
wcscpy(errmsg,outofmem);
goto pcserror;
}
cset->inlist = cset->outlist = NULL;
cset->flags = 0;
cbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto pcserror;
for (p = wstr; *p; ++p)
if (*p == L'_') {
++p;
if (appearsin(*p, singleescapes)) {
if (*p == L'_') ch = L'_' ;
else if (*p == L's') ch = L' ' ;
else if (*p == L'b') ch = L'\\';
else if (*p == L'q') ch = L'\'';
else if (*p == L'Q') ch = L'\"';
else /* *p == 'x' */ {
/* FIXME _x metacharacter should allow wide characters input.*/
hex1 = hexdigtoint(p[1]);
hex2 = hexdigtoint(p[2]);
if (hex1 < 0 || hex2 < 0) goto pcsbadstr;
ch = 16 * hex1 + hex2;
p += 2;
}
if (!ch)
cset->flags |= CS_NUL;
else {
additem(cbuf, &ch, errmsg);
if (*errmsg) goto pcserror;
}
}
else {
if (*p == L'A') cset->flags |= CS_UCASE;
else if (*p == L'a') cset->flags |= CS_LCASE;
else if (*p == L'0') cset->flags |= CS_DIGIT;
else goto pcsbadstr;
}
}
else {
additem(cbuf, p,errmsg);
if (*errmsg) goto pcserror;
}
ch = '\0';
additem(cbuf, &ch, errmsg);
if (*errmsg) goto pcserror;
cset->inlist = copyitems(cbuf,errmsg);
if (*errmsg) goto pcserror;
pcscleanup:
if (cbuf) freebuffer(cbuf);
if (wstr) free(wstr);
return cset;
pcsbadstr:
swprintf(errmsg, errmsg_size, L"Bad charset syntax: %.*s\n", errmsg_size - 22, str);
pcserror:
if (cset) freecharset(cset);
cset = NULL;
goto pcscleanup;
}
static charset *csud(
int u, const charset *cset1, const charset *cset2, errmsg_t errmsg
)
/* Returns the union of cset1 and cset2 if u is 1, or the set */
/* difference cset1 - cset2 if u is 0. Returns NULL on failure. */
{
charset *csu;
buffer *inbuf = NULL, *outbuf = NULL;
wchar_t *lists[4], **list, *p, nullchar = L'\0';
csu = malloc(sizeof (charset));
if (!csu) {
wcscpy(errmsg,outofmem);
goto csuderror;
}
inbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto csuderror;
outbuf = newbuffer(sizeof (wchar_t), errmsg);
if (*errmsg) goto csuderror;
csu->inlist = csu->outlist = NULL;
csu->flags = u ? cset1->flags | cset2->flags
: cset1->flags & ~cset2->flags;
lists[0] = cset1->inlist;
lists[1] = cset1->outlist;
lists[2] = cset2->inlist;
lists[3] = cset2->outlist;
for (list = lists; list < lists + 4; ++list)
if (*list) {
for (p = *list; *p; ++p)
if (u ? csmember(*p, cset1) || csmember(*p, cset2)
: csmember(*p, cset1) && !csmember(*p, cset2)) {
if (!csmember(*p, csu)) {
additem(inbuf,p,errmsg);
if (*errmsg) goto csuderror;
}
}
else
if (csmember(*p, csu)) {
additem(outbuf,p,errmsg);
if (*errmsg) goto csuderror;
}
}
additem(inbuf, &nullchar, errmsg);
if (*errmsg) goto csuderror;
additem(outbuf, &nullchar, errmsg);
if (*errmsg) goto csuderror;
csu->inlist = copyitems(inbuf,errmsg);
if (*errmsg) goto csuderror;
csu->outlist = copyitems(outbuf,errmsg);
if (*errmsg) goto csuderror;
csudcleanup:
if (inbuf) freebuffer(inbuf);
if (outbuf) freebuffer(outbuf);
return csu;
csuderror:
if (csu) freecharset(csu);
csu = NULL;
goto csudcleanup;
}
// create a cube model that looks like a wavefront model,
MODEL_T cube_wavefront()
{
static const float qv[] = {
-0.5f, -0.5f, 0.5f,
-0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, -0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
0.5f, 0.5f, -0.5f,
-0.5f, 0.5f, -0.5f,
};
static const float qn[] = {
0.0f, -1.0f, -0.0f,
0.0f, 1.0f, -0.0f,
0.0f, 0.0f, 1.0f,
1.0f, 0.0f, -0.0f,
0.0f, 0.0f, -1.0f,
-1.0f, 0.0f, -0.0f,
};
static const float qt[] = {
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f,
0.0f, 0.0f,
};
static const unsigned short qf[] = {
1,1,1, 2,2,1, 3,3,1,
3,3,1, 4,4,1, 1,1,1,
5,4,2, 6,1,2, 7,2,2,
7,2,2, 8,3,2, 5,4,2,
1,4,3, 4,1,3, 6,2,3,
6,2,3, 5,3,3, 1,4,3,
4,4,4, 3,1,4, 7,2,4,
7,2,4, 6,3,4, 4,4,4,
3,4,5, 2,1,5, 8,2,5,
8,2,5, 7,3,5, 3,4,5,
2,4,6, 1,1,6, 5,2,6,
5,2,6, 8,3,6, 2,4,6,
};
WAVEFRONT_MODEL_T *model = malloc(sizeof *model);
if (model) {
WAVEFRONT_MATERIAL_T *mat = model->material;
float *temp;
const int offset = 0;
memset(model, 0, sizeof *model);
temp = allocbuffer(3*MAX_VERTICES*sizeof *temp);
//mat->numverts = countof(qf)/3;
mat->numverts = sizeof(qf)/sizeof(short)/3;
// vertex, texture, normal
deindex(temp, qv, qf+3*offset+0, 3, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_VERTEX, 3 * mat->numverts * sizeof *qv, temp); // 3
deindex(temp, qt, qf+3*offset+1, 2, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_TEXTURE, 2 * mat->numverts * sizeof *qt, temp); // 2
deindex(temp, qn, qf+3*offset+2, 3, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_NORMAL, 3 * mat->numverts * sizeof *qn, temp); // 3
freebuffer(temp);
model->num_materials = 1;
}
return (MODEL_T)model;
}
MODEL_T load_wavefront(const char *modelname, const char *texturename)
{
WAVEFRONT_MODEL_T *model;
float *temp, *qv, *qt, *qn;
unsigned short *qf;
int i;
int numverts = 0, offset = 0;
struct wavefront_model_loading_s *m;
int s=-1;
char modelname_obj[128];
model = malloc(sizeof *model);
if (!model || !modelname) return NULL;
memset (model, 0, sizeof *model);
model->texture = 0; //load_texture(texturename);
m = allocbuffer(sizeof *m +
sizeof(float)*(3+2+3)*MAX_VERTICES + // 3 vertices + 2 textures + 3 normals
sizeof(unsigned short)*3*MAX_VERTICES); //each face has 9 vertices
if (!m) return 0;
if (strlen(modelname) + 5 <= sizeof modelname_obj) {
strcpy(modelname_obj, modelname);
strcat(modelname_obj, ".dat");
s = load_wavefront_dat(modelname_obj, model, m);
}
if (s==0) {}
else if (strncmp(modelname + strlen(modelname) - 4, ".obj", 4) == 0) {
#ifdef DUMP_OBJ_DAT
int size;
FILE *fp;
#endif
s = load_wavefront_obj(modelname, model, m);
#ifdef DUMP_OBJ_DAT
strcpy(modelname_obj, modelname);
strcat(modelname_obj, ".dat");
size = sizeof *m +
sizeof(float)*(3*m->numv+2*m->numt+3*m->numn) + // 3 vertices + 2 textures + 3 normals
sizeof(unsigned short)*3*m->numf; //each face has 9 vertices
fp = host_file_open(modelname_obj, "w");
fwrite(m, 1, size, fp);
fclose(fp);
#endif
} else if (strncmp(modelname + strlen(modelname) - 4, ".dat", 4) == 0) {
s = load_wavefront_dat(modelname, model, m);
}
if (s != 0) return 0;
qv = (float *)(m->data);
qt = (float *)(m->data + m->numv);
qn = (float *)(m->data + m->numv + m->numt);
qf = (unsigned short *)(m->data + m->numv + m->numt + m->numn);
numverts = m->numf/3;
vc_assert(numverts <= MAX_VERTICES);
temp = allocbuffer(3*numverts*sizeof *temp);
for (i=0; i<m->num_materials; i++) {
WAVEFRONT_MATERIAL_T *mat = model->material + i;
mat->numverts = i < m->num_materials-1 ? m->material_index[i+1]-m->material_index[i] : numverts - m->material_index[i];
// vertex, texture, normal
deindex(temp, qv, qf+3*offset+0, 3, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_VERTEX, 3 * mat->numverts * sizeof *qv, temp); // 3
deindex(temp, qt, qf+3*offset+1, 2, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_TEXTURE, 2 * mat->numverts * sizeof *qt, temp); // 2
deindex(temp, qn, qf+3*offset+2, 3, mat->numverts);
create_vbo(GL_ARRAY_BUFFER, mat->vbo+VBO_NORMAL, 3 * mat->numverts * sizeof *qn, temp); // 3
offset += mat->numverts;
mat->texture = model->texture;
}
model->num_materials = m->num_materials;
vc_assert(offset == numverts);
freebuffer(temp);
freebuffer(m);
return (MODEL_T)model;
}
/* snarfheredoc -- read a heredoc until the eof marker */
extern Tree *snarfheredoc(const char *eof, Boolean quoted) {
Tree *tree, **tailp;
Buffer *buf;
unsigned char *s;
assert(quoted || strchr(eof, '$') == NULL); /* can never be typed (whew!) */
if (strchr(eof, '\n') != NULL) {
yyerror("here document eof-marker contains a newline");
return NULL;
}
disablehistory = TRUE;
for (tree = NULL, tailp = &tree, buf = openbuffer(0);;) {
int c;
print_prompt2();
for (s = (unsigned char *) eof; (c = GETC()) == *s; s++)
;
if (*s == '\0' && (c == '\n' || c == EOF)) {
if (buf->current == 0 && tree != NULL)
freebuffer(buf);
else
*tailp = treecons(mk(nQword, sealcountedbuffer(buf)), NULL);
break;
}
if (s != (unsigned char *) eof)
buf = bufncat(buf, eof, s - (unsigned char *) eof);
for (;; c = GETC()) {
if (c == EOF) {
yyerror("incomplete here document");
freebuffer(buf);
disablehistory = FALSE;
return NULL;
}
if (c == '$' && !quoted && (c = GETC()) != '$') {
Tree *var;
UNGETC(c);
if (buf->current == 0)
freebuffer(buf);
else {
*tailp = treecons(mk(nQword, sealcountedbuffer(buf)), NULL);
tailp = &(*tailp)->CDR;
}
var = getherevar();
if (var == NULL) {
freebuffer(buf);
disablehistory = FALSE;
return NULL;
}
*tailp = treecons(var, NULL);
tailp = &(*tailp)->CDR;
buf = openbuffer(0);
continue;
}
buf = bufputc(buf, c);
if (c == '\n')
break;
}
}
disablehistory = FALSE;
return tree->CDR == NULL ? tree->CAR : tree;
}
