channel_need_redraw = TRUE;
}
+/*
+ * Return the first node from "channel"/"part" without removing it.
+ * Returns NULL if there is nothing.
+ */
+ readq_T *
+channel_peek(channel_T *channel, int part)
+{
+ readq_T *head = &channel->ch_part[part].ch_head;
+
+ return head->rq_next;
+}
+
+/*
+ * Return a pointer to the first NL in "node".
+ * Skips over NUL characters.
+ * Returns NULL if there is no NL.
+ */
+ char_u *
+channel_first_nl(readq_T *node)
+{
+ char_u *buffer = node->rq_buffer;
+ long_u i;
+
+ for (i = 0; i < node->rq_buflen; ++i)
+ if (buffer[i] == NL)
+ return buffer + i;
+ return NULL;
+}
+
/*
* Return the first buffer from channel "channel"/"part" and remove it.
* The caller must free it.
/*
* Returns the whole buffer contents concatenated for "channel"/"part".
+ * Replaces NUL bytes with NL.
*/
static char_u *
channel_get_all(channel_T *channel, int part)
p = res;
for (node = head->rq_next; node != NULL; node = node->rq_next)
{
- STRCPY(p, node->rq_buffer);
+ mch_memmove(p, node->rq_buffer, node->rq_buflen);
p += node->rq_buflen;
}
*p = NUL;
vim_free(p);
} while (p != NULL);
+ /* turn all NUL into NL */
+ while (len > 0)
+ {
+ --len;
+ if (res[len] == NUL)
+ res[len] = NL;
+ }
+
return res;
}
+/*
+ * Consume "len" bytes from the head of "channel"/"part".
+ * Caller must check these bytes are available.
+ */
+ void
+channel_consume(channel_T *channel, int part, int len)
+{
+ readq_T *head = &channel->ch_part[part].ch_head;
+ readq_T *node = head->rq_next;
+ char_u *buf = node->rq_buffer;
+
+ mch_memmove(buf, buf + len, node->rq_buflen - len);
+ node->rq_buflen -= len;
+}
+
/*
* Collapses the first and second buffer for "channel"/"part".
* Returns FAIL if that is not possible.
len = node->rq_buflen + last_node->rq_buflen + 1;
if (want_nl)
while (last_node->rq_next != NULL
- && vim_strchr(last_node->rq_buffer, NL) == NULL)
+ && channel_first_nl(last_node) == NULL)
{
last_node = last_node->rq_next;
len += last_node->rq_buflen;
p = newbuf = alloc(len);
if (newbuf == NULL)
return FAIL; /* out of memory */
- STRCPY(p, node->rq_buffer);
+ mch_memmove(p, node->rq_buffer, node->rq_buflen);
p += node->rq_buflen;
vim_free(node->rq_buffer);
node->rq_buffer = newbuf;
for (n = node; n != last_node; )
{
n = n->rq_next;
- STRCPY(p, n->rq_buffer);
+ mch_memmove(p, n->rq_buffer, n->rq_buflen);
p += n->rq_buflen;
vim_free(n->rq_buffer);
}
node = (readq_T *)alloc(sizeof(readq_T));
if (node == NULL)
return FAIL; /* out of memory */
+ /* A NUL is added at the end, because netbeans code expects that.
+ * Otherwise a NUL may appear inside the text. */
node->rq_buffer = alloc(len + 1);
if (node->rq_buffer == NULL)
{
char_u *callback = NULL;
partial_T *partial = NULL;
buf_T *buffer = NULL;
+ char_u *p;
if (channel->ch_nb_close_cb != NULL)
/* this channel is handled elsewhere (netbeans) */
{
char_u *nl;
char_u *buf;
+ readq_T *node;
/* See if we have a message ending in NL in the first buffer. If
* not try to concatenate the first and the second buffer. */
while (TRUE)
{
- buf = channel_peek(channel, part);
- nl = vim_strchr(buf, NL);
+ node = channel_peek(channel, part);
+ nl = channel_first_nl(node);
if (nl != NULL)
break;
if (channel_collapse(channel, part, TRUE) == FAIL)
return FALSE; /* incomplete message */
}
- if (nl[1] == NUL)
+ buf = node->rq_buffer;
+
+ /* Convert NUL to NL, the internal representation. */
+ for (p = buf; p < nl && p < buf + node->rq_buflen; ++p)
+ if (*p == NUL)
+ *p = NL;
+
+ if (nl + 1 == buf + node->rq_buflen)
{
/* get the whole buffer, drop the NL */
msg = channel_get(channel, part);
}
else
{
- /* Copy the message into allocated memory and remove it from
- * the buffer. */
+ /* Copy the message into allocated memory (excluding the NL)
+ * and remove it from the buffer (including the NL). */
msg = vim_strnsave(buf, (int)(nl - buf));
- mch_memmove(buf, nl + 1, STRLEN(nl + 1) + 1);
+ channel_consume(channel, part, (int)(nl - buf) + 1);
}
}
else
+ {
/* For a raw channel we don't know where the message ends, just
- * get everything we have. */
+ * get everything we have.
+ * Convert NUL to NL, the internal representation. */
msg = channel_get_all(channel, part);
+ }
if (msg == NULL)
return FALSE; /* out of memory (and avoids Coverity warning) */
channel->ch_nb_close_cb = NULL;
}
-/*
- * Return the first buffer from "channel"/"part" without removing it.
- * Returns NULL if there is nothing.
- */
- char_u *
-channel_peek(channel_T *channel, int part)
-{
- readq_T *head = &channel->ch_part[part].ch_head;
-
- if (head->rq_next == NULL)
- return NULL;
- return head->rq_next->rq_buffer;
-}
-
/*
* Clear the read buffer on "channel"/"part".
*/
ch_mode_T mode = channel->ch_part[part].ch_mode;
sock_T fd = channel->ch_part[part].ch_fd;
char_u *nl;
+ readq_T *node;
ch_logsn(channel, "Blocking %s read, timeout: %d msec",
mode == MODE_RAW ? "RAW" : "NL", timeout);
while (TRUE)
{
- buf = channel_peek(channel, part);
- if (buf != NULL && (mode == MODE_RAW
- || (mode == MODE_NL && vim_strchr(buf, NL) != NULL)))
- break;
- if (buf != NULL && channel_collapse(channel, part, mode == MODE_NL)
- == OK)
- continue;
+ node = channel_peek(channel, part);
+ if (node != NULL)
+ {
+ if (mode == MODE_RAW || (mode == MODE_NL
+ && channel_first_nl(node) != NULL))
+ /* got a complete message */
+ break;
+ if (channel_collapse(channel, part, mode == MODE_NL) == OK)
+ continue;
+ }
/* Wait for up to the channel timeout. */
if (fd == INVALID_FD)
}
else
{
- nl = vim_strchr(buf, NL);
- if (nl[1] == NUL)
+ char_u *p;
+
+ buf = node->rq_buffer;
+ nl = channel_first_nl(node);
+
+ /* Convert NUL to NL, the internal representation. */
+ for (p = buf; p < nl && p < buf + node->rq_buflen; ++p)
+ if (*p == NUL)
+ *p = NL;
+
+ if (nl + 1 == buf + node->rq_buflen)
{
/* get the whole buffer */
msg = channel_get(channel, part);
/* Copy the message into allocated memory and remove it from the
* buffer. */
msg = vim_strnsave(buf, (int)(nl - buf));
- mch_memmove(buf, nl + 1, STRLEN(nl + 1) + 1);
+ channel_consume(channel, part, (int)(nl - buf) + 1);
}
}
if (log_fd != NULL)
projects / vim / commitdiff