/****************************************************************************
- * Copyright (c) 1998-2007,2008 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 *
July 1995 (esr): worms is now in living color! :-)
-Options:
- -f fill screen with copies of 'WORM' at start.
- -l <n> set worm length
- -n <n> set number of worms
- -t make worms leave droppings
- -T <start> <end> set trace interval
- -S set single-stepping during trace interval
- -N suppress cursor-movement optimization
-
This program makes a good torture-test for the ncurses cursor-optimization
code. You can use -T to set the worm move interval over which movement
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.58 2008/10/04 21:54:09 tom Exp $
+ $Id: worm.c,v 1.89 2022/12/24 20:46:49 tom Exp $
*/
#include <test.priv.h>
+#ifndef NCURSES_VERSION
+#undef TRACE
+#endif
+
#ifdef USE_PTHREADS
#include <pthread.h>
#endif
{
'O', '*', '#', '$', '%', '0', '@',
};
-static const short xinc[] =
+static const int xinc[] =
{
1, 1, 1, 0, -1, -1, -1, 0
}, yinc[] =
typedef struct worm {
int orientation;
int head;
- short *xpos;
- short *ypos;
+ int *xpos;
+ int *ypos;
chtype attrs;
#ifdef USE_PTHREADS
pthread_t thread;
static bool quitting = FALSE;
static WORM worm[MAX_WORMS];
-static short **refs;
+static int max_refs;
+static int **refs;
static int last_x, last_y;
static const char *field;
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);
+ stop_curses();
+ ExitProgram(EXIT_FAILURE);
+}
+#endif
+
static void
cleanup(void)
{
- USING_WINDOW(stdscr, wrefresh);
- curs_set(1);
- endwin();
+ USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
+ stop_curses();
}
-static RETSIGTYPE
+static void
onsig(int sig GCC_UNUSED)
{
cleanup();
ExitProgram(EXIT_FAILURE);
}
-static float
+static double
ranf(void)
{
long r = (rand() & 077777);
- return ((float) r / 32768.);
+ return ((double) r / 32768.);
}
static int
{
WORM *w = (WORM *) data;
const struct options *op;
- unsigned mask = ~(1 << (w - worm));
- chtype attrs = w->attrs | ((mask & pending) ? A_REVERSE : 0);
+ unsigned mask = (unsigned) (~(1 << (w - worm)));
+ 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];
break;
default:
- w->orientation = op->opts[(int) (ranf() * (float) op->nopts)];
+ w->orientation = op->opts[(int) (ranf() * (double) op->nopts)];
break;
}
static bool
quit_worm(int bitnum)
{
- pending |= (1 << bitnum);
+ Locked(pending = (pending | (unsigned) (1 << bitnum)));
+
napms(10); /* let the other thread(s) have a chance */
- pending &= ~(1 << bitnum);
+
+ Locked(pending = (pending & (unsigned) ~(1 << bitnum)));
+
return quitting;
}
{
unsigned long compare = 0;
Trace(("start_worm"));
- while (!quit_worm(((struct worm *) arg) - worm)) {
- while (compare < sequence) {
+ while (!quit_worm((int) (((struct worm *) arg) - worm))) {
+ for (;;) {
+ bool done = FALSE;
+ Locked(done = (compare >= sequence));
+ if (done)
+ break;
++compare;
- use_window(stdscr, draw_worm, arg);
+ USING_WINDOW2(stdscr, draw_worm, arg);
}
}
Trace(("...start_worm (done)"));
if (first) {
first = FALSE;
for (n = 0, w = &worm[0]; n < number; n++, w++) {
- int rc;
- rc = pthread_create(&(w->thread), NULL, start_worm, w);
+ (void) pthread_create(&(w->thread), NULL, start_worm, w);
}
}
#else
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(short, COLS, refs[y]);
+ refs[y] = typeRealloc(int, (size_t) COLS, refs[y]);
+ if (!refs[y])
+ failed("update_refs");
for (x = last_x + 1; x < COLS; x++)
refs[y][x] = 0;
}
if (last_y != LINES - 1) {
for (y = LINES; y <= last_y; y++)
free(refs[y]);
- refs = typeRealloc(short *, LINES, refs);
+ max_refs = LINES;
+ refs = typeRealloc(int *, (size_t) LINES, refs);
for (y = last_y + 1; y < LINES; y++) {
- refs[y] = typeMalloc(short, COLS);
+ refs[y] = typeMalloc(int, (size_t) COLS);
+ if (!refs[y])
+ failed("update_refs");
for (x = 0; x < COLS; x++)
refs[y][x] = 0;
}
}
#endif
+static void
+usage(int ok)
+{
+ static const char *msg[] =
+ {
+ "Usage: worm [options]"
+ ,""
+ ,USAGE_COMMON
+ ,"Options:"
+#if HAVE_USE_DEFAULT_COLORS
+ ," -d invoke use_default_colors"
+#endif
+ ," -f fill screen with copies of \"WORM\" at start"
+ ," -l <n> set length of worms"
+ ," -n <n> set number of worms"
+ ," -t leave trail of \".\""
+#ifdef TRACE
+ ," -T <start>,<end> set trace interval"
+ ," -N suppress cursor-movement optimization"
+#endif
+ };
+ size_t n;
+
+ for (n = 0; n < SIZEOF(msg); n++)
+ fprintf(stderr, "%s\n", msg[n]);
+
+ ExitProgram(ok ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+/* *INDENT-OFF* */
+VERSION_COMMON()
+/* *INDENT-ON* */
+
int
main(int argc, char *argv[])
{
+ int ch;
int x, y;
int n;
struct worm *w;
- short *ip;
+ int *ip;
bool done = FALSE;
+#if HAVE_USE_DEFAULT_COLORS
+ bool opt_d = FALSE;
+#endif
setlocale(LC_ALL, "");
- for (x = 1; x < argc; x++) {
- char *p;
- p = argv[x];
- if (*p == '-')
- p++;
- switch (*p) {
+ while ((ch = getopt(argc, argv, OPTS_COMMON "dfl:n:tT:N")) != -1) {
+ switch (ch) {
+#if HAVE_USE_DEFAULT_COLORS
+ case 'd':
+ opt_d = TRUE;
+ break;
+#endif
case 'f':
field = "WORM";
break;
case 'l':
- if (++x == argc)
- goto usage;
- if ((length = atoi(argv[x])) < 2 || length > MAX_LENGTH) {
+ if ((length = atoi(optarg)) < 2 || length > MAX_LENGTH) {
fprintf(stderr, "%s: Invalid length\n", *argv);
- ExitProgram(EXIT_FAILURE);
+ usage(FALSE);
}
break;
case 'n':
- if (++x == argc)
- goto usage;
- if ((number = atoi(argv[x])) < 1 || number > MAX_WORMS) {
+ if ((number = atoi(optarg)) < 1 || number > MAX_WORMS) {
fprintf(stderr, "%s: Invalid number of worms\n", *argv);
- ExitProgram(EXIT_FAILURE);
+ usage(FALSE);
}
break;
case 't':
break;
#ifdef TRACE
case 'T':
- trace_start = atoi(argv[++x]);
- trace_end = atoi(argv[++x]);
+ if (sscanf(optarg, "%d,%d", &trace_start, &trace_end) != 2)
+ usage(FALSE);
break;
case 'N':
_nc_optimize_enable ^= OPTIMIZE_ALL; /* declared by ncurses */
break;
#endif /* TRACE */
+ case OPTS_VERSION:
+ show_version(argv);
+ ExitProgram(EXIT_SUCCESS);
default:
- usage:
- fprintf(stderr,
- "usage: %s [-field] [-length #] [-number #] [-trail]\n", *argv);
- ExitProgram(EXIT_FAILURE);
+ usage(ch == OPTS_USAGE);
+ /* NOTREACHED */
}
}
+ if (optind < argc)
+ usage(FALSE);
signal(SIGINT, onsig);
initscr();
int bg = COLOR_BLACK;
start_color();
#if HAVE_USE_DEFAULT_COLORS
- if (use_default_colors() == OK)
+ if (opt_d && (use_default_colors() == OK))
bg = -1;
#endif
#define SET_COLOR(num, fg) \
- init_pair(num+1, fg, bg); \
- flavor[num] |= COLOR_PAIR(num+1) | A_BOLD
+ init_pair(num+1, (short) fg, (short) bg); \
+ flavor[num] |= (chtype) COLOR_PAIR(num+1) | A_BOLD
SET_COLOR(0, COLOR_GREEN);
SET_COLOR(1, COLOR_RED);
}
#endif /* A_COLOR */
- refs = typeMalloc(short *, LINES);
- for (y = 0; y < LINES; y++) {
- refs[y] = typeMalloc(short, COLS);
+ max_refs = LINES;
+ refs = typeMalloc(int *, (size_t) max_refs);
+ for (y = 0; y < max_refs; y++) {
+ refs[y] = typeMalloc(int, (size_t) COLS);
for (x = 0; x < COLS; x++) {
refs[y][x] = 0;
}
#endif /* BADCORNER */
for (n = number, w = &worm[0]; --n >= 0; w++) {
- w->attrs = flavor[n % SIZEOF(flavor)];
+ w->attrs = flavor[(unsigned) n % SIZEOF(flavor)];
w->orientation = 0;
w->head = 0;
- if (!(ip = typeMalloc(short, (length + 1)))) {
+ if (!(ip = typeMalloc(int, (size_t) (length + 1)))) {
fprintf(stderr, "%s: out of memory\n", *argv);
ExitProgram(EXIT_FAILURE);
}
w->xpos = ip;
for (x = length; --x >= 0;)
*ip++ = -1;
- if (!(ip = typeMalloc(short, (length + 1)))) {
+ if (!(ip = typeMalloc(int, (size_t) (length + 1)))) {
fprintf(stderr, "%s: out of memory\n", *argv);
ExitProgram(EXIT_FAILURE);
}
}
}
}
- USING_WINDOW(stdscr, wrefresh);
+ USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
nodelay(stdscr, TRUE);
- while (!done) {
- int ch;
+#ifdef USE_PTHREADS
+ pthread_mutex_init(&pending_mutex, NULL);
+#endif
- ++sequence;
+ while (!done) {
+ 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"));
cleanup();
-#ifdef NO_LEAKS
- for (y = 0; y < LINES; y++) {
- free(refs[y]);
- }
- free(refs);
- for (n = number, w = &worm[0]; --n >= 0; w++) {
- free(w->xpos);
- free(w->ypos);
- }
-#endif
#ifdef USE_PTHREADS
/*
* Do this just in case one of the threads did not really exit.
for (n = 0; n < number; n++) {
pthread_join(worm[n].thread, NULL);
}
+#endif
+#if NO_LEAKS
+ for (y = 0; y < max_refs; y++) {
+ free(refs[y]);
+ }
+ free(refs);
+ for (n = number, w = &worm[0]; --n >= 0; w++) {
+ free(w->xpos);
+ free(w->ypos);
+ }
#endif
ExitProgram(EXIT_SUCCESS);
}
projects / ncurses.git / blobdiff