ncurses 6.1 - patch 20180303

[ncurses.git] / test / worm.c

diff --git a/test/worm.c b/test/worm.c
index 2029b34f9e3cefdd00d0c3d4a03ef3b88baf103a..2e31638d302e203613491bf436d681a07b6b627d 100644 (file)
--- a/test/worm.c
+++ b/test/worm.c
@@ -1,5 +1,5 @@
 /****************************************************************************
 /****************************************************************************

- * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
+ * Copyright (c) 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            *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *


@@ -47,25 +47,20 @@
 
                July 1995 (esr): worms is now in living color! :-)
 
 
                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.
 
   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.76 2017/11/18 22:41:08 tom Exp $

 */
 
 #include <test.priv.h>
 
 */
 
 #include <test.priv.h>
 

+#ifndef NCURSES_VERSION
+#undef TRACE
+#endif
+

 #ifdef USE_PTHREADS
 #include <pthread.h>
 #endif
 #ifdef USE_PTHREADS
 #include <pthread.h>
 #endif


@@ -79,7 +74,7 @@ static chtype flavor[] =
 {
     'O', '*', '#', '$', '%', '0', '@',
 };
 {
     'O', '*', '#', '$', '%', '0', '@',
 };

-static const short xinc[] =
+static const int xinc[] =

 {
     1, 1, 1, 0, -1, -1, -1, 0
 }, yinc[] =
 {
     1, 1, 1, 0, -1, -1, -1, 0
 }, yinc[] =


@@ -90,8 +85,8 @@ static const short xinc[] =
 typedef struct worm {
     int orientation;
     int head;
 typedef struct worm {
     int orientation;
     int head;

-    short *xpos;
-    short *ypos;
+    int *xpos;
+    int *ypos;

     chtype attrs;
 #ifdef USE_PTHREADS
     pthread_t thread;
     chtype attrs;
 #ifdef USE_PTHREADS
     pthread_t thread;


@@ -102,7 +97,8 @@ static unsigned long sequence = 0;
 static bool quitting = FALSE;
 
 static WORM worm[MAX_WORMS];
 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 int last_x, last_y;
 
 static const char *field;


@@ -201,26 +197,35 @@ static const struct options {
 };
 /* *INDENT-ON* */
 
 };
 /* *INDENT-ON* */
 

+#ifdef KEY_RESIZE
+static void
+failed(const char *s)
+{
+    perror(s);
+    exit_curses();
+    ExitProgram(EXIT_FAILURE);
+}
+#endif
+

 static void
 cleanup(void)
 {
     USING_WINDOW(stdscr, wrefresh);
 static void
 cleanup(void)
 {
     USING_WINDOW(stdscr, wrefresh);

-    curs_set(1);
-    endwin();
+    exit_curses();

 }
 
 }
 

-static RETSIGTYPE
+static void

 onsig(int sig GCC_UNUSED)
 {
     cleanup();
     ExitProgram(EXIT_FAILURE);
 }
 
 onsig(int sig GCC_UNUSED)
 {
     cleanup();
     ExitProgram(EXIT_FAILURE);
 }
 

-static float
+static double

 ranf(void)
 {
     long r = (rand() & 077777);
 ranf(void)
 {
     long r = (rand() & 077777);

-    return ((float) r / 32768.);
+    return ((double) r / 32768.);

 }
 
 static int
 }
 
 static int


@@ -228,7 +233,7 @@ draw_worm(WINDOW *win, void *data)
 {
     WORM *w = (WORM *) data;
     const struct options *op;
 {
     WORM *w = (WORM *) data;
     const struct options *op;

-    unsigned mask = ~(1 << (w - worm));
+    unsigned mask = (unsigned) (~(1 << (w - worm)));

     chtype attrs = w->attrs | ((mask & pending) ? A_REVERSE : 0);
 
     int x;
     chtype attrs = w->attrs | ((mask & pending) ? A_REVERSE : 0);
 
     int x;


@@ -286,12 +291,13 @@ draw_worm(WINDOW *win, void *data)
     switch (op->nopts) {
     case 0:
        done = TRUE;
     switch (op->nopts) {
     case 0:
        done = TRUE;

+       Trace(("done - draw_worm"));

        break;
     case 1:
        w->orientation = op->opts[0];
        break;
     default:
        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;
     }
 
        break;
     }
 


@@ -316,9 +322,9 @@ draw_worm(WINDOW *win, void *data)
 static bool
 quit_worm(int bitnum)
 {
 static bool
 quit_worm(int bitnum)
 {

-    pending |= (1 << bitnum);
+    pending = (pending | (unsigned) (1 << bitnum));

     napms(10);                 /* let the other thread(s) have a chance */
     napms(10);                 /* let the other thread(s) have a chance */

-    pending &= ~(1 << bitnum);
+    pending = (pending & (unsigned) ~(1 << bitnum));

     return quitting;
 }
 
     return quitting;
 }
 


@@ -327,10 +333,14 @@ start_worm(void *arg)
 {
     unsigned long compare = 0;
     Trace(("start_worm"));
 {
     unsigned long compare = 0;
     Trace(("start_worm"));

-    while (!quit_worm(((struct worm *) arg) - worm)) {
+    while (!quit_worm((int) (((struct worm *) arg) - worm))) {

        while (compare < sequence) {
            ++compare;
        while (compare < sequence) {
            ++compare;

+#if HAVE_USE_WINDOW

            use_window(stdscr, draw_worm, arg);
            use_window(stdscr, draw_worm, arg);

+#else
+           draw_worm(stdscr, arg);
+#endif

        }
     }
     Trace(("...start_worm (done)"));
        }
     }
     Trace(("...start_worm (done)"));


@@ -350,13 +360,18 @@ draw_all_worms(void)
     if (first) {
        first = FALSE;
        for (n = 0, w = &worm[0]; n < number; n++, w++) {
     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
     for (n = 0, w = &worm[0]; n < number; n++, w++) {
        }
     }
 #else
     for (n = 0, w = &worm[0]; n < number; n++, w++) {

-       if (USING_WINDOW2(stdscr, draw_worm, w))
+       if (
+#if HAVE_USE_WINDOW
+              USING_WINDOW2(stdscr, draw_worm, w)
+#else
+              draw_worm(stdscr, w)
+#endif
+           )

            done = TRUE;
     }
 #endif
            done = TRUE;
     }
 #endif


@@ -380,7 +395,9 @@ update_refs(WINDOW *win)
     (void) win;
     if (last_x != COLS - 1) {
        for (y = 0; y <= last_y; y++) {
     (void) win;
     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;
        }
            for (x = last_x + 1; x < COLS; x++)
                refs[y][x] = 0;
        }


@@ -389,9 +406,12 @@ update_refs(WINDOW *win)
     if (last_y != LINES - 1) {
        for (y = LINES; y <= last_y; y++)
            free(refs[y]);
     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++) {
        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;
        }
            for (x = 0; x < COLS; x++)
                refs[y][x] = 0;
        }


@@ -401,40 +421,69 @@ update_refs(WINDOW *win)
 }
 #endif
 
 }
 #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
 main(int argc, char *argv[])
 {

+    int ch;

     int x, y;
     int n;
     struct worm *w;
     int x, y;
     int n;
     struct worm *w;

-    short *ip;
+    int *ip;

     bool done = FALSE;
     bool done = FALSE;

+#if HAVE_USE_DEFAULT_COLORS
+    bool opt_d = FALSE;
+#endif

 
     setlocale(LC_ALL, "");
 
 
     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':
        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);
                fprintf(stderr, "%s: Invalid length\n", *argv);

-               ExitProgram(EXIT_FAILURE);
+               usage();

            }
            break;
        case 'n':
            }
            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);
                fprintf(stderr, "%s: Invalid number of worms\n", *argv);

