ncurses 6.2 - patch 20200718
[ncurses.git] / test / worm.c
index ceb4f980070e675d3987d0eced274c3ac2f901b5..6304e4b06a88e750d006bc68a6c52276de1fb968 100644 (file)
@@ -1,3 +1,31 @@
+/****************************************************************************
+ * 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            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
 /*
 
         @@@        @@@    @@@@@@@@@@     @@@@@@@@@@@    @@@@@@@@@@@@
 
                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.21 1998/01/30 10:17:59 tom Exp $
+  $Id: worm.c,v 1.82 2020/02/02 23:34:34 tom Exp $
 */
 
 #include <test.priv.h>
 
-#include <term.h>      /* for tparm() */
+#ifndef NCURSES_VERSION
+#undef TRACE
+#endif
+
+#ifdef USE_PTHREADS
+#include <pthread.h>
+#endif
 
-#include <signal.h>
+WANT_USE_WINDOW();
 
-#define cursor(col,row) move(row,col)
+#define MAX_WORMS      40
+#define MAX_LENGTH     1024
 
-short *ref[128];
-static chtype flavor[]={
-    'O' , '*', '#', '$', '%', '0', '@',
+static chtype flavor[] =
+{
+    'O', '*', '#', '$', '%', '0', '@',
 };
-#define MAXWORMS       (sizeof(flavor)/sizeof(chtype))
-static const short xinc[]={
-     1,  1,  1,  0, -1, -1, -1,  0
-}, yinc[]={
-    -1,  0,  1,  1,  1,  0, -1, -1
+static const int xinc[] =
+{
+    1, 1, 1, 0, -1, -1, -1, 0
+}, yinc[] =
+{
+    -1, 0, 1, 1, 1, 0, -1, -1
 };
-static struct worm {
-    int orientation, head;
-    short *xpos, *ypos;
-} worm[40];
+
+typedef struct worm {
+    int orientation;
+    int head;
+    int *xpos;
+    int *ypos;
+    chtype attrs;
+#ifdef USE_PTHREADS
+    pthread_t thread;
+#endif
+} WORM;
+
+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 int length = 16, number = 3;
+static chtype trail = ' ';
 
+static unsigned pending;
 #ifdef TRACE
-int generation, trace_start, trace_end, singlestep;
+static int generation, trace_start, trace_end;
 #endif /* TRACE */
+/* *INDENT-OFF* */
 static const struct options {
     int nopts;
     int opts[3];
@@ -152,65 +196,330 @@ static const struct options {
     { 0, { 0, 0, 0 } },
     { 0, { 0, 0, 0 } }
 };
+/* *INDENT-ON* */
 
-static RETSIGTYPE onsig(int sig);
-static float ranf(void);
+#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_WINDOW1(stdscr, wrefresh, safe_wrefresh);
+    stop_curses();
+}
+
+static void
+onsig(int sig GCC_UNUSED)
+{
+    cleanup();
+    ExitProgram(EXIT_FAILURE);
+}
+
+static double
+ranf(void)
+{
+    long r = (rand() & 077777);
+    return ((double) r / 32768.);
+}
+
+static int
+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;
+
+    bool done = FALSE;
+
+    if ((x = w->xpos[h = w->head]) < 0) {
+       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)
+       x = last_x;
+    if (y > last_y)
+       y = last_y;
+
+    if (++h == length)
+       h = 0;
+
+    if (w->xpos[w->head = h] >= 0) {
+       int x1, y1;
+       x1 = w->xpos[h];
+       y1 = w->ypos[h];
+       if (y1 < LINES
+           && x1 < COLS
+           && --refs[y1][x1] == 0) {
+           wmove(win, y1, x1);
+           waddch(win, trail);
+       }
+    }
+
+    op = &(x == 0
+          ? (y == 0
+             ? upleft
+             : (y == last_y
+                ? lowleft
+                : left))
+          : (x == last_x
+             ? (y == 0
+                ? upright
+                : (y == last_y
+                   ? lowright
+                   : right))
+             : (y == 0
+                ? upper
+                : (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() * (double) op->nopts)];
+       break;
+    }
+
+    if (!done) {
+       x += xinc[w->orientation];
+       y += yinc[w->orientation];
+       wmove(win, y, x);
+
+       if (y < 0)
+           y = 0;
+       waddch(win, attrs);
+
+       w->ypos[h] = y;
+       w->xpos[h] = x;
+       refs[y][x]++;
+    }
+
+    return done;
+}
+
+#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
+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 (!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 <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(EXIT_FAILURE);
+}
 
 int
 main(int argc, char *argv[])
 {
-int x, y;
-int n;
-struct worm *w;
-const struct options *op;
-int h;
-short *ip;
-int last, bottom;
-
-    for (x=1;x<argc;x++) {
-               register char *p;
-               p=argv[x];
-               if (*p=='-') p++;
-               switch (*p) {
-               case 'f':
-                   field="WORM";
-                   break;
-               case 'l':
-                   if (++x==argc) goto usage;
-                   if ((length=atoi(argv[x]))<2||length>1024) {
-                               fprintf(stderr,"%s: Invalid length\n",*argv);
-                               return EXIT_FAILURE;
-                   }
-                   break;
-               case 'n':
-                   if (++x==argc) goto usage;
-                   if ((number=atoi(argv[x]))<1||number>40) {
-                               fprintf(stderr,"%s: Invalid number of worms\n",*argv);
-                               return EXIT_FAILURE;
-                   }
-                   break;
-               case 't':
-                   trail='.';
-                   break;
+    int ch;
+    int x, y;
+    int n;
+    struct worm *w;
+    int *ip;
+    bool done = FALSE;
+#if HAVE_USE_DEFAULT_COLORS
+    bool opt_d = FALSE;
+#endif
+
+    setlocale(LC_ALL, "");
+
+    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 ((length = atoi(optarg)) < 2 || length > MAX_LENGTH) {
+               fprintf(stderr, "%s: Invalid length\n", *argv);
+               usage();
+           }
+           break;
+       case 'n':
+           if ((number = atoi(optarg)) < 1 || number > MAX_WORMS) {
+               fprintf(stderr, "%s: Invalid number of worms\n", *argv);
+               usage();
+           }
+           break;
+       case 't':
+           trail = '.';
+           break;
 #ifdef TRACE
-               case 'S':
-                   singlestep = TRUE;
-                   break;
-               case 'T':
-                   trace_start = atoi(argv[++x]);
-                   trace_end   = atoi(argv[++x]);
-                   break;
-               case 'N':
-                   _nc_optimize_enable ^= OPTIMIZE_ALL;                /* declared by ncurses */
-                   break;
+       case 'T':
+           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);
-                   return EXIT_FAILURE;
-                   break;
-               }
+       default:
+           usage();
+           /* NOTREACHED */
+       }
     }
+    if (optind < argc)
+       usage();
 
     signal(SIGINT, onsig);
     initscr();
@@ -220,152 +529,144 @@ int last, bottom;
 
     curs_set(0);
 
-    bottom = LINES-1;
-    last = COLS-1;
+    last_y = LINES - 1;
+    last_x = COLS - 1;
 
 #ifdef A_COLOR
-    if (has_colors())
-    {
+    if (has_colors()) {
        int bg = COLOR_BLACK;
        start_color();
-#ifdef NCURSES_VERSION
-       if (use_default_colors() == OK)
+#if HAVE_USE_DEFAULT_COLORS
+       if (opt_d && (use_default_colors() == OK))
            bg = -1;
 #endif
-       init_pair(COLOR_GREEN,   COLOR_GREEN,   bg);
-       init_pair(COLOR_RED,     COLOR_RED,     bg);
-       init_pair(COLOR_CYAN,    COLOR_CYAN,    bg);
-       init_pair(COLOR_WHITE,   COLOR_WHITE,   bg);
-       init_pair(COLOR_MAGENTA, COLOR_MAGENTA, bg);
-       init_pair(COLOR_BLUE,    COLOR_BLUE,    bg);
-       init_pair(COLOR_YELLOW,  COLOR_YELLOW,  bg);
-
-       flavor[0] |= COLOR_PAIR(COLOR_GREEN)   | A_BOLD;
-       flavor[1] |= COLOR_PAIR(COLOR_RED)     | A_BOLD;
-       flavor[2] |= COLOR_PAIR(COLOR_CYAN)    | A_BOLD;
-       flavor[3] |= COLOR_PAIR(COLOR_WHITE)   | A_BOLD;
-       flavor[4] |= COLOR_PAIR(COLOR_MAGENTA) | A_BOLD;
-       flavor[5] |= COLOR_PAIR(COLOR_BLUE)    | A_BOLD;
-       flavor[6] |= COLOR_PAIR(COLOR_YELLOW)  | A_BOLD;
+
+#define SET_COLOR(num, fg) \
+           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);
+       SET_COLOR(2, COLOR_CYAN);
+       SET_COLOR(3, COLOR_WHITE);
+       SET_COLOR(4, COLOR_MAGENTA);
+       SET_COLOR(5, COLOR_BLUE);
+       SET_COLOR(6, COLOR_YELLOW);
     }
 #endif /* A_COLOR */
 
-    ip=(short *)malloc(LINES*COLS*sizeof (short));
-
-    for (n=0;n<LINES;) {
-               ref[n++]=ip; ip+=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;
+       }
     }
