ttyansi.c

操作系统SunOS 4.1.3版本的源码

    Textsw	textsw;
    int		pty_index,
    		new_pty_index;
{
    /* in ![cooked, echo], pty_mark = insert */
    if (!cmdsw->cooked_echo
    &&  (int)textsw_get(textsw, TEXTSW_INSERTION_POINT)
    ==  pty_index) {
        if (cmdsw->append_only_log) {
            /* Remove read_only_mark to allow insert */
            textsw_remove_mark(textsw, cmdsw->read_only_mark);
        }
        (void)textsw_set(textsw, TEXTSW_INSERTION_POINT, new_pty_index, 0);
        if (cmdsw->append_only_log) {
            cmdsw->read_only_mark =
              textsw_add_mark(textsw, TEXTSW_INFINITY-1,
              			TEXTSW_MARK_READ_ONLY);
        }
    }
}

static int
do_backspace(textsw, addr)
    Textsw	 textsw;
    char	*addr;
{
    Textsw_index	pty_index;
    Textsw_index	pty_end;
    Textsw_index	textsw_start_of_display_line();
    int			increment = 0;
    Textsw_index	expanded_size = 1;
#define BUFSIZE 10
    char		buf[BUFSIZE];

    pty_end = cmdsw->cmd_started ?
    	      textsw_find_mark(textsw, cmdsw->user_mark) :
    	      (int)textsw_get(textsw, TEXTSW_LENGTH);
    pty_index = textsw_find_mark(textsw, cmdsw->pty_mark);
    if (pty_index > textsw_start_of_display_line(textsw, pty_index)) {
        switch(textsw_expand(
            textsw, pty_index-1, pty_index, buf, BUFSIZE, 
	    (int *)(LINT_CAST(&expanded_size)))) {
          case TEXTSW_EXPAND_OK:
            break;
          case TEXTSW_EXPAND_FULL_BUF:
          case TEXTSW_EXPAND_OTHER_ERROR:
          default:
            buf[0] = ' ';
            expanded_size = 1;
            break;
        }
        textsw_remove_mark(textsw, cmdsw->pty_mark);
        if (expanded_size != 1) {
	    if (replace_chars(textsw, pty_index - 1, pty_index,
	        buf, expanded_size)) {
	        increment = -1;
	    }
	    pty_index += expanded_size - 1;
	    pty_end += expanded_size - 1;
        }
        cmdsw->pty_mark = textsw_add_mark(textsw,
	  pty_index - 1, TEXTSW_MARK_DEFAULTS);
	if (increment < 0)
	    return (increment);
	adjust_insertion_point(textsw, (int) pty_index, (int) pty_index - 1);
	/*
	 * if at the end of transcript, interpret ' ' as
	 * delete a character.
	 */
	if (pty_end == pty_index
	&&  strncmp(addr+1, " ", 2) == 0) {
	    if (erase_chars(textsw, pty_index-1, pty_index)) {
		increment = -1;
	    } else {
		increment = 2;
	    }
	}
    }
    return(increment);
#undef BUFSIZE
}

static
get_end_of_line(textsw)
    Textsw	 textsw;
{
    int		pty_index;
    int		pty_end;
    int		pattern_start;
    int		pattern_end;
    char	newline = '\n';

    pty_end = cmdsw->cmd_started ?
	textsw_find_mark(textsw, cmdsw->user_mark) :
	(int)textsw_get(textsw, TEXTSW_LENGTH);
    pty_index = textsw_find_mark(textsw, cmdsw->pty_mark);
    pattern_start = pty_index;
    if (pty_index == pty_end - cmdsw->pty_owes_newline
    ||  textsw_find_bytes(textsw,
	(long *)(LINT_CAST(&pattern_start)), 
	(long *)(LINT_CAST(&pattern_end)), &newline, 1, 0) ==  -1
    ||  pattern_start >= pty_end - cmdsw->pty_owes_newline
    ||  pattern_start < pty_index) {
	pattern_start = pty_end - cmdsw->pty_owes_newline;
    }
    return (pattern_start);
}

/*
 *  By definition, the pty_mark is on the last line of the transcript.
 *  Therefore, must insert a newline at pty_end, plus enough spaces
 *  to line up with old column.
 */
