/****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc. *
+ * Copyright 2018-2020,2022 Thomas E. Dickey *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the *
traces will be dumped. The program stops and waits for one character of
input at the beginning and end of the interval.
- $Id: worm.c,v 1.75 2017/09/08 20:00:50 tom Exp $
+ $Id: worm.c,v 1.84 2022/07/23 17:06:16 tom Exp $
*/
#include <test.priv.h>
static bool quitting = FALSE;
static WORM worm[MAX_WORMS];
+static int max_refs;
static int **refs;
static int last_x, last_y;
static chtype trail = ' ';
static unsigned pending;
+
+#ifdef USE_PTHREADS
+#define Locked(statement) { \
+ pthread_mutex_lock(&pending_mutex); \
+ statement; \
+ pthread_mutex_unlock(&pending_mutex); \
+ }
+pthread_mutex_t pending_mutex;
+#else
+#define Locked(statement) statement
+#endif
+
#ifdef TRACE
static int generation, trace_start, trace_end;
#endif /* TRACE */
};
/* *INDENT-ON* */
+#if HAVE_USE_WINDOW
+static int
+safe_wgetch(WINDOW *w, void *data GCC_UNUSED)
+{
+ return wgetch(w);
+}
+static int
+safe_wrefresh(WINDOW *w, void *data GCC_UNUSED)
+{
+ return wrefresh(w);
+}
+#endif
+
#ifdef KEY_RESIZE
static void
failed(const char *s)
{
perror(s);
- exit_curses();
+ stop_curses();
ExitProgram(EXIT_FAILURE);
}
#endif
static void
cleanup(void)
{
- USING_WINDOW(stdscr, wrefresh);
- exit_curses();
+ USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
+ stop_curses();
}
static void
WORM *w = (WORM *) data;
const struct options *op;
unsigned mask = (unsigned) (~(1 << (w - worm)));
- chtype attrs = w->attrs | ((mask & pending) ? A_REVERSE : 0);
+ chtype attrs;
int x;
int y;
int h;
bool done = FALSE;
+ bool is_pending;
+
+ Locked(is_pending = ((mask & pending) != 0));
+
+ attrs = w->attrs | (is_pending ? A_REVERSE : 0);
if ((x = w->xpos[h = w->head]) < 0) {
wmove(win, y = w->ypos[h] = last_y, x = w->xpos[h] = 0);
switch (op->nopts) {
case 0:
done = TRUE;
+ Trace(("done - draw_worm"));
break;
case 1:
w->orientation = op->opts[0];
static bool
quit_worm(int bitnum)
{
- pending = (pending | (unsigned) (1 << bitnum));
+ Locked(pending = (pending | (unsigned) (1 << bitnum)));
+
napms(10); /* let the other thread(s) have a chance */
- pending = (pending & (unsigned) ~(1 << bitnum));
+
+ Locked(pending = (pending & (unsigned) ~(1 << bitnum)));
+
return quitting;
}
while (!quit_worm((int) (((struct worm *) arg) - worm))) {
while (compare < sequence) {
++compare;
-#if HAVE_USE_WINDOW
- use_window(stdscr, draw_worm, arg);
-#else
- draw_worm(stdscr, arg);
-#endif
+ USING_WINDOW2(stdscr, draw_worm, arg);
}
}
Trace(("...start_worm (done)"));
}
#else
for (n = 0, w = &worm[0]; n < number; n++, w++) {
- if (
-#if HAVE_USE_WINDOW
- USING_WINDOW2(stdscr, draw_worm, w)
-#else
- draw_worm(stdscr, w)
-#endif
- )
+ if (USING_WINDOW2(stdscr, draw_worm, w))
done = TRUE;
}
#endif
get_input(void)
{
int ch;
- ch = USING_WINDOW(stdscr, wgetch);
+ ch = USING_WINDOW1(stdscr, wgetch, safe_wgetch);
return ch;
}
#ifdef KEY_RESIZE
static int
-update_refs(WINDOW *win)
+update_refs(WINDOW *win, void *data)
{
int x, y;
(void) win;
+ (void) data;
if (last_x != COLS - 1) {
for (y = 0; y <= last_y; y++) {
refs[y] = typeRealloc(int, (size_t) COLS, refs[y]);
if (last_y != LINES - 1) {
for (y = LINES; y <= last_y; y++)
free(refs[y]);
+ max_refs = LINES;
refs = typeRealloc(int *, (size_t) LINES, refs);
for (y = last_y + 1; y < LINES; y++) {
refs[y] = typeMalloc(int, (size_t) COLS);
struct worm *w;
int *ip;
bool done = FALSE;
- int max_refs;
#if HAVE_USE_DEFAULT_COLORS
bool opt_d = FALSE;
#endif
}
}
}
- USING_WINDOW(stdscr, wrefresh);
+ USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
nodelay(stdscr, TRUE);
+#ifdef USE_PTHREADS
+ pthread_mutex_init(&pending_mutex, NULL);
+#endif
+
while (!done) {
- ++sequence;
+ Locked(++sequence);
if ((ch = get_input()) > 0) {
#ifdef TRACE
if (trace_start || trace_end) {
if (generation == trace_start) {
- trace(TRACE_CALLS);
+ curses_trace(TRACE_CALLS);
get_input();
} else if (generation == trace_end) {
- trace(0);
+ curses_trace(0);
get_input();
}
if (ch == 'q') {
quitting = TRUE;
done = TRUE;
+ Trace(("done - quitting"));
continue;
} else if (ch == 's') {
nodelay(stdscr, FALSE);
done = draw_all_worms();
napms(10);
- USING_WINDOW(stdscr, wrefresh);
+ USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
}
Trace(("Cleanup"));