-    for (ip=ref[0],n=LINES*COLS;--n>=0;) *ip++=0;
 
 #ifdef BADCORNER
     /* if addressing the lower right corner doesn't work in your curses */
-    ref[bottom][last]=1;
+    refs[last_y][last_x] = 1;
 #endif /* BADCORNER */
 
-    for (n=number, w= &worm[0];--n>=0;w++) {
-               w->orientation=w->head=0;
-               if (!(ip=(short *)malloc((length+1)*sizeof (short)))) {
-                   fprintf(stderr,"%s: out of memory\n",*argv);
-                   return EXIT_FAILURE;
-               }
-               w->xpos=ip;
-               for (x=length;--x>=0;) *ip++ = -1;
-               if (!(ip=(short *)malloc((length+1)*sizeof (short)))) {
-                   fprintf(stderr,"%s: out of memory\n",*argv);
-                   return EXIT_FAILURE;
-               }
-               w->ypos=ip;
-               for (y=length;--y>=0;) *ip++ = -1;
+    for (n = number, w = &worm[0]; --n >= 0; w++) {
+       w->attrs = flavor[(unsigned) n % SIZEOF(flavor)];
+       w->orientation = 0;
+       w->head = 0;
+
+       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(int, (size_t) (length + 1)))) {
+           fprintf(stderr, "%s: out of memory\n", *argv);
+           ExitProgram(EXIT_FAILURE);
+       }
+       w->ypos = ip;
+       for (y = length; --y >= 0;)
+           *ip++ = -1;
     }
     if (field) {
-               register const char *p;
-               p=field;
-               for (y=bottom;--y>=0;) {
-                   for (x=COLS;--x>=0;) {
-                               addch((chtype)(*p++));
-                               if (!*p) p=field;
-                   }
-            addch('\n');
-        }
+       const char *p;
+       p = field;
+       for (y = last_y; --y >= 0;) {
+           for (x = COLS; --x >= 0;) {
+               addch((chtype) (*p++));
+               if (!*p)
+                   p = field;
+           }
+       }
     }
