

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: ditto.c</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>/****************************************************************************
 * Copyright (c) 1998-2011,2012 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            *
 * &quot;Software&quot;), 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 &quot;AS IS&quot;, 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.                                                           *
 ****************************************************************************/

/*
 * Author: Thomas E. Dickey (1998-on)
 *
 * $Id: ditto.c,v 1.42 2012/11/24 20:16:18 tom Exp $
 *
 * The program illustrates how to set up multiple screens from a single
 * program.
 *
 * If openpty() is supported, the command line parameters are titles for
 * the windows showing each screen's data.
 *
 * If openpty() is not supported, you must invoke the program by specifying
 * another terminal on the same machine by specifying its device, e.g.,
 *	ditto /dev/ttyp1
 */
#include &lt;test.priv.h&gt;
#include &lt;sys/stat.h&gt;

#ifdef USE_PTHREADS
#include &lt;pthread.h&gt;
#endif

#ifdef USE_XTERM_PTY
#include USE_OPENPTY_HEADER
#endif

#define MAX_FIFO 256

#define THIS_FIFO(n) ((n) % MAX_FIFO)
#define NEXT_FIFO(n) THIS_FIFO((n) + 1)

typedef struct {
    unsigned long sequence;
    int head;
    int tail;
    int data[MAX_FIFO];
} FIFO;

typedef struct {
    unsigned long sequence;
} PEEK;

/*
 * Data &quot;owned&quot; for a single screen.  Each screen is divided into windows that
 * show the text read from each terminal.  Input from a given screen will also
 * be read into one window per screen.
 */
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;

/*
 * Structure used to pass multiple parameters via the use_screen()
 * single-parameter interface.
 */
typedef struct {
    int source;			/* which screen did character come from */
    int target;			/* which screen is character going to */
    DITTO *ditto;		/* data for all screens */
} DDATA;

static void failed(const char *) GCC_NORETURN;
static void usage(void) GCC_NORETURN;

static void
failed(const char *s)
{
    perror(s);
    ExitProgram(EXIT_FAILURE);
}

static void
usage(void)
{
    fprintf(stderr, &quot;usage: ditto [terminal1 ...]\n&quot;);
    ExitProgram(EXIT_FAILURE);
}

/* Add to the head of the fifo, checking for overflow. */
static void
put_fifo(FIFO * fifo, int value)
{
    int next = NEXT_FIFO(fifo-&gt;head);
    if (next == fifo-&gt;tail)
	fifo-&gt;tail = NEXT_FIFO(fifo-&gt;tail);
    fifo-&gt;data[next] = value;
    fifo-&gt;head = next;
    fifo-&gt;sequence += 1;
}

/* Get data from the tail (oldest part) of the fifo, returning -1 if no data.
 * Since each screen can peek into the fifo, we do not update the tail index,
 * but modify the peek-index.
 *
 * FIXME - test/workaround for case where fifo gets more than a buffer
 * ahead of peek.
 */
static int
peek_fifo(FIFO * fifo, PEEK * peek)
{
    int result = -1;
    if (peek-&gt;sequence &lt; fifo-&gt;sequence) {
	result = fifo-&gt;data[THIS_FIFO(peek-&gt;sequence)];
	peek-&gt;sequence += 1;
    }
    return result;
}

static FILE *
open_tty(char *path)
{
    FILE *fp;
#ifdef USE_XTERM_PTY
    int amaster;
    int aslave;
    char slave_name[1024];
    char s_option[sizeof(slave_name) + 80];

    if (openpty(&amp;amaster, &amp;aslave, slave_name, 0, 0) != 0
	|| strlen(slave_name) &gt; sizeof(slave_name) - 1)
	failed(&quot;openpty&quot;);
    if (strrchr(slave_name, '/') == 0) {
	errno = EISDIR;
	failed(slave_name);
    }
    sprintf(s_option, &quot;-S%s/%d&quot;, slave_name, aslave);
    if (fork()) {
	execlp(&quot;xterm&quot;, &quot;xterm&quot;, s_option, &quot;-title&quot;, path, (char *) 0);
	_exit(0);
    }
    fp = fdopen(amaster, &quot;r+&quot;);
    if (fp == 0)
	failed(path);
#else
    struct stat sb;

    if (stat(path, &amp;sb) &lt; 0)
	failed(path);
    if ((sb.st_mode &amp; S_IFMT) != S_IFCHR) {
	errno = ENOTTY;
	failed(path);
    }
    fp = fopen(path, &quot;r+&quot;);
    if (fp == 0)
	failed(path);
    printf(&quot;opened %s\n&quot;, path);
#endif
    assert(fp != 0);
    return fp;
}

static void
init_screen(
#if HAVE_USE_WINDOW
	       SCREEN *sp GCC_UNUSED,
#endif
	       void *arg)
{
    DITTO *target = (DITTO *) arg;
    int high, wide;
    int k;

    cbreak();
    noecho();
    scrollok(stdscr, TRUE);
    box(stdscr, 0, 0);

    target-&gt;parents = typeCalloc(WINDOW *, (size_t) target-&gt;length);
    target-&gt;windows = typeCalloc(WINDOW *, (size_t) target-&gt;length);
    target-&gt;peeks = typeCalloc(PEEK, (size_t) target-&gt;length);

    high = (LINES - 2) / target-&gt;length;
    wide = (COLS - 2);
    for (k = 0; k &lt; target-&gt;length; ++k) {
	WINDOW *outer = newwin(high, wide, 1 + (high * k), 1);
	WINDOW *inner = derwin(outer, high - 2, wide - 2, 1, 1);

	box(outer, 0, 0);
	MvWAddStr(outer, 0, 2, target-&gt;titles[k]);
	wnoutrefresh(outer);

	scrollok(inner, TRUE);
	keypad(inner, TRUE);
#ifndef USE_PTHREADS
	nodelay(inner, TRUE);
#endif

	target-&gt;parents[k] = outer;
	target-&gt;windows[k] = inner;
    }
    doupdate();
}