-               ExitProgram(EXIT_FAILURE);
+               usage();

            }
            break;
        case 't':
            }
            break;
        case 't':


@@ -442,20 +491,20 @@ main(int argc, char *argv[])
            break;
 #ifdef TRACE
        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();

            break;
        case 'N':
            _nc_optimize_enable ^= OPTIMIZE_ALL;        /* declared by ncurses */
            break;
 #endif /* TRACE */
        default:
            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();
 
     signal(SIGINT, onsig);
     initscr();


@@ -473,13 +522,13 @@ main(int argc, char *argv[])
        int bg = COLOR_BLACK;
        start_color();
 #if HAVE_USE_DEFAULT_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) \
            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);
 
        SET_COLOR(0, COLOR_GREEN);
        SET_COLOR(1, COLOR_RED);


@@ -491,9 +540,10 @@ main(int argc, char *argv[])
     }
 #endif /* A_COLOR */
 
     }
 #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;
        }
        for (x = 0; x < COLS; x++) {
            refs[y][x] = 0;
        }


@@ -505,18 +555,18 @@ main(int argc, char *argv[])
 #endif /* BADCORNER */
 
     for (n = number, w = &worm[0]; --n >= 0; w++) {
 #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;
 
        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;
            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);
        }
            fprintf(stderr, "%s: out of memory\n", *argv);
            ExitProgram(EXIT_FAILURE);
        }


@@ -539,8 +589,6 @@ main(int argc, char *argv[])
     nodelay(stdscr, TRUE);
 
     while (!done) {
     nodelay(stdscr, TRUE);
 
     while (!done) {

-       int ch;
-

        ++sequence;
        if ((ch = get_input()) > 0) {
 #ifdef TRACE
        ++sequence;
        if ((ch = get_input()) > 0) {
 #ifdef TRACE


@@ -570,6 +618,7 @@ main(int argc, char *argv[])
            if (ch == 'q') {
                quitting = TRUE;
                done = TRUE;
            if (ch == 'q') {
                quitting = TRUE;
                done = TRUE;

+               Trace(("done - quitting"));

                continue;
            } else if (ch == 's') {
                nodelay(stdscr, FALSE);
                continue;
            } else if (ch == 's') {
                nodelay(stdscr, FALSE);


@@ -585,8 +634,8 @@ main(int argc, char *argv[])
 
     Trace(("Cleanup"));
     cleanup();
 
     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);
        free(refs[y]);
     }
     free(refs);