vim: src/channel.c comparison

comparison src/channel.c @ 11937:c893d6c00497 v8.0.0848

patch 8.0.0848: using multiple ch_log functions is clumsy commit https://github.com/vim/vim/commit/2f3a90a3bd8505728c0b6d9ac3515f64ee19b357 Author: Bram Moolenaar <Bram@vim.org> Date: Thu Aug 3 14:49:29 2017 +0200 patch 8.0.0848: using multiple ch_log functions is clumsy Problem: Using multiple ch_log functions is clumsy. Solution: Use variable arguments. (Ozaki Kiichi, closes https://github.com/vim/vim/issues/1919)

author	Christian Brabandt <cb@256bit.org>
date	Thu, 03 Aug 2017 15:00:05 +0200
parents	d033653d3df8
children	ef1febf04d03

comparison

equal deleted inserted replaced

-:84e482f5ae52
+:c893d6c00497
 }
 static int did_log_msg = TRUE;
 void
-ch_log(channel_T *ch, char *msg)
+ch_log(channel_T *ch, const char *fmt, ...)
 {
 if (log_fd != NULL)
 {
+	va_list ap;
 	ch_log_lead("", ch);
-	fputs(msg, log_fd);
+	va_start(ap, fmt);
+	vfprintf(log_fd, fmt, ap);
+	va_end(ap);
 	fputc('\n', log_fd);
 	fflush(log_fd);
 	did_log_msg = TRUE;
 }
 }
-void
+static void
-ch_logn(channel_T *ch, char *msg, int nr)
+ch_error(channel_T *ch, const char *fmt, ...)
 {
 if (log_fd != NULL)
 {
-	ch_log_lead("", ch);
+	va_list ap;
-	fprintf(log_fd, msg, nr);
-	fputc('\n', log_fd);
-	fflush(log_fd);
-	did_log_msg = TRUE;
-}
-}
-void
-ch_logs(channel_T *ch, char *msg, char *name)
-{
-if (log_fd != NULL)
-{
-	ch_log_lead("", ch);
-	fprintf(log_fd, msg, name);
-	fputc('\n', log_fd);
-	fflush(log_fd);
-	did_log_msg = TRUE;
-}
-}
-static void
-ch_logsn(channel_T *ch, char *msg, char *name, int nr)
-{
-if (log_fd != NULL)
-{
-	ch_log_lead("", ch);
-	fprintf(log_fd, msg, name, nr);
-	fputc('\n', log_fd);
-	fflush(log_fd);
-	did_log_msg = TRUE;
-}
-}
-static void
-ch_error(channel_T *ch, char *msg)
-{
-if (log_fd != NULL)
-{
 	ch_log_lead("ERR ", ch);
-	fputs(msg, log_fd);
+	va_start(ap, fmt);
-	fputc('\n', log_fd);
+	vfprintf(log_fd, fmt, ap);
-	fflush(log_fd);
+	va_end(ap);
-	did_log_msg = TRUE;
-}
-}
-static void
-ch_errorn(channel_T *ch, char *msg, int nr)
-{
-if (log_fd != NULL)
-{
-	ch_log_lead("ERR ", ch);
-	fprintf(log_fd, msg, nr);
-	fputc('\n', log_fd);
-	fflush(log_fd);
-	did_log_msg = TRUE;
-}
-}
-static void
-ch_errors(channel_T *ch, char *msg, char *arg)
-{
-if (log_fd != NULL)
-{
-	ch_log_lead("ERR ", ch);
-	fprintf(log_fd, msg, arg);
 	fputc('\n', log_fd);
 	fflush(log_fd);
 	did_log_msg = TRUE;
 }
 }
 channel_T	*channel;
 ch_part_T	part;
 channel = channel_fd2channel(fd, &part);
 if (channel == NULL)
-	ch_errorn(NULL, "Channel for fd %d not found", fd);
+	ch_error(NULL, "Channel for fd %d not found", fd);
 else
 	channel_read(channel, part, "channel_read_fd");
 }
 #endif
 		fcntl(sd, F_SETFL, O_NONBLOCK) < 0
 #endif
 	       )
 	    {
 		SOCK_ERRNO;
-		ch_errorn(channel,
+		ch_error(channel,
 			 "channel_open: Connect failed with errno %d", errno);
 		sock_close(sd);
 		channel_free(channel);
 		return NULL;
 	    }
 	}
 	/* Try connecting to the server. */