static void
open_screen(DITTO * target, char **source, int length, int which1)
{
    if (which1 != 0) {
	target-&gt;input =
	    target-&gt;output = open_tty(source[which1]);
    } else {
	target-&gt;input = stdin;
	target-&gt;output = stdout;
    }

    target-&gt;which1 = which1;
    target-&gt;titles = source;
    target-&gt;length = length;
    target-&gt;fifo.head = -1;
    target-&gt;screen = newterm((char *) 0,	/* assume $TERM is the same */
			     target-&gt;output,
			     target-&gt;input);

    if (target-&gt;screen == 0)
	failed(&quot;newterm&quot;);

    (void) USING_SCREEN(target-&gt;screen, init_screen, target);
}

static int
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();
}

/*
 * Read data from the 'source' screen.
 */
static int
read_screen(
#if HAVE_USE_WINDOW
	       SCREEN *sp GCC_UNUSED,
#endif
	       void *arg)
{
    DDATA *data = (DDATA *) arg;
    DITTO *ditto = &amp;(data-&gt;ditto[data-&gt;source]);
    WINDOW *win = ditto-&gt;windows[data-&gt;source];
    int ch = wgetch(win);

    if (ch &gt; 0 &amp;&amp; ch &lt; 256)
	put_fifo(&amp;(ditto-&gt;fifo), ch);
    else
	ch = ERR;

    return ch;
}

/*
 * Write all of the data that's in fifos for the 'target' screen.
 */
static int
write_screen(
#if HAVE_USE_WINDOW
		SCREEN *sp GCC_UNUSED,
#endif
		void *arg GCC_UNUSED)
{
    DDATA *data = (DDATA *) arg;
    DITTO *ditto = &amp;(data-&gt;ditto[data-&gt;target]);
    bool changed = FALSE;
    int which;

    for (which = 0; which &lt; ditto-&gt;length; ++which) {
	WINDOW *win = ditto-&gt;windows[which];
	FIFO *fifo = &amp;(data-&gt;ditto[which].fifo);
	PEEK *peek = &amp;(ditto-&gt;peeks[which]);
	int ch;

	while ((ch = peek_fifo(fifo, peek)) &gt; 0) {
	    changed = TRUE;

	    waddch(win, (chtype) ch);
	    wnoutrefresh(win);
	}
    }

    if (changed)
	doupdate();
    return OK;
}

static void
show_ditto(DITTO * data, int count, DDATA * ddata)
{
    int n;

    (void) data;
    for (n = 0; n &lt; count; n++) {
	ddata-&gt;target = n;
	USING_SCREEN(data[n].screen, write_screen, (void *) ddata);
    }
}

#ifdef USE_PTHREADS
static void *
handle_screen(void *arg)
{
    DDATA ddata;
    int ch;

    memset(&amp;ddata, 0, sizeof(ddata));
    ddata.ditto = (DITTO *) arg;
    ddata.source = ddata.ditto-&gt;which1;
    ddata.ditto -= ddata.source;	/* -&gt; base of array */

    for (;;) {
	ch = read_screen(ddata.ditto-&gt;screen, &amp;ddata);
	if (ch == CTRL('D')) {
	    int later = (ddata.source ? ddata.source : -1);
	    int j;

	    for (j = ddata.ditto-&gt;length - 1; j &gt; 0; --j) {
		if (j != later) {
		    pthread_cancel(ddata.ditto[j].thread);
		}
	    }
	    if (later &gt; 0) {
		pthread_cancel(ddata.ditto[later].thread);
	    }
	    break;
	}
	show_ditto(ddata.ditto, ddata.ditto-&gt;length, &amp;ddata);
    }
    return NULL;
}
#endif

int
main(int argc, char *argv[])
{
    int j;
    DITTO *data;
#ifndef USE_PTHREADS
    int count;
#endif

    if (argc &lt;= 1)
	usage();

    if ((data = typeCalloc(DITTO, (size_t) argc)) == 0)
	failed(&quot;calloc data&quot;);

    assert(data != 0);

    for (j = 0; j &lt; argc; j++) {
	open_screen(&amp;data[j], argv, argc, j);
    }

#ifdef USE_PTHREADS
    /*
     * 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 &lt; argc; j++) {
	(void) pthread_create(&amp;(data[j].thread), NULL, handle_screen, &amp;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);

	ddata.source = which;
	ddata.ditto = data;

	ch = USING_SCREEN(data[which].screen, read_screen, &amp;ddata);
	if (ch == CTRL('D')) {
	    break;
	} else if (ch != ERR) {
	    show_ditto(data, argc, &amp;ddata);
	}
    }
#endif

    /*
     * Cleanup and exit
     */
    for (j = argc - 1; j &gt;= 0; j--) {
	USING_SCREEN(data[j].screen, close_screen, 0);
	fprintf(data[j].output, &quot;**Closed\r\n&quot;);

	/*
	 * Closing before a delscreen() helps ncurses determine that there
	 * is no valid output buffer, and can remove the setbuf() data.
	 */
	fflush(data[j].output);
	fclose(data[j].output);
	delscreen(data[j].screen);
    }
    ExitProgram(EXIT_SUCCESS);
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/doc/ncurses-devel-5.9/test/ditto.c'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fshare%2Fdoc%2Fncurses-devel-5.9%2Ftest' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>