X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Fworm.c;h=ea407a0c0606827ff629205bfdde8358677ade63;hp=651ccc15fba59d074e78038752417b8850b39d9c;hb=25358bc041a5566ce2de4c9c792837e552b35671;hpb=46722468f47c2b77b3987729b4bcf2321cccfd01 diff --git a/test/worm.c b/test/worm.c index 651ccc15..ea407a0c 100644 --- a/test/worm.c +++ b/test/worm.c @@ -1,3 +1,30 @@ +/**************************************************************************** + * Copyright (c) 1998-2007,2008 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,11 +61,15 @@ 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.37 2002/06/29 23:32:18 tom Exp $ + $Id: worm.c,v 1.53 2008/01/19 20:56:38 tom Exp $ */ #include +#ifdef USE_PTHREADS +#include +#endif + static chtype flavor[] = { 'O', '*', '#', '$', '%', '0', '@', @@ -50,17 +81,30 @@ static const short xinc[] = { -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; + short *xpos; + short *ypos; + chtype attrs; +#ifdef USE_PTHREADS + pthread_t thread; +#endif +} WORM; + +static unsigned long sequence = 0; +static bool quitting = FALSE; + +static WORM worm[40]; +static short **refs; static const char *field; static int length = 16, number = 3; static chtype trail = ' '; #ifdef TRACE -int generation, trace_start, trace_end, singlestep; +static int generation, trace_start, trace_end; #endif /* TRACE */ /* *INDENT-OFF* */ static const struct options { @@ -173,17 +217,172 @@ ranf(void) return ((float) r / 32768.); } +static int +draw_worm(WINDOW *win, void *data) +{ + WORM *w = (WORM *) data; + const struct options *op; + + 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); + refs[y][x]++; + } else { + y = w->ypos[h]; + } + + if (x > last) + x = last; + if (y > bottom) + y = bottom; + + 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 == 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: + done = TRUE; + break; + case 1: + w->orientation = op->opts[0]; + break; + default: + w->orientation = op->opts[(int) (ranf() * (float) op->nopts)]; + break; + } + + if (!done) { + x += xinc[w->orientation]; + y += yinc[w->orientation]; + wmove(win, y, x); + + if (y < 0) + y = 0; + waddch(win, w->attrs); + + w->ypos[h] = y; + w->xpos[h] = x; + refs[y][x]++; + } + + return done; +} + +#if !defined(NCURSES_VERSION_PATCH) || (NCURSES_VERSION_PATCH < 20070915) || !NCURSES_EXT_FUNCS +static int +use_window(WINDOW *win, int (*func) (WINDOW *, void *), void *data) +{ + return func(win, data); +} +#endif + +#ifdef USE_PTHREADS +static bool +quit_worm(void) +{ + napms(10); /* let the other thread(s) have a chance */ + return quitting; +} + +static void * +start_worm(void *arg) +{ + unsigned long compare = 0; + while (!quit_worm()) { + while (compare < sequence) { + ++compare; + use_window(stdscr, draw_worm, arg); + } + } + 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++) { + int rc; + rc = pthread_create(&(w->thread), NULL, start_worm, w); + } + } +#else + for (n = 0, w = &worm[0]; n < number; n++, w++) { + if (use_window(stdscr, draw_worm, w)) + done = TRUE; + } +#endif + return done; +} + +static int +get_input(void) +{ + int ch; +#ifdef USE_PTHREADS + ch = use_window(stdscr, (NCURSES_CALLBACK) wgetch, stdscr); +#else + ch = getch(); +#endif + return ch; +} + int main(int argc, char *argv[]) { - short **ref; int x, y; int n; struct worm *w; - const struct options *op; - int h; short *ip; int last, bottom; + bool done = FALSE; setlocale(LC_ALL, ""); @@ -216,9 +415,6 @@ main(int argc, char *argv[]) trail = '.'; break; #ifdef TRACE - case 'S': - singlestep = TRUE; - break; case 'T': trace_start = atoi(argv[++x]); trace_end = atoi(argv[++x]); @@ -269,21 +465,24 @@ main(int argc, char *argv[]) } #endif /* A_COLOR */ - ref = typeMalloc(short *, LINES); + refs = typeMalloc(short *, LINES); for (y = 0; y < LINES; y++) { - ref[y] = typeMalloc(short, COLS); + refs[y] = typeMalloc(short, COLS); for (x = 0; x < COLS; x++) { - ref[y][x] = 0; + refs[y][x] = 0; } } #ifdef BADCORNER /* if addressing the lower right corner doesn't work in your curses */ - ref[bottom][last] = 1; + refs[bottom][last] = 1; #endif /* BADCORNER */ for (n = number, w = &worm[0]; --n >= 0; w++) { - w->orientation = w->head = 0; + w->attrs = flavor[n % SIZEOF(flavor)]; + w->orientation = 0; + w->head = 0; + if (!(ip = typeMalloc(short, (length + 1)))) { fprintf(stderr, "%s: out of memory\n", *argv); ExitProgram(EXIT_FAILURE); @@ -310,50 +509,45 @@ main(int argc, char *argv[]) } } } - napms(10); refresh(); -#ifndef TRACE nodelay(stdscr, TRUE); -#endif - for (;;) { -#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++; - } -#else + 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); + get_input(); + } else if (generation == trace_end) { + trace(0); + get_input(); + } + + generation++; + } +#endif #ifdef KEY_RESIZE if (ch == KEY_RESIZE) { if (last != COLS - 1) { for (y = 0; y <= bottom; y++) { - ref[y] = typeRealloc(short, COLS, ref[y]); + refs[y] = typeRealloc(short, COLS, refs[y]); for (x = last + 1; x < COLS; x++) - ref[y][x] = 0; + refs[y][x] = 0; } last = COLS - 1; } if (bottom != LINES - 1) { for (y = LINES; y <= bottom; y++) - free(ref[y]); - ref = typeRealloc(short *, LINES, ref); + free(refs[y]); + refs = typeRealloc(short *, LINES, refs); for (y = bottom + 1; y < LINES; y++) { - ref[y] = typeMalloc(short, COLS); + refs[y] = typeMalloc(short, COLS); for (x = 0; x < COLS; x++) - ref[y][x] = 0; + refs[y][x] = 0; } bottom = LINES - 1; } @@ -361,67 +555,42 @@ main(int argc, char *argv[]) #endif /* * Make it simple to put this into single-step mode, or resume - * normal operation -TD + * normal operation -T.Dickey */ if (ch == 'q') { - cleanup(); - ExitProgram(EXIT_SUCCESS); + quitting = TRUE; + done = TRUE; + continue; } else if (ch == 's') { nodelay(stdscr, FALSE); } else if (ch == ' ') { nodelay(stdscr, TRUE); } } -#endif /* TRACE */ - - for (n = 0, w = &worm[0]; n < number; n++, w++) { - if ((x = w->xpos[h = w->head]) < 0) { - move(y = w->ypos[h] = bottom, x = w->xpos[h] = 0); - addch(flavor[n % SIZEOF(flavor)]); - ref[y][x]++; - } else { - y = w->ypos[h]; - } - if (x > last) - x = last; - if (y > bottom) - y = bottom; - 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 - && --ref[y1][x1] == 0) { - move(y1, x1); - 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: - cleanup(); - ExitProgram(EXIT_SUCCESS); - case 1: - w->orientation = op->opts[0]; - break; - default: - w->orientation = op->opts[(int) (ranf() * (float) op->nopts)]; - } - move(y += yinc[w->orientation], x += xinc[w->orientation]); - if (y < 0) - y = 0; - addch(flavor[n % SIZEOF(flavor)]); - ref[w->ypos[h] = y][w->xpos[h] = x]++; - } + done = draw_all_worms(); napms(10); refresh(); } + + 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 + ExitProgram(EXIT_SUCCESS); }