X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Fworm.c;h=6304e4b06a88e750d006bc68a6c52276de1fb968;hp=4692668bdcfe6f43fcf4925ce641e0a1b04a431d;hb=cf6a62567b2365c8678b7d561845bdbd1739e5da;hpb=e79c0691e5b41f07305fe0d73132673251a93efd diff --git a/test/worm.c b/test/worm.c index 4692668b..6304e4b0 100644 --- a/test/worm.c +++ b/test/worm.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998-2006,2007 Free Software Foundation, Inc. * + * Copyright 2018-2019,2020 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 * @@ -47,30 +48,34 @@ July 1995 (esr): worms is now in living color! :-) -Options: - -f fill screen with copies of 'WORM' at start. - -l set worm length - -n set number of worms - -t make worms leave droppings - -T 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.48 2007/09/15 21:42:16 tom Exp $ + $Id: worm.c,v 1.82 2020/02/02 23:34:34 tom Exp $ */ #include +#ifndef NCURSES_VERSION +#undef TRACE +#endif + +#ifdef USE_PTHREADS +#include +#endif + +WANT_USE_WINDOW(); + +#define MAX_WORMS 40 +#define MAX_LENGTH 1024 + static chtype flavor[] = { 'O', '*', '#', '$', '%', '0', '@', }; -static const short xinc[] = +static const int xinc[] = { 1, 1, 1, 0, -1, -1, -1, 0 }, yinc[] = @@ -81,18 +86,27 @@ static const short xinc[] = typedef struct worm { int orientation; int head; - short *xpos; - short *ypos; + int *xpos; + int *ypos; chtype attrs; +#ifdef USE_PTHREADS + pthread_t thread; +#endif } WORM; -static WORM worm[40]; -static short **refs; +static unsigned long sequence = 0; +static bool quitting = FALSE; + +static WORM worm[MAX_WORMS]; +static int max_refs; +static int **refs; +static int last_x, last_y; static const char *field; static int length = 16, number = 3; static chtype trail = ' '; +static unsigned pending; #ifdef TRACE static int generation, trace_start, trace_end; #endif /* TRACE */ @@ -184,27 +198,48 @@ static const struct options { }; /* *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) { - standend(); - refresh(); - 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 @@ -212,28 +247,27 @@ draw_worm(WINDOW *win, void *data) { WORM *w = (WORM *) data; const struct options *op; + unsigned mask = (unsigned) (~(1 << (w - worm))); + chtype attrs = w->attrs | ((mask & pending) ? A_REVERSE : 0); int x; int y; int h; - int bottom = LINES - 1; - int last = COLS - 1; - bool done = FALSE; if ((x = w->xpos[h = w->head]) < 0) { - wmove(win, y = w->ypos[h] = bottom, x = w->xpos[h] = 0); - waddch(win, w->attrs); + wmove(win, y = w->ypos[h] = last_y, x = w->xpos[h] = 0); + waddch(win, attrs); refs[y][x]++; } else { y = w->ypos[h]; } - if (x > last) - x = last; - if (y > bottom) - y = bottom; + if (x > last_x) + x = last_x; + if (y > last_y) + y = last_y; if (++h == length) h = 0; @@ -253,30 +287,31 @@ draw_worm(WINDOW *win, void *data) op = &(x == 0 ? (y == 0 ? upleft - : (y == bottom + : (y == last_y ? lowleft : left)) - : (x == last + : (x == last_x ? (y == 0 ? upright - : (y == bottom + : (y == last_y ? lowright : right)) : (y == 0 ? upper - : (y == bottom + : (y == last_y ? lower : normal))))[w->orientation]; 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; } @@ -287,7 +322,7 @@ draw_worm(WINDOW *win, void *data) if (y < 0) y = 0; - waddch(win, w->attrs); + waddch(win, attrs); w->ypos[h] = y; w->xpos[h] = x; @@ -297,49 +332,173 @@ draw_worm(WINDOW *win, void *data) return done; } -#if !defined(NCURSES_VERSION_PATCH) || (NCURSES_VERSION_PATCH < 20070915) +#ifdef USE_PTHREADS +static bool +quit_worm(int bitnum) +{ + pending = (pending | (unsigned) (1 << bitnum)); + napms(10); /* let the other thread(s) have a chance */ + pending = (pending & (unsigned) ~(1 << bitnum)); + return quitting; +} + +static void * +start_worm(void *arg) +{ + unsigned long compare = 0; + Trace(("start_worm")); + 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 + } + } + Trace(("...start_worm (done)")); + return NULL; +} +#endif + +static bool +draw_all_worms(void) +{ + bool done = FALSE; + int n; + struct worm *w; + +#ifdef USE_PTHREADS + static bool first = TRUE; + if (first) { + first = FALSE; + for (n = 0, w = &worm[0]; n < number; n++, w++) { + (void) pthread_create(&(w->thread), NULL, start_worm, w); + } + } +#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 + ) + done = TRUE; + } +#endif + return done; +} + +static int +get_input(void) +{ + int ch; + ch = USING_WINDOW1(stdscr, wgetch, safe_wgetch); + return ch; +} + +#ifdef KEY_RESIZE static int -use_window(WINDOW *win, int (*func)(WINDOW *, void *), void *data) +update_refs(WINDOW *win, void *data) { - return func(win, 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 (!refs[y]) + failed("update_refs"); + for (x = last_x + 1; x < COLS; x++) + refs[y][x] = 0; + } + last_x = COLS - 1; + } + 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); + if (!refs[y]) + failed("update_refs"); + for (x = 0; x < COLS; x++) + refs[y][x] = 0; + } + last_y = LINES - 1; + } + return OK; } #endif +static void +usage(void) +{ + static const char *msg[] = + { + "Usage: worm [options]" + ,"" + ,"Options:" +#if HAVE_USE_DEFAULT_COLORS + ," -d invoke use_default_colors" +#endif + ," -f fill screen with copies of \"WORM\" at start" + ," -l set length of worms" + ," -n set number of worms" + ," -t leave trail of \".\"" +#ifdef TRACE + ," -T , 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(EXIT_FAILURE); +} + int main(int argc, char *argv[]) { + int ch; int x, y; int n; struct worm *w; - short *ip; - int last, bottom; + 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, "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 > 1024) { + if ((length = atoi(optarg)) < 2 || length > MAX_LENGTH) { fprintf(stderr, "%s: Invalid length\n", *argv); - ExitProgram(EXIT_FAILURE); + usage(); } break; case 'n': - if (++x == argc) - goto usage; - if ((number = atoi(argv[x])) < 1 || number > 40) { + if ((number = atoi(optarg)) < 1 || number > MAX_WORMS) { fprintf(stderr, "%s: Invalid number of worms\n", *argv); - ExitProgram(EXIT_FAILURE); + usage(); } break; case 't': @@ -347,20 +506,20 @@ main(int argc, char *argv[]) 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(); break; case 'N': _nc_optimize_enable ^= OPTIMIZE_ALL; /* declared by ncurses */ break; #endif /* TRACE */ default: - usage: - fprintf(stderr, - "usage: %s [-field] [-length #] [-number #] [-trail]\n", *argv); - ExitProgram(EXIT_FAILURE); + usage(); + /* NOTREACHED */ } } + if (optind < argc) + usage(); signal(SIGINT, onsig); initscr(); @@ -370,21 +529,21 @@ main(int argc, char *argv[]) curs_set(0); - bottom = LINES - 1; - last = COLS - 1; + last_y = LINES - 1; + last_x = COLS - 1; #ifdef A_COLOR if (has_colors()) { 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); @@ -396,9 +555,10 @@ main(int argc, char *argv[]) } #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; } @@ -406,22 +566,22 @@ main(int argc, char *argv[]) #ifdef BADCORNER /* if addressing the lower right corner doesn't work in your curses */ - refs[bottom][last] = 1; + refs[last_y][last_x] = 1; #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); } @@ -432,7 +592,7 @@ main(int argc, char *argv[]) if (field) { const char *p; p = field; - for (y = bottom; --y >= 0;) { + for (y = last_y; --y >= 0;) { for (x = COLS; --x >= 0;) { addch((chtype) (*p++)); if (!*p) @@ -440,56 +600,40 @@ main(int argc, char *argv[]) } } } - napms(10); - refresh(); + USING_WINDOW1(stdscr, wrefresh, safe_wrefresh); nodelay(stdscr, TRUE); while (!done) { - int ch; - - if ((ch = getch()) > 0) { + ++sequence; + if ((ch = get_input()) > 0) { #ifdef TRACE if (trace_start || trace_end) { if (generation == trace_start) { - trace(TRACE_CALLS); - getch(); + curses_trace(TRACE_CALLS); + get_input(); } else if (generation == trace_end) { - trace(0); - getch(); + curses_trace(0); + get_input(); } generation++; } #endif + #ifdef KEY_RESIZE if (ch == KEY_RESIZE) { - if (last != COLS - 1) { - for (y = 0; y <= bottom; y++) { - refs[y] = typeRealloc(short, COLS, refs[y]); - for (x = last + 1; x < COLS; x++) - refs[y][x] = 0; - } - last = COLS - 1; - } - if (bottom != LINES - 1) { - for (y = LINES; y <= bottom; y++) - free(refs[y]); - refs = typeRealloc(short *, LINES, refs); - for (y = bottom + 1; y < LINES; y++) { - refs[y] = typeMalloc(short, COLS); - for (x = 0; x < COLS; x++) - refs[y][x] = 0; - } - bottom = LINES - 1; - } + USING_WINDOW(stdscr, update_refs); } #endif + /* * Make it simple to put this into single-step mode, or resume * normal operation -T.Dickey */ if (ch == 'q') { + quitting = TRUE; done = TRUE; + Trace(("done - quitting")); continue; } else if (ch == 's') { nodelay(stdscr, FALSE); @@ -498,17 +642,15 @@ main(int argc, char *argv[]) } } - for (n = 0, w = &worm[0]; n < number; n++, w++) { - if (use_window(stdscr, draw_worm, w)) - done = TRUE; - } + done = draw_all_worms(); napms(10); - refresh(); + USING_WINDOW1(stdscr, wrefresh, safe_wrefresh); } + Trace(("Cleanup")); cleanup(); -#ifdef NO_LEAKS - for (y = 0; y < LINES; y++) { +#if NO_LEAKS + for (y = 0; y < max_refs; y++) { free(refs[y]); } free(refs); @@ -516,6 +658,15 @@ main(int argc, char *argv[]) free(w->xpos); free(w->ypos); } +#endif +#ifdef USE_PTHREADS + /* + * Do this just in case one of the threads did not really exit. + */ + Trace(("join all threads")); + for (n = 0; n < number; n++) { + pthread_join(worm[n].thread, NULL); + } #endif ExitProgram(EXIT_SUCCESS); }