X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=test%2Fditto.c;h=a5cec3305646a30ebb32c866c8812aabbbc45e07;hp=4873d0d99ad932ddf2e101c46180723f50257f03;hb=HEAD;hpb=ed530db2c5b10aa19d06104dfe82cf248a813860 diff --git a/test/ditto.c b/test/ditto.c index 4873d0d9..acac8377 100644 --- a/test/ditto.c +++ b/test/ditto.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. * + * Copyright 2018-2022,2023 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 * @@ -29,7 +30,7 @@ /* * Author: Thomas E. Dickey (1998-on) * - * $Id: ditto.c,v 1.26 2008/04/26 23:42:39 tom Exp $ + * $Id: ditto.c,v 1.59 2023/09/23 17:08:43 tom Exp $ * * The program illustrates how to set up multiple screens from a single * program. @@ -43,7 +44,12 @@ */ #include #include -#include + +#if HAVE_DELSCREEN + +#ifdef USE_PTHREADS +#include +#endif #ifdef USE_XTERM_PTY #include USE_OPENPTY_HEADER @@ -74,13 +80,27 @@ typedef struct { FILE *input; FILE *output; SCREEN *screen; /* this screen - curses internal data */ + int which1; /* this screen's index in DITTO[] array */ int length; /* length of windows[] and peeks[] */ char **titles; /* per-window titles */ + WINDOW **parents; /* display boxes around each screen's data */ WINDOW **windows; /* display data from each screen */ PEEK *peeks; /* indices for each screen's fifo */ FIFO fifo; /* fifo for this screen */ +#ifdef USE_PTHREADS + pthread_t thread; +#endif } DITTO; +#ifdef USE_PTHREADS +#define LockIt() pthread_mutex_lock(&pending_mutex) +#define UnlockIt() pthread_mutex_unlock(&pending_mutex) +pthread_mutex_t pending_mutex; +#else +#define LockIt() /* nothing */ +#define UnlockIt() /* nothing */ +#endif + /* * Structure used to pass multiple parameters via the use_screen() * single-parameter interface. @@ -98,13 +118,6 @@ failed(const char *s) ExitProgram(EXIT_FAILURE); } -static void -usage(void) -{ - fprintf(stderr, "usage: ditto [terminal1 ...]\n"); - ExitProgram(EXIT_FAILURE); -} - /* Add to the head of the fifo, checking for overflow. */ static void put_fifo(FIFO * fifo, int value) @@ -129,8 +142,8 @@ peek_fifo(FIFO * fifo, PEEK * peek) { int result = -1; if (peek->sequence < fifo->sequence) { - peek->sequence += 1; result = fifo->data[THIS_FIFO(peek->sequence)]; + peek->sequence += 1; } return result; } @@ -143,25 +156,32 @@ open_tty(char *path) int amaster; int aslave; char slave_name[1024]; - char s_option[1024]; - char *leaf; + char s_option[sizeof(slave_name) + 80]; + const char *xterm_prog = 0; - if (openpty(&amaster, &aslave, slave_name, 0, 0) != 0) + if ((xterm_prog = getenv("XTERM_PROG")) == 0) + xterm_prog = "xterm"; + + if (openpty(&amaster, &aslave, slave_name, 0, 0) != 0 + || strlen(slave_name) > sizeof(slave_name) - 1) failed("openpty"); - if ((leaf = strrchr(slave_name, '/')) == 0) { + if (strrchr(slave_name, '/') == 0) { errno = EISDIR; failed(slave_name); } - sprintf(s_option, "-S%s/%d", slave_name, aslave); + _nc_SPRINTF(s_option, _nc_SLIMIT(sizeof(s_option)) + "-S%s/%d", slave_name, aslave); if (fork()) { - execlp("xterm", "xterm", s_option, "-title", path, (char *) 0); + execlp(xterm_prog, xterm_prog, s_option, "-title", path, (char *) 0); _exit(0); } fp = fdopen(amaster, "r+"); + if (fp == 0) + failed(path); #else struct stat sb; - if (stat(path, &sb) < 0) + if (stat(path, &sb) == -1) failed(path); if ((sb.st_mode & S_IFMT) != S_IFCHR) { errno = ENOTTY; @@ -172,11 +192,16 @@ open_tty(char *path) failed(path); printf("opened %s\n", path); #endif + assert(fp != 0); return fp; } -static void -init_screen(SCREEN *sp GCC_UNUSED, void *arg) +static int +init_screen( +#if HAVE_USE_WINDOW + SCREEN *sp GCC_UNUSED, +#endif + void *arg) { DITTO *target = (DITTO *) arg; int high, wide; @@ -185,11 +210,11 @@ init_screen(SCREEN *sp GCC_UNUSED, void *arg) cbreak(); noecho(); scrollok(stdscr, TRUE); - nodelay(stdscr, TRUE); box(stdscr, 0, 0); - target->windows = typeCalloc(WINDOW *, target->length); - target->peeks = typeCalloc(PEEK, target->length); + target->parents = typeCalloc(WINDOW *, (size_t) target->length); + target->windows = typeCalloc(WINDOW *, (size_t) target->length); + target->peeks = typeCalloc(PEEK, (size_t) target->length); high = (LINES - 2) / target->length; wide = (COLS - 2); @@ -198,31 +223,45 @@ init_screen(SCREEN *sp GCC_UNUSED, void *arg) WINDOW *inner = derwin(outer, high - 2, wide - 2, 1, 1); box(outer, 0, 0); - mvwaddstr(outer, 0, 2, target->titles[k]); + MvWAddStr(outer, 0, 2, target->titles[k]); wnoutrefresh(outer); scrollok(inner, TRUE); - nodelay(inner, TRUE); keypad(inner, TRUE); +#ifndef USE_PTHREADS + nodelay(inner, TRUE); +#endif + target->parents[k] = outer; target->windows[k] = inner; } doupdate(); + return TRUE; +} + +static void +free_screen(DITTO * target) +{ + free(target->parents); + free(target->windows); + free(target->peeks); } static void -open_screen(DITTO * target, char **source, int length, int which) +open_screen(DITTO * target, char **source, int length, int which1) { - if (which != 0) { + if (which1 != 0) { target->input = - target->output = open_tty(source[which]); + target->output = open_tty(source[which1]); } else { target->input = stdin; target->output = stdout; } + target->which1 = which1; target->titles = source; target->length = length; + target->fifo.head = -1; target->screen = newterm((char *) 0, /* assume $TERM is the same */ target->output, target->input); @@ -234,9 +273,15 @@ open_screen(DITTO * target, char **source, int length, int which) } static int -close_screen(SCREEN *sp GCC_UNUSED, void *arg GCC_UNUSED) +close_screen( +#if HAVE_USE_WINDOW + SCREEN *sp GCC_UNUSED, +#endif + void *arg GCC_UNUSED) { +#if HAVE_USE_WINDOW (void) sp; +#endif (void) arg; return endwin(); } @@ -245,7 +290,11 @@ close_screen(SCREEN *sp GCC_UNUSED, void *arg GCC_UNUSED) * Read data from the 'source' screen. */ static int -read_screen(SCREEN *sp GCC_UNUSED, void *arg) +read_screen( +#if HAVE_USE_WINDOW + SCREEN *sp GCC_UNUSED, +#endif + void *arg) { DDATA *data = (DDATA *) arg; DITTO *ditto = &(data->ditto[data->source]); @@ -264,7 +313,11 @@ read_screen(SCREEN *sp GCC_UNUSED, void *arg) * Write all of the data that's in fifos for the 'target' screen. */ static int -write_screen(SCREEN *sp GCC_UNUSED, void *arg GCC_UNUSED) +write_screen( +#if HAVE_USE_WINDOW + SCREEN *sp GCC_UNUSED, +#endif + void *arg GCC_UNUSED) { DDATA *data = (DDATA *) arg; DITTO *ditto = &(data->ditto[data->target]); @@ -280,7 +333,7 @@ write_screen(SCREEN *sp GCC_UNUSED, void *arg GCC_UNUSED) while ((ch = peek_fifo(fifo, peek)) > 0) { changed = TRUE; - waddch(win, ch); + waddch(win, (chtype) ch); wnoutrefresh(win); } } @@ -295,37 +348,115 @@ show_ditto(DITTO * data, int count, DDATA * ddata) { int n; + (void) data; for (n = 0; n < count; n++) { ddata->target = n; USING_SCREEN(data[n].screen, write_screen, (void *) ddata); } } +#ifdef USE_PTHREADS +static void * +handle_screen(void *arg) +{ + DDATA ddata; + + memset(&ddata, 0, sizeof(ddata)); + ddata.ditto = (DITTO *) arg; + ddata.source = ddata.ditto->which1; + ddata.ditto -= ddata.source; /* -> base of array */ + + for (;;) { + int ch = read_screen(ddata.ditto->screen, &ddata); + if (ch == CTRL('D')) { + int later = (ddata.source ? ddata.source : -1); + int j; + + for (j = ddata.ditto->length - 1; j > 0; --j) { + if (j != later) { + pthread_cancel(ddata.ditto[j].thread); + } + } + if (later > 0) { + pthread_cancel(ddata.ditto[later].thread); + } + break; + } + show_ditto(ddata.ditto, ddata.ditto->length, &ddata); + } + return NULL; +} +#endif + +static void +usage(int ok) +{ + static const char *msg[] = + { + "Usage: ditto [terminal [terminal2 ...]]" + ,"" + ,USAGE_COMMON + }; + size_t n; + + for (n = 0; n < SIZEOF(msg); n++) + fprintf(stderr, "%s\n", msg[n]); + + ExitProgram(ok ? EXIT_SUCCESS : EXIT_FAILURE); +} +/* *INDENT-OFF* */ +VERSION_COMMON() +/* *INDENT-ON* */ + int -main(int argc GCC_UNUSED, - char *argv[]GCC_UNUSED) +main(int argc, char *argv[]) { int j; - int count; + int ch; DITTO *data; +#ifndef USE_PTHREADS + int count; +#endif - if (argc <= 1) - usage(); + while ((ch = getopt(argc, argv, OPTS_COMMON)) != -1) { + switch (ch) { + case OPTS_VERSION: + show_version(argv); + ExitProgram(EXIT_SUCCESS); + default: + usage(ch == OPTS_USAGE); + /* NOTREACHED */ + } + } - if ((data = typeCalloc(DITTO, argc)) == 0) + if ((data = typeCalloc(DITTO, (size_t) argc)) == 0) failed("calloc data"); + assert(data != 0); + for (j = 0; j < argc; j++) { open_screen(&data[j], argv, argc, j); } +#ifdef USE_PTHREADS + pthread_mutex_init(&pending_mutex, NULL); + /* + * For multi-threaded operation, set up a reader for each of the screens. + * That uses blocking I/O rather than polling for input, so no calls to + * napms() are needed. + */ + for (j = 0; j < argc; j++) { + (void) pthread_create(&(data[j].thread), NULL, handle_screen, + &data[j]); + } + pthread_join(data[1].thread, NULL); +#else /* * Loop, reading characters from any of the inputs and writing to all * of the screens. */ for (count = 0;; ++count) { DDATA ddata; - int ch; int which = (count % argc); napms(20); @@ -340,11 +471,13 @@ main(int argc GCC_UNUSED, show_ditto(data, argc, &ddata); } } +#endif /* * Cleanup and exit */ for (j = argc - 1; j >= 0; j--) { + LockIt(); USING_SCREEN(data[j].screen, close_screen, 0); fprintf(data[j].output, "**Closed\r\n"); @@ -355,6 +488,17 @@ main(int argc GCC_UNUSED, fflush(data[j].output); fclose(data[j].output); delscreen(data[j].screen); + free_screen(&data[j]); + UnlockIt(); } + free(data); ExitProgram(EXIT_SUCCESS); } +#else +int +main(void) +{ + printf("This program requires the curses delscreen function\n"); + ExitProgram(EXIT_FAILURE); +} +#endif