static int run_scan_argument(lua_State * L) /* HH */
{ /* can be simplified, no need for intermediate list */
saved_tex_scanner texstate;
halfword t, saved_defref;
save_tex_scanner(texstate);
do {
get_token();
} while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
if (cur_cmd == left_brace_cmd) {
back_input();
saved_defref = def_ref;
(void) scan_toks(false, true);
t = def_ref;
def_ref = saved_defref;
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == call_cmd) {
halfword saved_cur_tok = cur_tok;
cur_tok = right_brace_token + '}';
back_input();
cur_tok = saved_cur_tok;
back_input();
cur_tok = left_brace_token + '{';
back_input();
saved_defref = def_ref;
(void) scan_toks(false, true);
t = def_ref;
def_ref = saved_defref;
tokenlist_to_luastring(L,t);
flush_list(t);
} else if (cur_cmd == 11 || cur_cmd == 12 ) {
declare_buffer;
while (1) {
add_to_buffer(cur_chr);
get_x_token();
if (cur_cmd != 11 && cur_cmd != 12 ) {
break ;
}
}
back_input();
push_buffer;
} else {
back_input();
lua_pushnil(L);
}
unsave_tex_scanner(texstate);
return 1;
}
int network_listen(struct timeval *timeout)
{
fd_set set;
int ret;
flush_list();
setfd(&set);
if (timeout)
logger_debug("[NETWORK] waiting for next action in %lu:%lu",
timeout->tv_sec,
timeout->tv_usec);
else
logger_debug("[NETWORK] waiting for extern action. nothing planified");
if ((ret = (select(g_network->nfds, &set, NULL, NULL, timeout))) > 0)
{
find_speaker(&set,
g_network->read,
&extract_from_socket,
&execute_from_socket);
find_speaker(&set,
g_network->listened,
&extract_from_listener,
&execute_from_listener);
}
g_network->nfds = 0;
return (ret);
}
static void find_speaker(fd_set *set,
t_list *list,
SOCKET (*extract)(void *),
void (*execute)(void *))
{
t_list_iterator *it;
int ret;
void *tmp;
if (!set || !list || !extract || !execute)
return;
it = list_iterator_begin(list);
ret = (list_empty(list))?EXIT_FAILURE:EXIT_SUCCESS;
while (ret != EXIT_FAILURE)
{
tmp = list_iterator_get(it);
if (FD_ISSET(extract(tmp), set) && tmp)
{
logger_verbose("[NETWORK] message from fd : %d", extract(tmp));
ret = list_iterator_next(it);
(*execute)(tmp);
}
else
ret = list_iterator_next(it);
}
flush_list();
list_iterator_destroy(it);
}
static void
free_voters(voterstruct *vp)
{
if (vp->first != NULL) {
flush_list(vp);
free(vp->first);
vp->first = (CellList *) NULL;
}
if (vp->last != NULL) {
free(vp->last);
vp->last = (CellList *) NULL;
}
if (vp->arr != NULL) {
free(vp->arr);
vp->arr = (char *) NULL;
}
}
void ObjectManager::update(sdlc::Timer& timer, FxManager& fx_manager,
float world_y_pos, PlayerState& player_state)
{
world_y_pos_ = world_y_pos;
for (auto current : list) {
if (current->energy()) {
// main functions
current->think(*this, fx_manager);
current->update(timer);
current->check_collisions(*this, fx_manager);
// kill objects who move outside their allowed area
if (current->y() > 480) {
ObjType t = current->type();
if (t == ObjType::enemy || t == ObjType::passive
|| t == ObjType::bonus || t == ObjType::shot) {
current->set_energy(0);
}
} else if (current->type() == ObjType::shot) {
if (current->y() < 0 - current->height()
|| current->x() > 640
|| current->x() < 0 - current->width()) {
current->set_energy(0);
}
}
// debug
if (current->type() == ObjType::undefined) {
std::cout << "warning: object with undefined "
<< "type detected!" << std::endl;
}
if (current->name() == "Generic Object") {
std::cout << "warning: object with undefined "
<< "name detected!" << std::endl;
}
}
}
// Run maintenance functions
update_all_player_state(player_state);
flush_list(); // flush dead objects
add_from_queue(); // add the new objects
update_enemy_count(); // update/count how many enemies
}
void write_out(halfword p)
{
int old_setting;
int j;
char*s,*ss;
int callback_id;
int lua_retval;
expand_macros_in_tokenlist(p);
old_setting= selector;
j= write_stream(p);
if(file_can_be_written(j)){
selector= j;
}else if((j==term_only)&&(selector==term_and_log)){
selector= log_only;
tprint_nl("");
}else{
tprint_nl("");
}
s= tokenlist_to_cstring(def_ref,false,NULL);
if(selector<no_print){
callback_id= callback_defined(process_output_buffer_callback);
if(callback_id> 0){
lua_retval= run_callback(callback_id,"S->S",s,&ss);
if((lua_retval==true)&&(ss!=NULL)){
xfree(s);
s= ss;
}
}
}
tprint(s);
xfree(s);
print_ln();
flush_list(def_ref);
selector= old_setting;
}
int flush_ignore_list(void)
{
int t = flush_list(ignore_list);
ignore_list = NULL;
return (t);
}
int flush_contact_list(void)
{
int t = flush_list(contact_list);
contact_list = NULL;
return (t);
}
void
hyphenate ()
{
str t, u;
ptr q, r, s;
ptr hyf_node;
int bchar;
int c_loc;
int r_count;
ptr major_tail;
ptr minor_tail;
int c, h, i, j, l, v, z;
for (j = 0; j <= hn; incr(j))
hyf[j] = 0;
h = hc[1];
incr(hn);
hc[hn] = cur_lang;
for (j = 2; j <= hn; incr(j))
h = (h + h + hc[j]) % HYPH_SIZE;
loop {
t = hyph_word[h];
if (t == null_str)
goto not_found;
l = hyph_len[h];
if (l < hn)
goto not_found;
if (l == hn) {
j = 1;
u = t;
while (j <= hn) {
if (*u < hc[j])
goto not_found;
if (*u > hc[j])
goto done;
incr(u);
incr(j);
}
for (s = hyph_list[h]; s != null; s = link(s))
hyf[info(s)] = 1;
decr(hn);
goto found;
}
done:
if (h > 0) {
decr(h);
} else {
h = HYPH_SIZE;
}
}
not_found:
decr(hn);
if (trie_char(cur_lang + 1) != cur_lang)
return;
hc[0] = 0;
hc[hn + 1] = 0;
hc[hn + 2] = 256;
for (j = 0; j <= hn - r_hyf + 1; incr(j)) {
z = trie_link(cur_lang + 1) + hc[j];
l = j;
while (hc[l] == trie_char(z)) {
if (v = trie_op(z)) {
while (v) {
v += op_start[cur_lang];
i = l - hyf_distance[v];
if (hyf_num[v] > hyf[i])
hyf[i] = hyf_num[v];
v = hyf_next[v];
}
}
incr(l);
z = trie_link(z) + hc[l];
}
}
found:
for (j = 0; j < l_hyf; incr(j)) {
hyf[j] = 0;
}
for (j = 0; j < r_hyf; incr(j)) {
hyf[hn - j] = 0;
}
for (j = l_hyf; j <= hn - r_hyf; incr(j))
if (odd(hyf[j]))
goto found1;
return;
found1:
q = link(hb);
link(hb) = null;
r = link(ha);
link(ha) = null;
bchar = NON_CHAR;
if (type(hb) == LIGATURE_NODE && odd(subtype(hb))) {
bchar = font_bchar(hf);
}
if (is_char_node(ha)) {
if (font(ha) != hf) {
goto found2;
} else {
init_list = ha;
init_lig = FALSE;
hu[0] = character(ha);
}
} else if (type(ha) == LIGATURE_NODE) {
if (font(lig_char(ha)) != hf) {
goto found2;
} else {
init_list = lig_ptr(ha);
init_lig = TRUE;
init_lft = subtype(ha) > 1;
hu[0] = character(lig_char(ha));
if (init_list == null && init_lft) {
hu[0] = 256;
init_lig = FALSE;
}
free_node(ha, SMALL_NODE_SIZE);
}
} else {
if (type(r) == LIGATURE_NODE && subtype(r) > 1) {
goto found2;
}
j = 1;
s = ha;
init_list = null;
goto common_end;
}
s = cur_p;
while (link(s) != ha)
s = link(s);
j = 0;
goto common_end;
found2:
s = ha;
j = 0;
hu[0] = 256;
init_lig = FALSE;
init_list = null;
common_end:
flush_node_list(r);
#define advance_major_tail() \
{ major_tail = link(major_tail); \
incr(r_count); \
}
#define put_pre_break() \
{ minor_tail = null; \
pre_break(r) = null; \
hyf_node = new_character(hf, hyf_char); \
if (hyf_node != null) { \
incr(i); \
c = hu[i]; \
hu[i] = hyf_char; \
free_avail(hyf_node); \
} \
while (l <= i) { \
l = reconstitute(l, i, font_bchar(hf), NON_CHAR) + 1; \
if (link(hold_head) == null) { \
continue; \
} \
if (minor_tail == null) { \
pre_break(r) = link(hold_head); \
} else { \
link(minor_tail) = link(hold_head); \
} \
minor_tail = link(hold_head); \
while (link(minor_tail) != null) \
minor_tail = link(minor_tail); \
} \
if (hyf_node != null) { \
hu[i] = c; \
l = i; \
decr(i); \
} \
}
#define put_post_break() \
{ minor_tail = null; \
post_break(r) = null; \
c_loc = 0; \
if (bchar_label(hf) != NON_ADDRESS) { \
decr(l); \
c = hu[l]; \
c_loc = l; \
hu[l] = 256; \
} \
while (l < j) { \
do { \
l = reconstitute(l, hn, bchar, NON_CHAR) + 1; \
if (c_loc > 0) { \
hu[c_loc] = c; \
c_loc = 0; \
} \
if (link(hold_head) == null) { \
continue; \
} \
if (minor_tail == null) { \
post_break(r) = link(hold_head); \
} else { \
link(minor_tail) = link(hold_head); \
} \
minor_tail = link(hold_head); \
while (link(minor_tail) != null) \
minor_tail = link(minor_tail); \
} while (l < j); \
while (l > j) { \
j = reconstitute(j, hn, bchar, NON_CHAR) + 1; \
link(major_tail) = link(hold_head); \
while (link(major_tail) != null) { \
advance_major_tail(); \
} \
} \
} \
}
do {
l = j;
j = reconstitute(j, hn, bchar, hyf_char) + 1;
if (hyphen_passed == 0) {
link(s) = link(hold_head);
while (link(s) != null)
s = link(s);
if (odd(hyf[j - 1])) {
l = j;
hyphen_passed = j - 1;
link(hold_head) = null;
}
}
if (hyphen_passed > 0) {
do {
r = new_node(SMALL_NODE_SIZE);
link(r) = link(hold_head);
type(r) = DISC_NODE;
major_tail = r;
r_count = 0;
while (link(major_tail) != null) {
advance_major_tail();
}
i = hyphen_passed;
hyf[i] = 0;
put_pre_break();
put_post_break();
if (r_count > 127) {
link(s) = link(r);
link(r) = null;
flush_node_list(r);
} else {
link(s) = r;
replace_count(r) = r_count;
}
s = major_tail;
hyphen_passed = j - 1;
link(hold_head) = null;
} while (odd(hyf[j - 1]));
}
} while (j <= hn);
link(s) = q;
flush_list(init_list);
}
static void
handle_request(void *ctx) {
conn_t *conn = ctx;
struct evbuffer *rsps = evbuffer_new();
struct state *s = conn->state;
if (strcmp(conn->method, "GET") == 0) {
if (strcmp(conn->url, "/getproxies") == 0)
get_proxies(rsps);
else if (strcmp(conn->url, "/getlists") == 0)
get_lists(rsps);
else if (strncmp(conn->url, "/query?", 7) == 0)
query(rsps, evhttp_decode_uri(conn->url + 7));
else if (strcmp(conn->url, "/getlog") == 0)
get_log(rsps);
else if (strcmp(conn->url, "/gettrylist") == 0)
get_trylist(rsps);
else if (strcmp(conn->url, "/getversion") == 0)
evbuffer_add_printf(rsps, VERSION);
}
else if (strcmp(conn->method, "POST") == 0) {
struct evkeyvalq kv;
struct evhttp_uri *uri = evhttp_uri_parse_with_flags(conn->url, 0);
evhttp_parse_query_str(evhttp_uri_get_query(uri), &kv);
char *cont;
if (s->length)
cont = s->body;
const char *path = evhttp_uri_get_path(uri);
if (strcmp(path, "/addrule") == 0 || strcmp(path, "/rmrule") == 0) {
struct evkeyvalq kvc;
evhttp_parse_query_str(cont, &kvc);
char *list = evhttp_decode_uri(evhttp_find_header(&kvc, "list"));
char *rule = evhttp_decode_uri(evhttp_find_header(&kvc, "rule"));
if (get_domain(rule) == NULL)
evbuffer_add_printf(rsps, "Invalid rule.");
else {
if (strcmp(path, "/addrule") == 0)
update_rule(list, rule);
else
remove_rule(list, rule);
evbuffer_add_printf(rsps, "OK");
}
free(list);
free(rule);
free(cont);
}
else if (strcmp(path, "/flush") == 0) {
flush_list();
evbuffer_add_printf(rsps, "OK");
}
else if (strcmp(path, "/rmlog") == 0) {
rm_log(rsps);
}
else if (strcmp(path, "/purgetrylist") == 0) {
purgetrylist(rsps);
}
evhttp_uri_free(uri);
}
ret(conn->be_client, rsps);
evbuffer_free(rsps);
}
void error_pool_teardown(void)
{
flush_list();
}
void error_pool_deactivate(void)
{
flush_list();
msg_size = 0;
activated = 0;
}
void
init_voters(ModeInfo * mi)
{
int size = MI_SIZE(mi);
int i, col, row, colrow;
voterstruct *vp;
if (voters == NULL) {
if ((voters = (voterstruct *) calloc(MI_NUM_SCREENS(mi),
sizeof (voterstruct))) == NULL)
return;
}
vp = &voters[MI_SCREEN(mi)];
vp->generation = 0;
if (!vp->first) { /* Genesis of democracy */
icon_width = donkey_width;
icon_height = donkey_height;
if (!init_list(vp)) {
free_voters(vp);
return;
}
for (i = 0; i < BITMAPS; i++) {
logo[i].width = icon_width;
logo[i].height = icon_height;
logo[i].bytes_per_line = (icon_width + 7) / 8;
}
} else /* Exterminate all free thinking individuals */
flush_list(vp);
if (MI_IS_FULLRANDOM(mi)) {
vp->vertical = (Bool) (LRAND() & 1);
} else {
vp->vertical = vertical;
}
vp->width = MI_WIDTH(mi);
vp->height = MI_HEIGHT(mi);
for (i = 0; i < NEIGHBORKINDS; i++) {
if (neighbors == plots[i]) {
vp->neighbors = neighbors;
break;
}
if (i == NEIGHBORKINDS - 1) {
#if 0
vp->neighbors = plots[NRAND(NEIGHBORKINDS)];
vp->neighbors = (LRAND() & 1) ? 4 : 8;
#else
vp->neighbors = 8;
#endif
break;
}
}
if (vp->neighbors == 6) {
int nccols, ncrows, sides;
if (!vp->vertical) {
vp->height = MI_WIDTH(mi);
vp->width = MI_HEIGHT(mi);
}
if (vp->width < 8)
vp->width = 8;
if (vp->height < 8)
vp->height = 8;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) / MINGRIDSIZE);
else
vp->ys = MINSIZE;
} else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = vp->ys;
vp->pixelmode = True;
nccols = MAX(vp->width / vp->xs - 2, 2);
ncrows = MAX(vp->height / vp->ys - 1, 4);
vp->ncols = nccols / 2;
vp->nrows = 2 * (ncrows / 4);
vp->xb = (vp->width - vp->xs * nccols) / 2 + vp->xs / 2;
vp->yb = (vp->height - vp->ys * (ncrows / 2) * 2) / 2 +
vp->ys - 2;
for (sides = 0; sides < 6; sides++) {
if (vp->vertical) {
vp->shape.hexagon[sides].x =
(vp->xs - 1) * hexagonUnit[sides].x;
vp->shape.hexagon[sides].y =
((vp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
} else {
vp->shape.hexagon[sides].y =
(vp->xs - 1) * hexagonUnit[sides].x;
vp->shape.hexagon[sides].x =
((vp->ys - 1) * hexagonUnit[sides].y /
2) * 4 / 3;
}
}
} else if (vp->neighbors == 4 || vp->neighbors == 8) {
if (vp->width < 2)
vp->width = 2;
if (vp->height < 2)
vp->height = 2;
if (size == 0 ||
MINGRIDSIZE * size > vp->width || MINGRIDSIZE * size > vp->height) {
if (vp->width > MINGRIDSIZE * icon_width &&
vp->height > MINGRIDSIZE * icon_height) {
vp->pixelmode = False;
vp->xs = icon_width;
vp->ys = icon_height;
} else {
vp->pixelmode = True;
vp->xs = vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE);
}
} else {
vp->pixelmode = True;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE)
vp->ys = MINSIZE;
else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = vp->ys;
}
vp->ncols = MAX(vp->width / vp->xs, 2);
vp->nrows = MAX(vp->height / vp->ys, 2);
vp->xb = (vp->width - vp->xs * vp->ncols) / 2;
vp->yb = (vp->height - vp->ys * vp->nrows) / 2;
} else { /* TRI */
int orient, sides;
if (!vp->vertical) {
vp->height = MI_WIDTH(mi);
vp->width = MI_HEIGHT(mi);
}
if (vp->width < 2)
vp->width = 2;
if (vp->height < 2)
vp->height = 2;
if (size < -MINSIZE)
vp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE;
else if (size < MINSIZE) {
if (!size)
vp->ys = MAX(MINSIZE, MIN(vp->width, vp->height) / MINGRIDSIZE);
else
vp->ys = MINSIZE;
} else
vp->ys = MIN(size, MAX(MINSIZE, MIN(vp->width, vp->height) /
MINGRIDSIZE));
vp->xs = (int) (1.52 * vp->ys);
vp->pixelmode = True;
vp->ncols = (MAX(vp->width / vp->xs - 1, 2) / 2) * 2;
vp->nrows = (MAX(vp->height / vp->ys - 1, 2) / 2) * 2;
vp->xb = (vp->width - vp->xs * vp->ncols) / 2 + vp->xs / 2;
vp->yb = (vp->height - vp->ys * vp->nrows) / 2 + vp->ys / 2;
for (orient = 0; orient < 2; orient++) {
for (sides = 0; sides < 3; sides++) {
if (vp->vertical) {
vp->shape.triangle[orient][sides].x =
(vp->xs - 2) * triangleUnit[orient][sides].x;
vp->shape.triangle[orient][sides].y =
(vp->ys - 2) * triangleUnit[orient][sides].y;
} else {
vp->shape.triangle[orient][sides].y =
(vp->xs - 2) * triangleUnit[orient][sides].x;
vp->shape.triangle[orient][sides].x =
(vp->ys - 2) * triangleUnit[orient][sides].y;
}
}
}
}
vp->npositions = vp->ncols * vp->nrows;
if (vp->arr != NULL)
free(vp->arr);
if ((vp->arr = (char *) calloc(vp->npositions, sizeof (char))) == NULL) {
free_voters(vp);
return;
}
/* Play G-d with these numbers */
vp->nparties = MI_COUNT(mi);
if (vp->nparties < MINPARTIES || vp->nparties > BITMAPS)
vp->nparties = NRAND(BITMAPS - MINPARTIES + 1) + MINPARTIES;
if (vp->pixelmode)
vp->nparties = 2;
vp->busyLoop = 0;
MI_CLEARWINDOW(mi);
vp->painted = False;
for (i = 0; i < BITMAPS; i++)
vp->number_in_party[i] = 0;
for (row = 0; row < vp->nrows; row++)
for (col = 0; col < vp->ncols; col++) {
colrow = col + row * vp->ncols;
if (vp->nparties == 2)
i = (NRAND(vp->nparties) + 2) % BITMAPS;
else
i = NRAND(vp->nparties);
vp->arr[colrow] = (char) i;
drawcell(mi, col, row, (unsigned long) (MI_NPIXELS(mi) * i / BITMAPS),
i, False);
vp->number_in_party[i]++;
}
}
void error_pool_destroy(void)
{
flush_list();
}