-	ch_logsn(channel, "Connecting to %s port %d", hostname, port);
+	ch_log(channel, "Connecting to %s port %d", hostname, port);
 	ret = connect(sd, (struct sockaddr *)&server, sizeof(server));
 	if (ret == 0)
 	    /* The connection could be established. */
 	    break;
 #ifdef EINPROGRESS
 		&& errno != EINPROGRESS
 #endif
 		))
 	{
-	    ch_errorn(channel,
+	    ch_error(channel,
 			 "channel_open: Connect failed with errno %d", errno);
 	    PERROR(_(e_cannot_connect));
 	    sock_close(sd);
 	    channel_free(channel);
 	    return NULL;
 	    tv.tv_sec = waitnow / 1000;
 	    tv.tv_usec = (waitnow % 1000) * 1000;
 #ifndef WIN32
 	    gettimeofday(&start_tv, NULL);
 #endif
-	    ch_logn(channel,
+	    ch_log(channel,
 		    "Waiting for connection (waiting %d msec)...", waitnow);
 	    ret = select((int)sd + 1, &rfds, &wfds, NULL, &tv);
 	    if (ret < 0)
 	    {
 		SOCK_ERRNO;
-		ch_errorn(channel,
+		ch_error(channel,
 			"channel_open: Connect failed with errno %d", errno);
 		PERROR(_(e_cannot_connect));
 		sock_close(sd);
 		channel_free(channel);
 		return NULL;
 # ifdef EINPROGRESS
 			&& so_error != EINPROGRESS
 # endif
 			))
 		{
-		    ch_errorn(channel,
+		    ch_error(channel,
 			    "channel_open: Connect failed with errno %d",
 			    so_error);
 		    PERROR(_(e_cannot_connect));
 		    sock_close(sd);
 		    channel_free(channel);
 if (job->jv_in_buf != NULL)
 {
 	chanpart_T *in_part = &channel->ch_part[PART_IN];
 	set_bufref(&in_part->ch_bufref, job->jv_in_buf);
-	ch_logs(channel, "reading from buffer '%s'",
+	ch_log(channel, "reading from buffer '%s'",
 				 (char *)in_part->ch_bufref.br_buf->b_ffname);
 	if (options->jo_set & JO_IN_TOP)
 	{
 	    if (options->jo_in_top == 0 && !(options->jo_set & JO_IN_BOT))
 	    {
 	    {
 		EMSG(_(e_modifiable));
 	    }
 	    else
 	    {
-		ch_logs(channel, "writing out to buffer '%s'",
+		ch_log(channel, "writing out to buffer '%s'",
 						       (char *)buf->b_ffname);
 		set_bufref(&channel->ch_part[PART_OUT].ch_bufref, buf);
 	    }
 	}
 }
 	    {
 		EMSG(_(e_modifiable));
 	    }
 	    else
 	    {
-		ch_logs(channel, "writing err to buffer '%s'",
+		ch_log(channel, "writing err to buffer '%s'",
 						       (char *)buf->b_ffname);
 		set_bufref(&channel->ch_part[PART_ERR].ch_bufref, buf);
 	    }
 	}
 }
 	write_buf_line(buf, lnum, channel);
 	++written;
 }
 if (written == 1)
-	ch_logn(channel, "written line %d to channel", (int)lnum - 1);
+	ch_log(channel, "written line %d to channel", (int)lnum - 1);
 else if (written > 1)
-	ch_logn(channel, "written %d lines to channel", written);
+	ch_log(channel, "written %d lines to channel", written);
 in_part->ch_buf_top = lnum;
 if (lnum > buf->b_ml.ml_line_count || lnum > in_part->ch_buf_bot)
 {
 	/* Writing is done, no longer need the buffer. */
 	/* Close the pipe/socket, so that the other side gets EOF. */
 	ch_close_part(channel, PART_IN);
 }
 else
-	ch_logn(channel, "Still %d more lines to write",
+	ch_log(channel, "Still %d more lines to write",
 					  buf->b_ml.ml_line_count - lnum + 1);
 }
 /*
 * Handle buffer "buf" being freed, remove it from any channels.
 	{
 	    chanpart_T  *ch_part = &channel->ch_part[part];
 	    if (ch_part->ch_bufref.br_buf == buf)
 	    {
-		ch_logs(channel, "%s buffer has been wiped out",
+		ch_log(channel, "%s buffer has been wiped out",
 							    part_names[part]);
 		ch_part->ch_bufref.br_buf = NULL;
 	    }
 	}
 }
 		write_buf_line(buf, lnum, channel);
 		++written;
 	    }
 	    if (written == 1)
-		ch_logn(channel, "written line %d to channel", (int)lnum - 1);
+		ch_log(channel, "written line %d to channel", (int)lnum - 1);
 	    else if (written > 1)
-		ch_logn(channel, "written %d lines to channel", written);
+		ch_log(channel, "written %d lines to channel", written);
 	    if (lnum < buf->b_ml.ml_line_count)
-		ch_logn(channel, "Still %d more lines to write",
+		ch_log(channel, "Still %d more lines to write",
 					      buf->b_ml.ml_line_count - lnum);
 	    in_part->ch_buf_bot = lnum;
 	}
 }
 	if (listtv.v_type != VAR_LIST || listtv.vval.v_list->lv_len < 2)
 	{
 	    if (listtv.v_type != VAR_LIST)
 		ch_error(channel, "Did not receive a list, discarding");
 	    else
-		ch_errorn(channel, "Expected list with two items, got %d",
+		ch_error(channel, "Expected list with two items, got %d",
 						  listtv.vval.v_list->lv_len);
 	    clear_tv(&listtv);
 	}
 	else
 	{
 	if (chanpart->ch_wait_len < buflen)
 	{
 	    /* First time encountering incomplete message or after receiving
 	     * more (but still incomplete): set a deadline of 100 msec. */
-	    ch_logn(channel,
+	    ch_log(channel,
 		    "Incomplete message (%d bytes) - wait 100 msec for more",
 		    (int)buflen);
 	    reader.js_used = 0;
 	    chanpart->ch_wait_len = buflen;
 #ifdef WIN32
 		 || tv->vval.v_number == 0
 		 || tv->vval.v_number != channel->ch_part[part].ch_block_id))))
 	{
 	    *rettv = item->jq_value;
 	    if (tv->v_type == VAR_NUMBER)
-		ch_logn(channel, "Getting JSON message %d", tv->vval.v_number);
+		ch_log(channel, "Getting JSON message %d", tv->vval.v_number);
 	    remove_json_node(head, item);
 	    return OK;
 	}
 	item = item->jq_next;
 }
 if (STRCMP(cmd, "ex") == 0)
 {
 	int save_called_emsg = called_emsg;
 	called_emsg = FALSE;
-	ch_logs(channel, "Executing ex command '%s'", (char *)arg);
+	ch_log(channel, "Executing ex command '%s'", (char *)arg);
 	++emsg_silent;
 	do_cmdline_cmd(arg);
 	--emsg_silent;
 	if (called_emsg)
-	    ch_logs(channel, "Ex command error: '%s'",
+	    ch_log(channel, "Ex command error: '%s'",
 					  (char *)get_vim_var_str(VV_ERRMSG));
 	called_emsg = save_called_emsg;
 }
 else if (STRCMP(cmd, "normal") == 0)
 {
 	exarg_T ea;
-	ch_logs(channel, "Executing normal command '%s'", (char *)arg);
+	ch_log(channel, "Executing normal command '%s'", (char *)arg);
 	ea.arg = arg;
 	ea.addr_count = 0;
 	ea.forceit = TRUE; /* no mapping */
 	ex_normal(&ea);
 }
 	    /* Don't pollute the display with errors. */
 	    ++emsg_skip;
 	    if (!is_call)
 	    {
-		ch_logs(channel, "Evaluating expression '%s'", (char *)arg);
+		ch_log(channel, "Evaluating expression '%s'", (char *)arg);
 		tv = eval_expr(arg, NULL);
 	    }
 	    else
 	    {
-		ch_logs(channel, "Calling '%s'", (char *)arg);
+		ch_log(channel, "Calling '%s'", (char *)arg);
 		if (func_call(arg, &argv[2], NULL, NULL, &res_tv) == OK)
 		    tv = &res_tv;
 	    }
 	    if (argv[id_idx].v_type == VAR_NUMBER)
 		free_tv(tv);
 	}
 }
 else if (p_verbose > 2)
 {
-	ch_errors(channel, "Received unknown command: %s", (char *)cmd);
+	ch_error(channel, "Received unknown command: %s", (char *)cmd);
 	EMSG2(_("E905: received unknown command: %s"), cmd);
 }
 }
 /*
 	channel_T   *channel,
 	cbq_T	    *cbhead,
 	cbq_T	    *item,
 	typval_T    *argv)
 {
-ch_logs(channel, "Invoking one-time callback %s",
+ch_log(channel, "Invoking one-time callback %s",
 						   (char *)item->cq_callback);
 /* Remove the item from the list first, if the callback
 * invokes ch_close() the list will be cleared. */
 remove_cb_node(cbhead, item);
 invoke_callback(channel, item->cq_callback, item->cq_partial, argv);
 	--lnum;
 	buffer->b_write_to_channel = FALSE;
 }
 /* Append to the buffer */