-    refresh();
+    USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
+    nodelay(stdscr, TRUE);
 
-    for (;;) {
+    while (!done) {
+       ++sequence;
+       if ((ch = get_input()) > 0) {
 #ifdef TRACE
-               if (trace_start || trace_end) {
-                   if (generation == trace_start) {
-                       trace(TRACE_CALLS);
-                       getch();
-                   } else if (generation == trace_end) {
-                       trace(0);
-                       getch();
-                   }
-
-                   if (singlestep && generation > trace_start && generation < trace_end)
-                       getch();
-
-                   generation++;
+           if (trace_start || trace_end) {
+               if (generation == trace_start) {
+                   curses_trace(TRACE_CALLS);
+                   get_input();
+               } else if (generation == trace_end) {
+                   curses_trace(0);
+                   get_input();
                }
-#endif /* TRACE */
 
-               for (n=0,w= &worm[0];n<number;n++,w++) {
-                   if ((x=w->xpos[h=w->head])<0) {
-                               cursor(x=w->xpos[h]=0,y=w->ypos[h]=bottom);
-                               addch(flavor[n % MAXWORMS]);
-                               ref[y][x]++;
-                   }
-                   else y=w->ypos[h];
-                   if (++h==length) h=0;
-                   if (w->xpos[w->head=h]>=0) {
-                               register int x1, y1;
-                               x1=w->xpos[h]; y1=w->ypos[h];
-                               if (--ref[y1][x1]==0) {
-                                   cursor(x1,y1); addch(trail);
-                               }
-                   }
-            op= &(x==0 ? (y==0 ? upleft : (y==bottom ? lowleft : left)) :
-                (x==last ? (y==0 ? upright : (y==bottom ? lowright : right)) :
-                       (y==0 ? upper : (y==bottom ? lower : normal))))[w->orientation];
-                   switch (op->nopts) {
-                   case 0:
-                               refresh();
-                               curs_set(1);
-                               endwin();
-                               return EXIT_SUCCESS;
-                   case 1:
-                               w->orientation=op->opts[0];
-                               break;
-                   default:
-                               w->orientation=op->opts[(int)(ranf()*(float)op->nopts)];
-                   }
-                   cursor(x+=xinc[w->orientation], y+=yinc[w->orientation]);
-
-                   if (y < 0 ) y = 0;
-                   addch(flavor[n % MAXWORMS]);
-                   ref[w->ypos[h]=y][w->xpos[h]=x]++;
-               }
-               refresh();
-    }
-}
+               generation++;
+           }
+#endif
 
-static RETSIGTYPE
-onsig(int sig GCC_UNUSED)
-{
-       standend();
-       refresh();
-       curs_set(1);
-       endwin();
-       exit(EXIT_FAILURE);
-}
+#ifdef KEY_RESIZE
+           if (ch == KEY_RESIZE) {
+               USING_WINDOW(stdscr, update_refs);
+           }
+#endif
 
-static float
-ranf(void)
-{
-float rv;
-long r = rand();
+           /*
+            * 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);
+           } else if (ch == ' ') {
+               nodelay(stdscr, TRUE);
+           }
+       }
+
+       done = draw_all_worms();
+       napms(10);
+       USING_WINDOW1(stdscr, wrefresh, safe_wrefresh);
+    }
 
-    r &= 077777;
-    rv =((float)r/32767.);
-    return rv;
+    Trace(("Cleanup"));
+    cleanup();
+#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
+#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);
 }