X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Fworm.c;h=c3fc0da822ef2619246c5ed831c0d9eb9bee48af;hp=ba54ba825539fd1f4fe8ea943dd7d0014b6204dd;hb=21c8ffa0edf2e389f3f674f0c08009002c6f357d;hpb=3a9b6a3bf0269231bef7de74757a910dedd04e0c;ds=sidebyside diff --git a/test/worm.c b/test/worm.c index ba54ba82..c3fc0da8 100644 --- a/test/worm.c +++ b/test/worm.c @@ -1,3 +1,30 @@ +/**************************************************************************** + * Copyright (c) 1998-2012,2013 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. * + ****************************************************************************/ /* @@@ @@@ @@@@@@@@@@ @@@@@@@@@@@ @@@@@@@@@@@@ @@ -34,39 +61,59 @@ Options: 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.20 1997/05/03 18:38:57 tom Exp $ + $Id: worm.c,v 1.65 2013/06/22 20:01:41 tom Exp $ */ #include -#include /* for tparm() */ +#ifdef USE_PTHREADS +#include +#endif -#include +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 **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,64 +199,284 @@ static const struct options { { 0, { 0, 0, 0 } }, { 0, { 0, 0, 0 } } }; +/* *INDENT-ON* */ + +static void +failed(const char *s) +{ + perror(s); + endwin(); + ExitProgram(EXIT_FAILURE); +} + +static void +cleanup(void) +{ + USING_WINDOW(stdscr, wrefresh); + curs_set(1); + endwin(); +} + +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; + 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 |= (1 << bitnum); + napms(10); /* let the other thread(s) have a chance */ + pending &= ~(1 << bitnum); + return quitting; +} + +static void * +start_worm(void *arg) +{ + unsigned long compare = 0; + Trace(("start_worm")); + while (!quit_worm(((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 RETSIGTYPE onsig(int sig); -static float ranf(void); +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_WINDOW(stdscr, wgetch); + return ch; +} + +#ifdef KEY_RESIZE +static int +update_refs(WINDOW *win) +{ + int x, y; + + (void) win; + 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]); + 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 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;x1024) { - 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 x, y; + int n; + struct worm *w; + int *ip; + bool done = FALSE; + int max_refs; + + setlocale(LC_ALL, ""); + + for (x = 1; x < argc; x++) { + 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 > MAX_LENGTH) { + fprintf(stderr, "%s: Invalid length\n", *argv); + ExitProgram(EXIT_FAILURE); + } + break; + case 'n': + if (++x == argc) + goto usage; + if ((number = atoi(argv[x])) < 1 || number > MAX_WORMS) { + fprintf(stderr, "%s: Invalid number of worms\n", *argv); + ExitProgram(EXIT_FAILURE); + } + 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': + trace_start = atoi(argv[++x]); + trace_end = atoi(argv[++x]); + 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: + fprintf(stderr, + "usage: %s [-field] [-length #] [-number #] [-trail]\n", *argv); + ExitProgram(EXIT_FAILURE); + } } signal(SIGINT, onsig); @@ -220,152 +487,145 @@ 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 HAVE_USE_DEFAULT_COLORS if (use_default_colors() == OK) bg = -1; #endif - - init_pair(COLOR_GREEN, COLOR_GREEN, -1); - init_pair(COLOR_RED, COLOR_RED, -1); - init_pair(COLOR_CYAN, COLOR_CYAN, -1); - init_pair(COLOR_WHITE, COLOR_WHITE, -1); - init_pair(COLOR_MAGENTA, COLOR_MAGENTA, -1); - init_pair(COLOR_BLUE, COLOR_BLUE, -1); - init_pair(COLOR_YELLOW, COLOR_YELLOW, -1); - - 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=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_WINDOW(stdscr, wrefresh); + nodelay(stdscr, TRUE); + + while (!done) { + int ch; - for (;;) { + ++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) { + trace(TRACE_CALLS); + get_input(); + } else if (generation == trace_end) { + trace(0); + get_input(); } -#endif /* TRACE */ - for (n=0,w= &worm[0];nxpos[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; + continue; + } else if (ch == 's') { + nodelay(stdscr, FALSE); + } else if (ch == ' ') { + nodelay(stdscr, TRUE); + } + } + + done = draw_all_worms(); + napms(10); + USING_WINDOW(stdscr, wrefresh); + } - r &= 077777; - rv =((float)r/32767.); - return rv; + Trace(("Cleanup")); + cleanup(); +#ifdef 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); }