-ch_logn(channel, "appending line %d to buffer", (int)lnum + 1 - empty);
+ch_log(channel, "appending line %d to buffer", (int)lnum + 1 - empty);
 buffer->b_p_ma = TRUE;
 curbuf = buffer;
 curwin->w_buffer = curbuf;
 u_sync(TRUE);
 {
 char_u *msg;
 while ((msg = channel_get(channel, part)) != NULL)
 {
-	ch_logs(channel, "Dropping message '%s'", (char *)msg);
+	ch_log(channel, "Dropping message '%s'", (char *)msg);
 	vim_free(msg);
 }
 }
 /*
 buffer = ch_part->ch_bufref.br_buf;
 if (buffer != NULL && (!bufref_valid(&ch_part->ch_bufref)
 					       || buffer->b_ml.ml_mfp == NULL))
 {
 	/* buffer was wiped out or unloaded */
-	ch_logs(channel, "%s buffer has been wiped out", part_names[part]);
+	ch_log(channel, "%s buffer has been wiped out", part_names[part]);
 	ch_part->ch_bufref.br_buf = NULL;
 	buffer = NULL;
 }
 if (ch_mode == MODE_JSON || ch_mode == MODE_JS)
 		/* message must be read with ch_read() */
 		channel_push_json(channel, part, listtv);
 		listtv = NULL;
 	    }
 	    else
