xenocara/app/xterm/ptydata.c

480 lines
12 KiB
C
Raw Normal View History

/* $XTermId: ptydata.c,v 1.105 2016/05/22 16:34:03 tom Exp $ */
/*
* Copyright 1999-2014,2016 by Thomas E. Dickey
*
* All Rights Reserved
*
* 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, 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 LISTED COPYRIGHT HOLDER(S) 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.
*/
2006-11-26 04:11:12 -07:00
#include <data.h>
#if OPT_WIDE_CHARS
#include <menu.h>
#endif
/*
* Check for both EAGAIN and EWOULDBLOCK, because some supposedly POSIX
* systems are broken and return EWOULDBLOCK when they should return EAGAIN.
* Note that this macro may evaluate its argument more than once.
*/
#if defined(EAGAIN) && defined(EWOULDBLOCK)
#define E_TEST(err) ((err) == EAGAIN || (err) == EWOULDBLOCK)
#else
#ifdef EAGAIN
#define E_TEST(err) ((err) == EAGAIN)
#else
#define E_TEST(err) ((err) == EWOULDBLOCK)
#endif
#endif
#if OPT_WIDE_CHARS
/*
* Convert the 8-bit codes in data->buffer[] into Unicode in data->utf_data.
* The number of bytes converted will be nonzero iff there is data.
*/
2007-06-15 13:29:55 -06:00
Bool
decodeUtf8(TScreen *screen, PtyData *data)
2006-11-26 04:11:12 -07:00
{
int i;
int length = (int) (data->last - data->next);
2006-11-26 04:11:12 -07:00
int utf_count = 0;
unsigned utf_char = 0;
2006-11-26 04:11:12 -07:00
data->utf_size = 0;
for (i = 0; i < length; i++) {
unsigned c = data->next[i];
/* Combine UTF-8 into Unicode */
if (c < 0x80) {
/* We received an ASCII character */
if (utf_count > 0) {
data->utf_data = UCS_REPL; /* prev. sequence incomplete */
data->utf_size = i;
2006-11-26 04:11:12 -07:00
} else {
data->utf_data = (IChar) c;
2006-11-26 04:11:12 -07:00
data->utf_size = 1;
}
break;
} else if (c < 0xc0) {
/* We received a continuation byte */
if (utf_count < 1) {
/*
* We received a continuation byte before receiving a sequence
* state. Or an attempt to use a C1 control string. Either
* way, it is mapped to the replacement character, unless
* allowed by optional feature.
2006-11-26 04:11:12 -07:00
*/
data->utf_data = (IChar) (screen->c1_printable ? c : UCS_REPL);
2006-11-26 04:11:12 -07:00
data->utf_size = (i + 1);
break;
} else {
/* Check for overlong UTF-8 sequences for which a shorter
* encoding would exist and replace them with UCS_REPL.
* An overlong UTF-8 sequence can have any of the following
* forms:
* 1100000x 10xxxxxx
* 11100000 100xxxxx 10xxxxxx
* 11110000 1000xxxx 10xxxxxx 10xxxxxx
* 11111000 10000xxx 10xxxxxx 10xxxxxx 10xxxxxx
* 11111100 100000xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
*/
if (!utf_char && !((c & 0x7f) >> (7 - utf_count))) {
utf_char = UCS_REPL;
}
utf_char <<= 6;
utf_char |= (c & 0x3f);
2006-11-26 04:11:12 -07:00
if ((utf_char >= 0xd800 &&
utf_char <= 0xdfff) ||
(utf_char == 0xfffe) ||
2007-08-25 12:53:27 -06:00
(utf_char == HIDDEN_CHAR)) {
2006-11-26 04:11:12 -07:00
utf_char = UCS_REPL;
}
utf_count--;
if (utf_count == 0) {
#if !OPT_WIDER_ICHAR
/* characters outside UCS-2 become UCS_REPL */
if (utf_char > 0xffff) {
TRACE(("using replacement for %#x\n", utf_char));
utf_char = UCS_REPL;
}
#endif
data->utf_data = (IChar) utf_char;
2006-11-26 04:11:12 -07:00
data->utf_size = (i + 1);
break;
}
}
} else {
/* We received a sequence start byte */
if (utf_count > 0) {
data->utf_data = UCS_REPL; /* prev. sequence incomplete */
data->utf_size = (i + 1);
break;
}
if (c < 0xe0) {
utf_count = 1;
utf_char = (c & 0x1f);
if (!(c & 0x1e)) {
2006-11-26 04:11:12 -07:00
utf_char = UCS_REPL; /* overlong sequence */
}
2006-11-26 04:11:12 -07:00
} else if (c < 0xf0) {
utf_count = 2;
utf_char = (c & 0x0f);
} else if (c < 0xf8) {
utf_count = 3;
utf_char = (c & 0x07);
} else if (c < 0xfc) {
utf_count = 4;
utf_char = (c & 0x03);
} else if (c < 0xfe) {
utf_count = 5;
utf_char = (c & 0x01);
} else {
data->utf_data = UCS_REPL;
data->utf_size = (i + 1);
break;
}
}
}
#if OPT_TRACE > 1
TRACE(("UTF-8 char %04X [%d..%d]\n",
data->utf_data,
(int) (data->next - data->buffer),
(int) (data->next - data->buffer + data->utf_size - 1)));
2006-11-26 04:11:12 -07:00
#endif
return (data->utf_size != 0);
}
#endif
int
readPtyData(XtermWidget xw, PtySelect * select_mask, PtyData *data)
2006-11-26 04:11:12 -07:00
{
TScreen *screen = TScreenOf(xw);
2006-11-26 04:11:12 -07:00
int size = 0;
#ifdef VMS
if (*select_mask & pty_mask) {
trimPtyData(xw, data);
2006-11-26 04:11:12 -07:00
if (read_queue.flink != 0) {
size = tt_read(data->next);
if (size == 0) {
Panic("input: read returned zero\n", 0);
}
} else {
sys$hiber();
}
}
#else /* !VMS */
if (FD_ISSET(screen->respond, select_mask)) {
int save_err;
trimPtyData(xw, data);
2006-11-26 04:11:12 -07:00
size = (int) read(screen->respond, (char *) data->last, (size_t) FRG_SIZE);
save_err = errno;
2006-11-26 04:11:12 -07:00
#if (defined(i386) && defined(SVR4) && defined(sun)) || defined(__CYGWIN__)
/*
* Yes, I know this is a majorly f*ugly hack, however it seems to
* be necessary for Solaris x86. DWH 11/15/94
* Dunno why though..
* (and now CYGWIN, alanh@xfree86.org 08/15/01
*/
if (size <= 0) {
if (save_err == EIO || save_err == 0)
2013-03-09 07:45:38 -07:00
NormalExit();
else if (!E_TEST(save_err))
Panic("input: read returned unexpected error (%d)\n", save_err);
size = 0;
}
#else /* !f*ugly */
if (size < 0) {
if (save_err == EIO)
2013-03-09 07:45:38 -07:00
NormalExit();
else if (!E_TEST(save_err))
Panic("input: read returned unexpected error (%d)\n", save_err);
2006-11-26 04:11:12 -07:00
size = 0;
} else if (size == 0) {
#if defined(__FreeBSD__) || defined(__OpenBSD__)
2013-03-09 07:45:38 -07:00
NormalExit();
2006-11-26 04:11:12 -07:00
#else
Panic("input: read returned zero\n", 0);
#endif
}
#endif /* f*ugly */
2006-11-26 04:11:12 -07:00
}
#endif /* VMS */
if (size) {
#if OPT_TRACE
int i;
TRACE(("read %d bytes from pty\n", size));
for (i = 0; i < size; i++) {
if (!(i % 16))
TRACE(("%s", i ? "\n " : "READ"));
TRACE((" %02X", data->last[i]));
}
TRACE(("\n"));
#endif
data->last += size;
#ifdef ALLOWLOGGING
TScreenOf(term)->logstart = VTbuffer->next;
2006-11-26 04:11:12 -07:00
#endif
}
return (size);
}
/*
* Return the next value from the input buffer. Note that morePtyData() is
* always called before this function, so we can do the UTF-8 input conversion
* in that function and simply return the result here.
*/
#if OPT_WIDE_CHARS
IChar
nextPtyData(TScreen *screen, PtyData *data)
2006-11-26 04:11:12 -07:00
{
IChar result;
if (screen->utf8_inparse) {
2007-06-15 13:29:55 -06:00
result = skipPtyData(data);
2006-11-26 04:11:12 -07:00
} else {
result = *((data)->next++);
if (!screen->output_eight_bits) {
result = (IChar) (result & 0x7f);
}
2006-11-26 04:11:12 -07:00
}
TRACE2(("nextPtyData returns %#x\n", result));
return result;
}
2007-06-15 13:29:55 -06:00
/*
* Simply return the data and skip past it.
*/
IChar
skipPtyData(PtyData *data)
2007-06-15 13:29:55 -06:00
{
IChar result = data->utf_data;
data->next += data->utf_size;
data->utf_size = 0;
return result;
}
2006-11-26 04:11:12 -07:00
#endif
#if OPT_WIDE_CHARS
/*
* Called when UTF-8 mode has been turned on/off.
*/
void
switchPtyData(TScreen *screen, int flag)
2006-11-26 04:11:12 -07:00
{
if (screen->utf8_mode != flag) {
screen->utf8_mode = flag;
2009-03-09 16:13:04 -06:00
screen->utf8_inparse = (Boolean) (flag != 0);
2006-11-26 04:11:12 -07:00
TRACE(("turning UTF-8 mode %s\n", BtoS(flag)));
update_font_utf8_mode();
}
}
#endif
2007-06-15 13:29:55 -06:00
/*
* Allocate a buffer.
*/
2006-11-26 04:11:12 -07:00
void
initPtyData(PtyData **result)
2006-11-26 04:11:12 -07:00
{
PtyData *data;
TRACE(("initPtyData given minBufSize %d, maxBufSize %d\n",
FRG_SIZE, BUF_SIZE));
if (FRG_SIZE < 64)
FRG_SIZE = 64;
if (BUF_SIZE < FRG_SIZE)
BUF_SIZE = FRG_SIZE;
if (BUF_SIZE % FRG_SIZE)
BUF_SIZE = BUF_SIZE + FRG_SIZE - (BUF_SIZE % FRG_SIZE);
TRACE(("initPtyData using minBufSize %d, maxBufSize %d\n",
FRG_SIZE, BUF_SIZE));
data = TypeXtMallocX(PtyData, (BUF_SIZE + FRG_SIZE));
2006-11-26 04:11:12 -07:00
memset(data, 0, sizeof(*data));
data->next = data->buffer;
data->last = data->buffer;
*result = data;
}
2007-06-15 13:29:55 -06:00
/*
* Initialize a buffer for the caller, using its data in 'next'.
2007-06-15 13:29:55 -06:00
*/
#if OPT_WIDE_CHARS
PtyData *
fakePtyData(PtyData *result, Char *next, Char *last)
2007-06-15 13:29:55 -06:00
{
PtyData *data = result;
memset(data, 0, sizeof(*data));
data->next = next;
data->last = last;
return data;
}
#endif
2006-11-26 04:11:12 -07:00
/*
* Remove used data by shifting the buffer down, to make room for more data,
* e.g., a continuation-read.
*/
void
trimPtyData(XtermWidget xw GCC_UNUSED, PtyData *data)
2006-11-26 04:11:12 -07:00
{
FlushLog(xw);
2006-11-26 04:11:12 -07:00
if (data->next != data->buffer) {
int i;
int n = (int) (data->last - data->next);
2006-11-26 04:11:12 -07:00
TRACE(("shifting buffer down by %d\n", n));
for (i = 0; i < n; ++i) {
data->buffer[i] = data->next[i];
}
data->next = data->buffer;
data->last = data->next + n;
}
}
/*
* Insert new data into the input buffer so the next calls to morePtyData()
* and nextPtyData() will return that.
*/
void
fillPtyData(XtermWidget xw, PtyData *data, const char *value, int length)
2006-11-26 04:11:12 -07:00
{
int size;
int n;
/* remove the used portion of the buffer */
trimPtyData(xw, data);
2006-11-26 04:11:12 -07:00
VTbuffer->last += length;
size = (int) (VTbuffer->last - VTbuffer->next);
2006-11-26 04:11:12 -07:00
/* shift the unused portion up to make room */
for (n = size; n >= length; --n)
VTbuffer->next[n] = VTbuffer->next[n - length];
/* insert the new bytes to interpret */
for (n = 0; n < length; n++)
VTbuffer->next[n] = CharOf(value[n]);
}
#if OPT_WIDE_CHARS
Char *
convertToUTF8(Char *lp, unsigned c)
2006-11-26 04:11:12 -07:00
{
#define CH(n) (Char)((c) >> ((n) * 8))
if (c < 0x80) {
/* 0******* */
*lp++ = (Char) CH(0);
} else if (c < 0x800) {
/* 110***** 10****** */
*lp++ = (Char) (0xc0 | (CH(0) >> 6) | ((CH(1) & 0x07) << 2));
*lp++ = (Char) (0x80 | (CH(0) & 0x3f));
} else if (c < 0x00010000) {
/* 1110**** 10****** 10****** */
*lp++ = (Char) (0xe0 | ((int) (CH(1) & 0xf0) >> 4));
*lp++ = (Char) (0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
*lp++ = (Char) (0x80 | (CH(0) & 0x3f));
} else if (c < 0x00200000) {
*lp++ = (Char) (0xf0 | ((int) (CH(2) & 0x1f) >> 2));
*lp++ = (Char) (0x80 |
((int) (CH(1) & 0xf0) >> 4) |
((int) (CH(2) & 0x03) << 4));
*lp++ = (Char) (0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
*lp++ = (Char) (0x80 | (CH(0) & 0x3f));
} else if (c < 0x04000000) {
*lp++ = (Char) (0xf8 | (CH(3) & 0x03));
*lp++ = (Char) (0x80 | (CH(2) >> 2));
*lp++ = (Char) (0x80 |
((int) (CH(1) & 0xf0) >> 4) |
((int) (CH(2) & 0x03) << 4));
*lp++ = (Char) (0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
*lp++ = (Char) (0x80 | (CH(0) & 0x3f));
} else {
*lp++ = (Char) (0xfc | ((int) (CH(3) & 0x40) >> 6));
*lp++ = (Char) (0x80 | (CH(3) & 0x3f));
*lp++ = (Char) (0x80 | (CH(2) >> 2));
*lp++ = (Char) (0x80 | (CH(1) >> 4) | ((CH(2) & 0x03) << 4));
*lp++ = (Char) (0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
*lp++ = (Char) (0x80 | (CH(0) & 0x3f));
2006-11-26 04:11:12 -07:00
}
return lp;
#undef CH
2006-11-26 04:11:12 -07:00
}
/*
* Write data back to the PTY
*/
void
writePtyData(int f, IChar *d, unsigned len)
2006-11-26 04:11:12 -07:00
{
unsigned n = (len << 1);
if (VTbuffer->write_len <= len) {
VTbuffer->write_len = n;
VTbuffer->write_buf = (Char *) XtRealloc((char *)
VTbuffer->write_buf, VTbuffer->write_len);
}
for (n = 0; n < len; n++)
2009-03-09 16:13:04 -06:00
VTbuffer->write_buf[n] = (Char) d[n];
2006-11-26 04:11:12 -07:00
TRACE(("writePtyData %d:%s\n", n,
visibleChars(VTbuffer->write_buf, n)));
2006-11-26 04:11:12 -07:00
v_write(f, VTbuffer->write_buf, n);
}
#endif /* OPT_WIDE_CHARS */
#ifdef NO_LEAKS
void
noleaks_ptydata(void)
{
if (VTbuffer != 0) {
#if OPT_WIDE_CHARS
if (VTbuffer->write_buf != 0)
free(VTbuffer->write_buf);
#endif
free(VTbuffer);
VTbuffer = 0;
}
}
#endif