static int
do_linefeed(textsw)
    Textsw	textsw;
{
    int			pty_index;
    int			pty_end;
    Textsw_index	line_start;
    Textsw_index	textsw_start_of_display_line();
    char		newline = '\n';
#define BUFSIZE 2048
    char		buf[2048];
    char		*cp = buf;
    int			column;
    int			i;

    pty_end = cmdsw->cmd_started ?
	textsw_find_mark(textsw, cmdsw->user_mark) :
	(int)textsw_get(textsw, TEXTSW_LENGTH);
    pty_index = textsw_find_mark(textsw, cmdsw->pty_mark);
    line_start = textsw_start_of_display_line(textsw, pty_index);
    column = min(BUFSIZE - 3, (pty_index - line_start));

    textsw_remove_mark(textsw, cmdsw->pty_mark);
    cmdsw->pty_mark = textsw_add_mark(textsw,
        (Textsw_index) (pty_end - cmdsw->pty_owes_newline),
        TEXTSW_MARK_DEFAULTS);
    adjust_insertion_point(textsw,
        pty_index, pty_end - cmdsw->pty_owes_newline);

    *cp++ = newline;
    for (i = 0; i < column; i++) {
        *cp++ = ' ';
    }
    return (from_pty_to_textsw(textsw, cp, buf) ? 0 : 1);
#undef BUFSIZE
}

/*  This is a static instead of a return code, for backward
 *  compatibility reasons.
 */
static int handle_escape_status = 0;

