static void
set_arrays (const shaderparam_t *vert, const shaderparam_t *norm,
const shaderparam_t *st, aliasvrt_t *pose)
{
byte *pose_offs = (byte *) pose;
if (developer->int_val & SYS_GLSL) {
GLint size;
qfeglGetBufferParameteriv (GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &size);
if (size <= (intptr_t)pose_offs) {
Sys_Printf ("Invalid pose");
pose = 0;
}
}
qfeglVertexAttribPointer (vert->location, 3, GL_UNSIGNED_SHORT,
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, vertex));
qfeglVertexAttribPointer (norm->location, 3, GL_SHORT,
1, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, normal));
qfeglVertexAttribPointer (st->location, 2, GL_SHORT,
0, sizeof (aliasvrt_t),
pose_offs + field_offset (aliasvrt_t, st));
}
tex_t *
sw32_SCR_CaptureBGR (void)
{
int count, x, y;
tex_t *tex;
const byte *src;
byte *dst;
count = vid.width * vid.height;
tex = malloc (field_offset (tex_t, data[count * 3]));
SYS_CHECKMEM (tex);
tex->width = vid.width;
tex->height = vid.height;
tex->format = tex_rgb;
tex->palette = 0;
sw32_D_EnableBackBufferAccess ();
src = vid.buffer;
for (y = 0; y < tex->height; y++) {
dst = tex->data + (tex->height - 1 - y) * tex->width * 3;
for (x = 0; x < tex->width; x++) {
*dst++ = vid.basepal[*src * 3 + 2]; // blue
*dst++ = vid.basepal[*src * 3 + 1]; // green
*dst++ = vid.basepal[*src * 3 + 0]; // red
src++;
}
}
sw32_D_DisableBackBufferAccess ();
return tex;
}
int prepare_response(Socket_t *sock, uint8_t *frame, uint8_t *data, int length)
{
IPV4TX_header_t *txhdr = (IPV4TX_header_t *)frame;
char *ptr = (char *)data;
int len = length;
printf("Response: ");
while (--len >= 0 && *ptr != '\r')
putchar(*ptr++);
putchar('\n');
txhdr->apiid = ID_IPV4TX;
txhdr->frameid = ++txframeid;
memcpy(&txhdr->dstaddr, &sock->id.srcaddr, 4);
memcpy(&txhdr->dstport, &sock->id.srcport, 2);
memcpy(&txhdr->srcport, &sock->id.dstport, 2);
txhdr->protocol = sock->protocol;
//txhdr->options = 0x00; // don't terminate after send
txhdr->options = 0x01; // terminate after send
memcpy(txhdr->data, data, length);
length += field_offset(IPV4TX_header_t, data);
#ifdef FRAME_TX_DEBUG
printf("[TX %02x]", txframeid);
show_frame(frame, length);
#endif
return length;
}
static void send_at_command(int id, char *fmt, ...)
{
uint8_t frame[32];
ATCommand_t *atcmd = (ATCommand_t *)frame;
va_list ap;
int len;
atcmd->apiid = ID_ATCOMMAND;
atcmd->frameid = id;
va_start(ap, fmt);
len = field_offset(ATCommand_t, command) + vsprintf((char *)atcmd->command, fmt, ap);
va_end(ap);
#ifdef AT_DEBUG
printf("AT frame:");
show_frame(frame, len);
printf("AT '%s'", atcmd->command);
#endif
XbeeFrame_sendframe(mailbox, frame, len);
#ifdef AT_DEBUG
printf(" -- sent\n");
#endif
}
tex_t *
glsl_SCR_CaptureBGR (void)
{
byte *r, *b;
int count, i;
tex_t *tex;
count = vid.width * vid.height;
tex = malloc (field_offset (tex_t, data[count * 3]));
SYS_CHECKMEM (tex);
tex->width = vid.width;
tex->height = vid.height;
tex->format = tex_rgb;
tex->palette = 0;
qfeglReadPixels (0, 0, vid.width, vid.height, GL_RGB,
GL_UNSIGNED_BYTE, tex->data);
for (i = 0, r = tex->data, b = tex->data + 2; i < count;
i++, r += 3, b += 3) {
byte t = *b;
*b = *r;
*r = t;
}
return tex;
}
size_t jl_field_offset(jl_struct_type_t *t, jl_sym_t *fld)
{
return field_offset(t, fld, 0);
}
static void handle_ipv4_frame(IPV4RX_header_t *frame, int length)
{
Socket_t *sock = sockets;
#ifdef MULTI_SOCKETS
Socket_t *free = NULL;
#endif
int len, cnt, i;
uint8_t *ptr;
#ifdef SOCKET_DEBUG
printf("ip %d.%d.%d.%d, dst %d, src %d, protocol %d\n",
frame->srcaddr[0],
frame->srcaddr[1],
frame->srcaddr[2],
frame->srcaddr[3],
(frame->dstport[0] << 8) | frame->dstport[1],
(frame->srcport[0] << 8) | frame->srcport[1],
frame->protocol);
#endif
/* find a socket for this connection */
for (i = 0; i < MAX_SOCKETS; ++i) {
if (sock->flags & SF_BUSY) {
if (memcmp(&sock->id, &frame->srcaddr, sizeof(sock->id)) == 0)
break;
}
#ifdef MULTI_SOCKETS
else if (!free)
free = sock;
#endif
++sock;
}
/* check for needing to open a new socket */
if (i >= MAX_SOCKETS) {
#ifdef MULTI_SOCKETS
if (!(sock = free)) {
printf("No free sockets\n");
return; // no sockets available, ignore frame
}
#else
sock = &sockets[0];
#endif
sock->flags |= SF_BUSY;
memcpy(&sock->id, frame->srcaddr, sizeof(sock->id));
sock->protocol = frame->protocol;
sock->state = SS_REQUEST;
sock->handler = NULL;
sock->length = 0;
sock->i = 0;
}
#ifdef SOCKET_DEBUG
printf("Using socket %d\n", sock - sockets);
#endif
/* setup the frame parsing variables */
ptr = frame->data;
len = length - field_offset(IPV4RX_header_t, data);
/* process the data in this frame */
while (len > 0) {
switch (sock->state) {
case SS_REQUEST:
case SS_HEADER:
while (len > 0 && *ptr != '\r' && *ptr != '\n') {
if (sock->i < MAX_CONTENT)
sock->content[sock->i++] = *ptr;
++ptr;
--len;
}
if (len > 0) {
int term = *ptr;
sock->content[sock->i] = '\0';
++ptr;
--len;
if (sock->i == 0) {
if (sock->state == SS_REQUEST) {
printf("Missing request line\n");
}
else {
#ifdef STATE_MACHINE_DEBUG
printf("Found content\n");
#endif
if (term == '\r')
sock->state = SS_CONTENT_NL;
else {
if (sock->handler) {
sock->frame_ptr = ptr;
sock->frame_len = len;
(*sock->handler)(sock, HP_CONTENT_START);
}
sock->state = SS_CONTENT;
}
}
}
else {
#ifdef STATE_MACHINE_DEBUG
printf("Found %s: %s\n", sock->state == SS_REQUEST ? "request" : "header", sock->content);
#endif
switch (sock->state) {
case SS_REQUEST:
parse_request(sock);
break;
case SS_HEADER:
parse_header(sock);
break;
}
sock->state = (term == '\r' ? SS_SKIP_NL : SS_HEADER);
}
sock->i = 0;
}
break;
case SS_SKIP_NL:
case SS_CONTENT_NL:
if (*ptr == '\n') {
++ptr;
--len;
}
if (sock->state == SS_CONTENT_NL && sock->handler) {
sock->frame_ptr = ptr;
sock->frame_len = len;
(*sock->handler)(sock, HP_CONTENT_START);
}
sock->state = (sock->state == SS_SKIP_NL ? SS_HEADER : SS_CONTENT);
break;
case SS_CONTENT:
cnt = sock->length - sock->i;
#ifdef STATE_MACHINE_DEBUG
printf("length %d, remaining: %d\n", sock->length, cnt);
#endif
if (len < cnt)
cnt = len;
memcpy(&sock->content[sock->i], ptr, cnt);
sock->i += cnt;
ptr += cnt;
len -= cnt;
if (len > 0 && sock->i >= sock->length)
handle_content(sock);
break;
}
}
if (sock->i >= sock->length)
handle_content(sock);
}
int
main(int argc, char *argv[])
{
#ifndef GEN_HASKELL
printf("/* This file is created automatically. Do not edit by hand.*/\n\n");
printf("#define STD_HDR_SIZE %" FMT_SizeT "\n", (size_t)sizeofW(StgHeader) - sizeofW(StgProfHeader));
/* grrr.. PROFILING is on so we need to subtract sizeofW(StgProfHeader) */
printf("#define PROF_HDR_SIZE %" FMT_SizeT "\n", (size_t)sizeofW(StgProfHeader));
printf("#define BLOCK_SIZE %u\n", BLOCK_SIZE);
printf("#define MBLOCK_SIZE %u\n", MBLOCK_SIZE);
printf("#define BLOCKS_PER_MBLOCK %" FMT_SizeT "\n", (lnat)BLOCKS_PER_MBLOCK);
// could be derived, but better to save doing the calculation twice
printf("\n\n");
#endif
field_offset(StgRegTable, rR1);
field_offset(StgRegTable, rR2);
field_offset(StgRegTable, rR3);
field_offset(StgRegTable, rR4);
field_offset(StgRegTable, rR5);
field_offset(StgRegTable, rR6);
field_offset(StgRegTable, rR7);
field_offset(StgRegTable, rR8);
field_offset(StgRegTable, rR9);
field_offset(StgRegTable, rR10);
field_offset(StgRegTable, rF1);
field_offset(StgRegTable, rF2);
field_offset(StgRegTable, rF3);
field_offset(StgRegTable, rF4);
field_offset(StgRegTable, rD1);
field_offset(StgRegTable, rD2);
field_offset(StgRegTable, rL1);
field_offset(StgRegTable, rSp);
field_offset(StgRegTable, rSpLim);
field_offset(StgRegTable, rHp);
field_offset(StgRegTable, rHpLim);
field_offset(StgRegTable, rCCCS);
field_offset(StgRegTable, rCurrentTSO);
field_offset(StgRegTable, rCurrentNursery);
field_offset(StgRegTable, rHpAlloc);
struct_field(StgRegTable, rRet);
struct_field(StgRegTable, rNursery);
def_offset("stgEagerBlackholeInfo", FUN_OFFSET(stgEagerBlackholeInfo));
def_offset("stgGCEnter1", FUN_OFFSET(stgGCEnter1));
def_offset("stgGCFun", FUN_OFFSET(stgGCFun));
field_offset(Capability, r);
field_offset(Capability, lock);
struct_field(Capability, no);
struct_field(Capability, mut_lists);
struct_field(Capability, context_switch);
struct_field(Capability, interrupt);
struct_field(Capability, sparks);
struct_field(bdescr, start);
struct_field(bdescr, free);
struct_field(bdescr, blocks);
struct_field(bdescr, gen_no);
struct_field(bdescr, link);
struct_size(generation);
struct_field(generation, n_new_large_words);
struct_size(CostCentreStack);
struct_field(CostCentreStack, ccsID);
struct_field(CostCentreStack, mem_alloc);
struct_field(CostCentreStack, scc_count);
struct_field(CostCentreStack, prevStack);
struct_field(CostCentre, ccID);
struct_field(CostCentre, link);
struct_field(StgHeader, info);
struct_field_("StgHeader_ccs", StgHeader, prof.ccs);
struct_field_("StgHeader_ldvw", StgHeader, prof.hp.ldvw);
struct_size(StgSMPThunkHeader);
closure_payload(StgClosure,payload);
struct_field(StgEntCounter, allocs);
struct_field(StgEntCounter, registeredp);
struct_field(StgEntCounter, link);
struct_field(StgEntCounter, entry_count);
closure_size(StgUpdateFrame);
closure_size(StgCatchFrame);
closure_size(StgStopFrame);
closure_size(StgMutArrPtrs);
closure_field(StgMutArrPtrs, ptrs);
closure_field(StgMutArrPtrs, size);
closure_size(StgArrWords);
closure_field(StgArrWords, bytes);
closure_payload(StgArrWords, payload);
closure_field(StgTSO, _link);
closure_field(StgTSO, global_link);
closure_field(StgTSO, what_next);
closure_field(StgTSO, why_blocked);
closure_field(StgTSO, block_info);
closure_field(StgTSO, blocked_exceptions);
closure_field(StgTSO, id);
closure_field(StgTSO, cap);
closure_field(StgTSO, saved_errno);
closure_field(StgTSO, trec);
closure_field(StgTSO, flags);
closure_field(StgTSO, dirty);
closure_field(StgTSO, bq);
closure_field_("StgTSO_cccs", StgTSO, prof.cccs);
closure_field(StgTSO, stackobj);
closure_field(StgStack, sp);
closure_field_offset(StgStack, stack);
closure_field(StgStack, stack_size);
closure_field(StgStack, dirty);
struct_size(StgTSOProfInfo);
opt_struct_size(StgTSOProfInfo,PROFILING);
closure_field(StgUpdateFrame, updatee);
closure_field(StgCatchFrame, handler);
closure_field(StgCatchFrame, exceptions_blocked);
closure_size(StgPAP);
closure_field(StgPAP, n_args);
closure_field_gcptr(StgPAP, fun);
closure_field(StgPAP, arity);
closure_payload(StgPAP, payload);
thunk_size(StgAP);
closure_field(StgAP, n_args);
closure_field_gcptr(StgAP, fun);
closure_payload(StgAP, payload);
thunk_size(StgAP_STACK);
closure_field(StgAP_STACK, size);
closure_field_gcptr(StgAP_STACK, fun);
closure_payload(StgAP_STACK, payload);
thunk_size(StgSelector);
closure_field_gcptr(StgInd, indirectee);
closure_size(StgMutVar);
closure_field(StgMutVar, var);
closure_size(StgAtomicallyFrame);
closure_field(StgAtomicallyFrame, code);
closure_field(StgAtomicallyFrame, next_invariant_to_check);
closure_field(StgAtomicallyFrame, result);
closure_field(StgInvariantCheckQueue, invariant);
closure_field(StgInvariantCheckQueue, my_execution);
closure_field(StgInvariantCheckQueue, next_queue_entry);
closure_field(StgAtomicInvariant, code);
closure_field(StgTRecHeader, enclosing_trec);
closure_size(StgCatchSTMFrame);
closure_field(StgCatchSTMFrame, handler);
closure_field(StgCatchSTMFrame, code);
closure_size(StgCatchRetryFrame);
closure_field(StgCatchRetryFrame, running_alt_code);
closure_field(StgCatchRetryFrame, first_code);
closure_field(StgCatchRetryFrame, alt_code);
closure_field(StgTVarWatchQueue, closure);
closure_field(StgTVarWatchQueue, next_queue_entry);
closure_field(StgTVarWatchQueue, prev_queue_entry);
closure_field(StgTVar, current_value);
closure_size(StgWeak);
closure_field(StgWeak,link);
closure_field(StgWeak,key);
closure_field(StgWeak,value);
closure_field(StgWeak,finalizer);
closure_field(StgWeak,cfinalizer);
closure_size(StgDeadWeak);
closure_field(StgDeadWeak,link);
closure_size(StgMVar);
closure_field(StgMVar,head);
closure_field(StgMVar,tail);
closure_field(StgMVar,value);
closure_size(StgMVarTSOQueue);
closure_field(StgMVarTSOQueue, link);
closure_field(StgMVarTSOQueue, tso);
closure_size(StgBCO);
closure_field(StgBCO, instrs);
closure_field(StgBCO, literals);
closure_field(StgBCO, ptrs);
closure_field(StgBCO, arity);
closure_field(StgBCO, size);
closure_payload(StgBCO, bitmap);
closure_size(StgStableName);
closure_field(StgStableName,sn);
closure_size(StgBlockingQueue);
closure_field(StgBlockingQueue, bh);
closure_field(StgBlockingQueue, owner);
closure_field(StgBlockingQueue, queue);
closure_field(StgBlockingQueue, link);
closure_size(MessageBlackHole);
closure_field(MessageBlackHole, link);
closure_field(MessageBlackHole, tso);
closure_field(MessageBlackHole, bh);
struct_field_("RtsFlags_ProfFlags_showCCSOnException",
RTS_FLAGS, ProfFlags.showCCSOnException);
struct_field_("RtsFlags_DebugFlags_apply",
RTS_FLAGS, DebugFlags.apply);
struct_field_("RtsFlags_DebugFlags_sanity",
RTS_FLAGS, DebugFlags.sanity);
struct_field_("RtsFlags_DebugFlags_weak",
RTS_FLAGS, DebugFlags.weak);
struct_field_("RtsFlags_GcFlags_initialStkSize",
RTS_FLAGS, GcFlags.initialStkSize);
struct_field_("RtsFlags_MiscFlags_tickInterval",
RTS_FLAGS, MiscFlags.tickInterval);
struct_size(StgFunInfoExtraFwd);
struct_field(StgFunInfoExtraFwd, slow_apply);
struct_field(StgFunInfoExtraFwd, fun_type);
struct_field(StgFunInfoExtraFwd, arity);
struct_field_("StgFunInfoExtraFwd_bitmap", StgFunInfoExtraFwd, b.bitmap);
struct_size(StgFunInfoExtraRev);
struct_field(StgFunInfoExtraRev, slow_apply_offset);
struct_field(StgFunInfoExtraRev, fun_type);
struct_field(StgFunInfoExtraRev, arity);
struct_field_("StgFunInfoExtraRev_bitmap", StgFunInfoExtraRev, b.bitmap);
struct_field(StgLargeBitmap, size);
field_offset(StgLargeBitmap, bitmap);
struct_size(snEntry);
struct_field(snEntry,sn_obj);
struct_field(snEntry,addr);
#ifdef mingw32_HOST_OS
struct_size(StgAsyncIOResult);
struct_field(StgAsyncIOResult, reqID);
struct_field(StgAsyncIOResult, len);
struct_field(StgAsyncIOResult, errCode);
#endif
return 0;
}
static void
SV_Punish (int mode)
{
int i;
double mins = 0.5;
qboolean all = false, done = false;
client_t *cl = 0;
dstring_t *text = dstring_new();
const char *cmd = 0;
const char *cmd_do = 0;
//FIXME const char *cmd_undo = 0;
int field_offs = 0;
switch (mode) {
case 0:
cmd = "cuff";
cmd_do = "cuffed";
//FIXME cmd_undo = "un-cuffed";
field_offs = field_offset (client_t, cuff_time);
break;
case 1:
cmd = "mute";
cmd_do = "muted";
//FIXME cmd_undo = "can speak";
field_offs = field_offset (client_t, lockedtill);
break;
}
if (Cmd_Argc () != 2 && Cmd_Argc () != 3) {
SV_Printf ("usage: %s <name/userid/ALL> [minutes]\n"
" (default = 0.5, 0 = cancel cuff).\n", cmd);
return;
}
if (strequal (Cmd_Argv (1), "ALL")) {
all = true;
} else {
cl = SV_Match_User (Cmd_Argv (1));
}
if (!all && !cl)
return;
if (Cmd_Argc () == 3) {
mins = atof (Cmd_Argv (2));
if (mins < 0.0 || mins > MAXPENALTY)
mins = MAXPENALTY;
}
if (cl) {
*(double *)((char *)cl + field_offs) = realtime + mins * 60.0;
if (mins) {
dsprintf (text, "You are %s for %.1f minutes\n\n"
"reconnecting won't help...\n", cmd_do, mins);
MSG_ReliableWrite_Begin (&cl->backbuf, svc_centerprint,
2 + strlen (text->str));
MSG_ReliableWrite_String (&cl->backbuf, text->str);
}
}
if (all) {
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++) {
if (cl->state < cs_zombie)
continue;
*(double *)((char *)cl + field_offs) = realtime + mins * 60.0;
done = true;
if (mins) {
dsprintf (text, "You are %s for %.1f minutes\n\n"
"reconnecting won't help...\n", cmd_do, mins);
MSG_ReliableWrite_Begin (&cl->backbuf, svc_centerprint,
2 + strlen (text->str));
MSG_ReliableWrite_String (&cl->backbuf, text->str);
}
}
}
if (done) {
if (mins)
SV_BroadcastPrintf (PRINT_HIGH, "%s %s for %.1f minutes.\n",
all? "All Users" : cl->name, cmd_do, mins);
else
SV_BroadcastPrintf (PRINT_HIGH, "%s %s.\n",
all? "All Users" : cl->name, cmd_do);
}
dstring_delete (text);
}