-		ch_logn(channel, "Dropping message %d without callback",
+		ch_log(channel, "Dropping message %d without callback",
 								       seq_nr);
 	}
 }
 else if (callback != NULL || buffer != NULL)
 {
 	    if (cbitem != NULL)
 		invoke_one_time_callback(channel, cbhead, cbitem, argv);
 	    else
 	    {
 		/* invoke the channel callback */
-		ch_logs(channel, "Invoking channel callback %s",
+		ch_log(channel, "Invoking channel callback %s",
 							    (char *)callback);
 		invoke_callback(channel, callback, partial, argv);
 	    }
 	}
 }
 else
-	ch_logn(channel, "Dropping message %d", seq_nr);
+	ch_log(channel, "Dropping message %d", seq_nr);
 if (listtv != NULL)
 	free_tv(listtv);
 vim_free(msg);
 		  ;
 	  /* Invoke the close callback, if still set. */
 	  if (channel->ch_close_cb != NULL)
 	  {
-	      ch_logs(channel, "Invoking close callback %s",
+	      ch_log(channel, "Invoking close callback %s",
 						(char *)channel->ch_close_cb);
 	      argv[0].v_type = VAR_CHANNEL;
 	      argv[0].vval.v_channel = channel;
 	      call_func(channel->ch_close_cb, (int)STRLEN(channel->ch_close_cb),
 			   &rettv, 1, argv, NULL, 0L, 0L, &dummy, TRUE,
 */
 static channel_wait_result
 channel_wait(channel_T *channel, sock_T fd, int timeout)
 {
 if (timeout > 0)
-	ch_logn(channel, "Waiting for up to %d msec", timeout);
+	ch_log(channel, "Waiting for up to %d msec", timeout);
 # ifdef WIN32
 if (fd != channel->CH_SOCK_FD)
 {
 	DWORD	nread;
 static void
 ch_close_part_on_error(
 	channel_T *channel, ch_part_T part, int is_err, char *func)
 {
-char	msgbuf[80];
+char	msg[] = "%s(): Read %s from ch_part[%d], closing";
-vim_snprintf(msgbuf, sizeof(msgbuf),
-	    "%%s(): Read %s from ch_part[%d], closing",
-					    (is_err ? "error" : "EOF"), part);
 if (is_err)
 	/* Do not call emsg(), most likely the other end just exited. */
-	ch_errors(channel, msgbuf, func);
+	ch_error(channel, msg, func, "error", part);
 else
-	ch_logs(channel, msgbuf, func);
+	ch_log(channel, msg, func, "EOF", part);
 /* Queue a "DETACH" netbeans message in the command queue in order to
 * terminate the netbeans session later. Do not end the session here
 * directly as we may be running in the context of a call to
 * netbeans_parse_messages():
 int			use_socket = FALSE;
 fd = channel->ch_part[part].ch_fd;
 if (fd == INVALID_FD)
 {
-	ch_errors(channel, "channel_read() called while %s part is closed",
+	ch_error(channel, "channel_read() called while %s part is closed",
 							    part_names[part]);
 	return;
 }
 use_socket = fd == channel->CH_SOCK_FD;
 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",
+ch_log(channel, "Blocking %s read, timeout: %d msec",
 				    mode == MODE_RAW ? "RAW" : "NL", timeout);
 while (TRUE)
 {
 	node = channel_peek(channel, part);
 	    msg = vim_strnsave(buf, (int)(nl - buf));
 	    channel_consume(channel, part, (int)(nl - buf) + 1);
 	}
 }
 if (log_fd != NULL)
-	ch_logn(channel, "Returning %d bytes", (int)STRLEN(msg));
+	ch_log(channel, "Returning %d bytes", (int)STRLEN(msg));
 return msg;
 }
 /*
 * Read one JSON message with ID "id" from "channel"/"part" and store the
 fd = channel->ch_part[part].ch_fd;
 if (fd == INVALID_FD)
 {
 	if (!channel->ch_error && fun != NULL)
 	{
-	    ch_errors(channel, "%s(): write while not connected", fun);
+	    ch_error(channel, "%s(): write while not connected", fun);
 	    EMSG2(_("E630: %s(): write while not connected"), fun);
 	}
 	channel->ch_error = TRUE;
 	return FAIL;
 }
 	res = fd_write(fd, (char *)buf, len);
 if (res != len)
 {
 	if (!channel->ch_error && fun != NULL)
 	{
-	    ch_errors(channel, "%s(): write failed", fun);
+	    ch_error(channel, "%s(): write failed", fun);
 	    EMSG2(_("E631: %s(): write failed"), fun);
 	}
 	channel->ch_error = TRUE;
 	return FAIL;
 }
 	{
 	    if (i > 0)
 		ga_concat(&ga, (char_u *)"  ");
 	    ga_concat(&ga, (char_u *)argv[i]);
 	}
-	ch_logs(NULL, "Starting job: %s", (char *)ga.ga_data);
+	ch_log(NULL, "Starting job: %s", (char *)ga.ga_data);
 	ga_clear(&ga);
 }
 mch_job_start(argv, job, &opt);
 #else
-ch_logs(NULL, "Starting job: %s", (char *)cmd);
+ch_log(NULL, "Starting job: %s", (char *)cmd);
 mch_job_start((char *)cmd, job, &opt);
 #endif
 /* If the channel is reading from a buffer, write lines now. */
 if (job->jv_channel != NULL)
 if (job->jv_status == JOB_ENDED)
 {
 	ch_log(job->jv_channel, "Job has already ended, job_stop() skipped");
 	return 0;
 }
-ch_logs(job->jv_channel, "Stopping job with '%s'", (char *)arg);
+ch_log(job->jv_channel, "Stopping job with '%s'", (char *)arg);
 if (mch_stop_job(job, arg) == FAIL)
 	return 0;
 /* Assume that only "kill" will kill the job. */
 if (job->jv_channel != NULL && STRCMP(arg, "kill") == 0)

Mercurial > vim

comparison src/channel.c @ 11937:c893d6c00497 v8.0.0848