ttysw_output(ttysw_client, addr, len0)
	Ttysubwindow ttysw_client;
	register unsigned char *addr;
	int len0;
{
    static	 int av[10];	/* args in ESCBRKT sequences.	*/
				/* -1 => defaulted		*/
    static	 int ac;	/* number of args in av		*/
#define BUFSIZE 1024
    Ttysw	*ttysw = (Ttysw *)(LINT_CAST(ttysw_client));
    Textsw	 textsw = (Textsw)ttysw->ttysw_hist;
    unsigned char	 buf[BUFSIZE];
    unsigned char	*cp = buf;
    int		 len = 0;
    int         upper_context;

    addr[len0] = '\0';
    if (!ttysw_getopt((caddr_t) ttysw, TTYOPT_TEXT))
	(void)removeCursor();
    for (; len < len0 && !ttysw->ttysw_frozen; len++, addr++) {
	if (state & S_ESC) {
	    switch (*addr) {
	    case NUL:
	    case DEL:
		/* all ignored */
		continue;
	    case '[':	/* Begin X3.64 escape code sequence */
		    ac = 0;
		    prefix = 0;
		    av[0] = -1;
		    state = S_ESCBRKT;
		    continue;

	    case 'P':	/* ANSI Device Control String */
	    case ']':	/* ANSI Operating System Command */
	    case '^':	/* ANSI Privacy Message */
	    case '_':	/* ANSI Application Program Command */
		    state = S_STRING;
		    strtype = *addr;
		    continue;

	    case '?':		/* simulate DEL char for systems
				    /* that can't xmit it. */
		*addr = DEL;
		state &= ~S_ESC;
		break;

	    case '\\':	/* ANSI string terminator */
		    if (state == (S_STRING|S_ESC)) {
			    ttysw_handlestring(ttysw, strtype, 0);
			    state = S_ALPHA;
			    continue;
		    }
		    /* FALL THROUGH */

	    default:
		state &= ~S_ESC;
		continue;
	    }
	}
	switch (state) {
	case S_ESCBRKT:
	    if (prefix == 0 && *addr >= '<' && *addr <= '?')
		    prefix = *addr;
	    else if (*addr >= '0' && *addr <= '9') {
		    if (av[ac] == -1)
			    av[ac] = 0;
		    av[ac] = ((short)av[ac])*10 + *addr - '0';
			    /* short for inline muls */
	    } else if (*addr == ';') {
		    av[ac] |= prefix << 24;
		    ac++;
		    av[ac] = -1;
		    prefix = 0;
	    } else {
		    /* XXX - should only terminate on valid end char */
		    av[ac] |= prefix << 24;
		    ac++;
		    switch (ttysw_handleescape(ttysw, *addr, ac, av)) {
		    case TTY_OK:
			    /* bug 1028029 
			    state = S_SKIPPING;
			    break;
			    */
		    case TTY_DONE:
			    state = S_ALPHA;
			    break;
		    default: {}
		    }
		    if (handle_escape_status) {
		        handle_escape_status = 0;
		        (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
		        return (0);
		    }
		    ac = 0;
		    prefix = 0;
	    }
	    break;

	case S_SKIPPING:
	    /* Waiting for char from cols 4-7 to end esc string */
	    if (*addr < '@')
		    break;
	    state = S_ALPHA;
	    break;

	case S_STRING:
	    if (!iscntrl(*addr))
		    ttysw_handlestring(ttysw, strtype, *addr);
	    else if (*addr == CTRL([))
		    state |= S_ESC;
	    break;

	case S_ALPHA:
	default:
	    if (ttysw_getopt((caddr_t) ttysw, TTYOPT_TEXT)) {
		state = S_ALPHA;
		switch (*addr) {
		case CTRL([):		/* Escape */
		    state |= S_ESC;
		    /* spit out what we have so far */
		    cp = from_pty_to_textsw(textsw, cp, buf);
		    if (!cp) {
		        (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
		        return (0);
		    }
		    break;
		case CTRL(G): {
		    extern struct pixwin *csr_pixwin;
		    struct pixwin *tmp_pixwin = csr_pixwin;
		    csr_pixwin = (struct pixwin *)
		        window_get(textsw, WIN_PIXWIN);
		    (void)blinkscreen();
		    csr_pixwin = tmp_pixwin;
		    break;
		}
		case NUL:	/* ignored */
		case DEL:	/* ignored */
		    break;
		case '\f': {	/* formfeed */
		    Textsw	view, textsw_first(), textsw_next();
		    int		pty_mark_shows;
		    int		pty_index =
		    		  textsw_find_mark(textsw, cmdsw->pty_mark);
		    *cp++ = '\n';
		    for (view = textsw_first(textsw);
			 view;
			 view = textsw_next(view))
		    {
			/*
			 * If pty_mark is showing,
			 * or if TEXTSW_INSERT_MAKES_VISIBLE == TEXTSW_ALWAYS
			 */
			pty_mark_shows = !textsw_does_index_not_show(view,
				(long)pty_index, (int *)0);
			if (pty_mark_shows
			|| (Textsw_enum)textsw_get(view,
				TEXTSW_INSERT_MAKES_VISIBLE)
			==	TEXTSW_ALWAYS /* != NEVER ??? */) {
			    /* spit out what we have so far */
			    cp = from_pty_to_textsw(view, cp, buf);
			    if (!cp) {
			        (void)ttysw_setopt(
			            (caddr_t)ttysw, TTYOPT_TEXT, 0);
			        return (0);
			    }
			    pty_index =
				textsw_find_mark(textsw, cmdsw->pty_mark);
                            /* we set the upper context to 0 for the clear */
                            /* command, then set it back to original value */
                            upper_context = 
                                (int) window_get(view, TEXTSW_UPPER_CONTEXT);
                            window_set (view, TEXTSW_UPPER_CONTEXT, 0, 0);
			    (void)textsw_set(
				view, TEXTSW_FIRST, pty_index, 0);
                            window_set (view, TEXTSW_UPPER_CONTEXT,
                                        upper_context, 0);
			}
		    }
		    if (cp >= &buf[sizeof(buf) - 1]) {
			/* spit out what we have so far */
			cp = from_pty_to_textsw(textsw, cp, buf);
			if (!cp) {
			    (void)ttysw_setopt(
				(caddr_t)ttysw, TTYOPT_TEXT, 0);
			    return (0);
			}
		    }
		    break;
		}
		case '\b': {	/* backspace */
		    register int	increment;
		    
		    /* preprocess buf */
		    if (cp > buf && *(cp-1) != '\t' && *(cp-1) != '\n') {
			while (*addr == '\b' && !iscntrl(*(addr+1))
			       && *(addr+1) != ' ') {
			    *(cp-1) = *(++addr);
			    addr++;
			    len += 2;
			}
		    }
		    if (*addr != '\b') {
			addr--;
			len--;
			break;
		    }
		    /* back up pty mark */
		    cp = from_pty_to_textsw(textsw, cp, buf);
		    if (!cp) {
		        (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
		        return (0);
		    }
		    if ((increment = do_backspace(textsw, addr)) > 0) {
		        addr += increment;
		        len += increment;
		    } else if (increment < 0) {
		        (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
		        return (0);
		    }
		    break;
		}
		case '\r': {
		    int			pty_index;
		    char		newline = '\n';
		    Textsw_index	line_start;
		    Textsw_index	textsw_start_of_display_line();

		    switch (*(addr+1)) {
		      case '\r':
		        /*
		         * compress multiple returns.
		         */
		        break;
		      case '\n':
		        /*
		         * if we're at the end,
		         *   increment to the newline and goto print_char,
		         * else process return normally.
		         */
		        pty_index = textsw_find_mark(textsw, cmdsw->pty_mark);
		        if ((cp-buf) >=
		            (get_end_of_line(textsw) - pty_index)) {
		            addr++;
		            len++;
		            goto print_char;
		        }
		      default: {

			/* spit out what we have so far */
			cp = from_pty_to_textsw(textsw, cp, buf);
			if (!cp) {
			    (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
			    return (0);
			}
			pty_index =
			    textsw_find_mark(textsw, cmdsw->pty_mark);
			line_start =
			    textsw_start_of_display_line(textsw, pty_index);
			textsw_remove_mark(textsw, cmdsw->pty_mark);
			cmdsw->pty_mark = textsw_add_mark(textsw,
			      line_start,
			      TEXTSW_MARK_DEFAULTS);
			adjust_insertion_point(
			    textsw, pty_index, (int)line_start);
		      }
		    } /* else textsw displays \n as \r\n */
		    break;
		}
		case '\n': {	/* linefeed */
		    cp = from_pty_to_textsw(textsw, cp, buf);
		    if (!cp) {
		        (void)ttysw_setopt((caddr_t)ttysw, TTYOPT_TEXT, 0);
		        return (0);