patch 7.4.1435v7.4.1435

Problem:    It is confusing that ch_sendexpr() and ch_sendraw() wait for a
            response.
Solution:   Add ch_evalexpr() and ch_evalraw().

5 files changed, 179 insertions, 69 deletions

diff --git a/runtime/doc/channel.txt b/runtime/doc/channel.txt
index 1e6eaf5f64..4571258a41 100644
--- a/runtime/doc/channel.txt
+++ b/runtime/doc/channel.txt
@@ -1,4 +1,4 @@
-*channel.txt*      For Vim version 7.4.  Last change: 2016 Feb 23
+*channel.txt*      For Vim version 7.4.  Last change: 2016 Feb 27
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -74,7 +74,7 @@ In T1 you should see:
 	=== socket opened === ~
 
 You can now send a message to the server: >
-	echo ch_sendexpr(channel, 'hello!')
+	echo ch_evalexpr(channel, 'hello!')
 
 The message is received in T1 and a response is sent back to Vim.
 You can see the raw messages in T1.  What Vim sends is:
@@ -101,7 +101,7 @@ Instead of giving a callback with every send call, it can also be specified
 when opening the channel: >
 	call ch_close(channel)
 	let channel = ch_open('localhost:8765', {'callback': "MyHandler"})
-	call ch_sendexpr(channel, 'hello!', {'callback': 0})
+	call ch_sendexpr(channel, 'hello!')
 
 ==============================================================================
 3. Opening a channel					*channel-open*
@@ -171,7 +171,7 @@ Use |ch_status()| to see if the channel could be opened.
 		msec at least.
 
 "timeout"	The time to wait for a request when blocking, E.g. when using
-		ch_sendexpr().  In milliseconds.  The default is 2000 (2
+		ch_evalexpr().  In milliseconds.  The default is 2000 (2
 		seconds).
 						*out-timeout* *err-timeout*
 "out-timeout"	Timeout for stdout.  Only when using pipes.
@@ -214,7 +214,7 @@ If there is an error reading or writing a channel it will be closed.
 4. Using a JSON or JS channel					*channel-use*
 
 If mode is JSON then a message can be sent synchronously like this: >
-    let response = ch_sendexpr(channel, {expr})
+    let response = ch_evalexpr(channel, {expr})
 This awaits a response from the other side.
 
 When mode is JS this works the same, except that the messages use
@@ -222,7 +222,7 @@ JavaScript encoding.  See |js_encode()| for the difference.
 
 To send a message, without handling a response or letting the channel callback
 handle the response: >
-    call ch_sendexpr(channel, {expr}, {'callback': 0})
+    call ch_sendexpr(channel, {expr})
 
 To send a message and letting the response handled by a specific function,
 asynchronously: >
@@ -263,8 +263,9 @@ On read error or ch_close(), when using a socket, the string "DETACH" is sent,
 if still possible.  The channel will then be inactive. For a JSON and JS mode
 channel quotes are used around DETACH, otherwise there are no quotes.
 
-It is also possible to use ch_sendraw() on a JSON or JS channel.  The caller
-is then completely responsible for correct encoding and decoding.
+It is also possible to use ch_sendraw() and ch_evalraw() on a JSON or JS
+channel.  The caller is then completely responsible for correct encoding and
+decoding.
 
 ==============================================================================
 5. Channel commands					*channel-commands*
@@ -363,7 +364,7 @@ Leave out the fourth argument if no response is to be sent:
 6. Using a RAW or NL channel				*channel-raw*
 
 If mode is RAW or NL then a message can be send like this: >
-    let response = ch_sendraw(channel, {string})
+    let response = ch_evalraw(channel, {string})
 
 The {string} is sent as-is.  The response will be what can be read from the
 channel right away.  Since Vim doesn't know how to recognize the end of the
@@ -377,18 +378,18 @@ first NL.  This can also be just the NL for an empty response.
 If no NL was read before the channel timeout an empty string is returned.
 
 To send a message, without expecting a response: >
-    call ch_sendraw(channel, {string}, 0)
+    call ch_sendraw(channel, {string})
 The process can send back a response, the channel handler will be called with
 it.
 
 To send a message and letting the response handled by a specific function,
 asynchronously: >
-    call ch_sendraw(channel, {string}, {callback})
+    call ch_sendraw(channel, {string}, {'callback': 'MyHandler'})
 
 This {string} can also be JSON, use |json_encode()| to create it and
 |json_decode()| to handle a received JSON message.
 
-It is not possible to use |ch_sendexpr()| on a raw channel.
+It is not possible to use |ch_evalexpr()| or |ch_sendexpr()| on a raw channel.
 
 ==============================================================================
 7. More channel functions				*channel-more*
@@ -447,8 +448,8 @@ If you want to handle both stderr and stdout with one handler use the
 "callback" option: >
     let job = job_start(command, {"callback": "MyHandler"}) 
 
-You can send a message to the command with ch_sendraw().  If the channel is in
-JSON or JS mode you can use ch_sendexpr().
+You can send a message to the command with ch_evalraw().  If the channel is in
+JSON or JS mode you can use ch_evalexpr().
 
 There are several options you can use, see |job-options|.
 For example, to start a job and write its output in buffer "dummy": >
diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 1a1da6e093..6a41c5fe63 100644
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -1818,6 +1818,10 @@ call( {func}, {arglist} [, {dict}])
 				any	call {func} with arguments {arglist}
 ceil( {expr})			Float	round {expr} up
 ch_close( {channel})		none	close {channel}
+ch_evalexpr( {channel}, {expr} [, {options}])
+				any	evaluate {expr} on JSON {channel}
+ch_evalraw( {channel}, {string} [, {options}])
+				any	evaluate {string} on raw {channel}
 ch_getjob( {channel})		Job	get the Job of {channel}
 ch_log( {msg} [, {channel}])	none	write {msg} in the channel log file
 ch_logfile( {fname} [, {mode}])	none	start logging channel activity
@@ -2692,6 +2696,31 @@ ch_close({channel})						*ch_close()*
 		Close {channel}.  See |channel-close|.
 		{only available when compiled with the |+channel| feature}
 
+ch_evalexpr({channel}, {expr} [, {options}])			*ch_evalexpr()*
+		Send {expr} over {channel}.  The {expr} is encoded
+		according to the type of channel.  The function cannot be used
+		with a raw channel.  See |channel-use|.  *E912*
+								*E917*
+		{options} must be a Dictionary.  It must not have a "callback"
+		entry.
+
+		ch_evalexpr() waits for a response and returns the decoded
+		expression.  When there is an error or timeout it returns an
+		empty string.
+
+		{only available when compiled with the |+channel| feature}
+
+ch_evalraw({channel}, {string} [, {options}])		*ch_evalraw()*
+		Send {string} over {channel}.
+		Works like |ch_evalexpr()|, but does not encode the request or
+		decode the response.  The caller is responsible for the
+		correct contents.  Also does not add a newline for a channel
+		in NL mode, the caller must do that.  The NL in the response
+		is removed.
+		See |channel-use|.
+
+		{only available when compiled with the |+channel| feature}
+
 ch_getjob({channel})						*ch_getjob()*
 		Get the Job associated with {channel}.
 		If there is no job calling |job_status()| on the returned Job
@@ -2769,16 +2798,11 @@ ch_sendexpr({channel}, {expr} [, {options}])			*ch_sendexpr()*
 		according to the type of channel.  The function cannot be used
 		with a raw channel.  See |channel-use|.  *E912*
 
-		{options} must be a Dictionary.
-		When "callback" is a Funcref or the name of a function,
-		ch_sendexpr() returns immediately.  The callback is invoked
-		when the response is received.  See |channel-callback|.
-
-		Without "callback" ch_sendexpr() waits for a response and
-		returns the decoded expression.  When there is an error or
-		timeout it returns an empty string.
-
-		When "callback" is zero no response is expected.
+		{options} must be a Dictionary.  The "callback" item is a
+		Funcref or the name of a function it is invoked when the
+		response is received.  See |channel-callback|.
+		Without "callback" the channel handler is invoked, otherwise
+		any received message is dropped.
 
 		{only available when compiled with the |+channel| feature}
 
@@ -7391,7 +7415,6 @@ scrollbind		Compiled with 'scrollbind' support.
 showcmd			Compiled with 'showcmd' support.
 signs			Compiled with |:sign| support.
 smartindent		Compiled with 'smartindent' support.
-sniff			Compiled with SNiFF interface support.
 spell			Compiled with spell checking support |spell|.
 startuptime		Compiled with |--startuptime| support.
 statusline		Compiled with support for 'statusline', 'rulerformat'
diff --git a/src/eval.c b/src/eval.c
index f69e814310..323caf1e50 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -507,6 +507,8 @@ static void f_ceil(typval_T *argvars, typval_T *rettv);
 #endif
 #ifdef FEAT_CHANNEL
 static void f_ch_close(typval_T *argvars, typval_T *rettv);
+static void f_ch_evalexpr(typval_T *argvars, typval_T *rettv);
+static void f_ch_evalraw(typval_T *argvars, typval_T *rettv);
 # ifdef FEAT_JOB
 static void f_ch_getjob(typval_T *argvars, typval_T *rettv);
 # endif
@@ -8201,6 +8203,8 @@ static struct fst
 #endif
 #ifdef FEAT_CHANNEL
     {"ch_close",	1, 1, f_ch_close},
+    {"ch_evalexpr",	2, 3, f_ch_evalexpr},
+    {"ch_evalraw",	2, 3, f_ch_evalraw},
 # ifdef FEAT_JOB
     {"ch_getjob",	1, 1, f_ch_getjob},
 # endif
@@ -10485,7 +10489,13 @@ f_ch_readraw(typval_T *argvars, typval_T *rettv)
  * Otherwise returns NULL.
  */
     static channel_T *
-send_common(typval_T *argvars, char_u *text, int id, char *fun, int *part_read)
+send_common(
+	typval_T *argvars,
+	char_u *text,
+	int id,
+	int eval,
+	char *fun,
+	int *part_read)
 {
     channel_T	*channel;
     jobopt_T	opt;
@@ -10502,9 +10512,17 @@ send_common(typval_T *argvars, char_u *text, int id, char *fun, int *part_read)
 	return NULL;
 
     /* Set the callback. An empty callback means no callback and not reading
-     * the response. */
+     * the response. With "ch_evalexpr()" and "ch_evalraw()" a callback is not
+     * allowed. */
     if (opt.jo_callback != NULL && *opt.jo_callback != NUL)
+    {
+	if (eval)
+	{
+	    EMSG2(_("E917: Cannot use a callback with %s()"), fun);
+	    return NULL;
+	}
 	channel_set_req_callback(channel, part_send, opt.jo_callback, id);
+    }
 
     if (channel_send(channel, part_send, text, fun) == OK
 						   && opt.jo_callback == NULL)
@@ -10513,10 +10531,10 @@ send_common(typval_T *argvars, char_u *text, int id, char *fun, int *part_read)
 }
 
 /*
- * "ch_sendexpr()" function
+ * common for "ch_evalexpr()" and "ch_sendexpr()"
  */
     static void
-f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
+ch_expr_common(typval_T *argvars, typval_T *rettv, int eval)
 {
     char_u	*text;
     typval_T	*listtv;
@@ -10539,7 +10557,7 @@ f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
     ch_mode = channel_get_mode(channel, part_send);
     if (ch_mode == MODE_RAW || ch_mode == MODE_NL)
     {
-	EMSG(_("E912: cannot use ch_sendexpr() with a raw or nl channel"));
+	EMSG(_("E912: cannot use ch_evalexpr()/ch_sendexpr() with a raw or nl channel"));
 	return;
     }
 
@@ -10549,9 +10567,10 @@ f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
     if (text == NULL)
 	return;
 
-    channel = send_common(argvars, text, id, "sendexpr", &part_read);
+    channel = send_common(argvars, text, id, eval,
+			    eval ? "ch_evalexpr" : "ch_sendexpr", &part_read);
     vim_free(text);
-    if (channel != NULL)
+    if (channel != NULL && eval)
     {
 	/* TODO: timeout from options */
 	timeout = channel_get_timeout(channel, part_read);
@@ -10570,10 +10589,28 @@ f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
 }
 
 /*
- * "ch_sendraw()" function
+ * "ch_evalexpr()" function
  */
     static void
-f_ch_sendraw(typval_T *argvars, typval_T *rettv)
+f_ch_evalexpr(typval_T *argvars, typval_T *rettv)
+{
+    ch_expr_common(argvars, rettv, TRUE);
+}
+
+/*
+ * "ch_sendexpr()" function
+ */
+    static void
+f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
+{
+    ch_expr_common(argvars, rettv, FALSE);
+}
+
+/*
+ * common for "ch_evalraw()" and "ch_sendraw()"
+ */
+    static void
+ch_raw_common(typval_T *argvars, typval_T *rettv, int eval)
 {
     char_u	buf[NUMBUFLEN];
     char_u	*text;
@@ -10586,8 +10623,9 @@ f_ch_sendraw(typval_T *argvars, typval_T *rettv)
     rettv->vval.v_string = NULL;
 
     text = get_tv_string_buf(&argvars[1], buf);
-    channel = send_common(argvars, text, 0, "sendraw", &part_read);
-    if (channel != NULL)
+    channel = send_common(argvars, text, 0, eval,
+			      eval ? "ch_evalraw" : "ch_sendraw", &part_read);
+    if (channel != NULL && eval)
     {
 	/* TODO: timeout from options */
 	timeout = channel_get_timeout(channel, part_read);
@@ -10596,6 +10634,24 @@ f_ch_sendraw(typval_T *argvars, typval_T *rettv)
 }
 
 /*
+ * "ch_evalraw()" function
+ */
+    static void
+f_ch_evalraw(typval_T *argvars, typval_T *rettv)
+{
+    ch_raw_common(argvars, rettv, TRUE);
+}
+
+/*
+ * "ch_sendraw()" function
+ */
+    static void
+f_ch_sendraw(typval_T *argvars, typval_T *rettv)
+{
+    ch_raw_common(argvars, rettv, FALSE);
+}
+
+/*
  * "ch_setoptions()" function
  */
     static void
diff --git a/src/testdir/test_channel.vim b/src/testdir/test_channel.vim
index 69922b1402..a3955e16ac 100644
--- a/src/testdir/test_channel.vim
+++ b/src/testdir/test_channel.vim
@@ -110,17 +110,17 @@ func s:communicate(port)
   endif
 
   " Simple string request and reply.
-  call assert_equal('got it', ch_sendexpr(handle, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(handle, 'hello!'))
 
   " Request that triggers sending two ex commands.  These will usually be
   " handled before getting the response, but it's not guaranteed, thus wait a
   " tiny bit for the commands to get executed.
-  call assert_equal('ok', ch_sendexpr(handle, 'make change'))
+  call assert_equal('ok', ch_evalexpr(handle, 'make change'))
   sleep 10m
   call assert_equal('added1', getline(line('$') - 1))
   call assert_equal('added2', getline('$'))
 
-  call assert_equal('ok', ch_sendexpr(handle, 'do normal'))
+  call assert_equal('ok', ch_evalexpr(handle, 'do normal'))
   sleep 10m
   call assert_equal('added more', getline('$'))
 
@@ -154,37 +154,37 @@ func s:communicate(port)
   call ch_setoptions(handle, {'callback': ''})
 
   " Send an eval request that works.
-  call assert_equal('ok', ch_sendexpr(handle, 'eval-works'))
+  call assert_equal('ok', ch_evalexpr(handle, 'eval-works'))
   sleep 10m
-  call assert_equal([-1, 'foo123'], ch_sendexpr(handle, 'eval-result'))
+  call assert_equal([-1, 'foo123'], ch_evalexpr(handle, 'eval-result'))
 
   " Send an eval request that fails.
-  call assert_equal('ok', ch_sendexpr(handle, 'eval-fails'))
+  call assert_equal('ok', ch_evalexpr(handle, 'eval-fails'))
   sleep 10m
-  call assert_equal([-2, 'ERROR'], ch_sendexpr(handle, 'eval-result'))
+  call assert_equal([-2, 'ERROR'], ch_evalexpr(handle, 'eval-result'))
 
   " Send an eval request that works but can't be encoded.
-  call assert_equal('ok', ch_sendexpr(handle, 'eval-error'))
+  call assert_equal('ok', ch_evalexpr(handle, 'eval-error'))
   sleep 10m
-  call assert_equal([-3, 'ERROR'], ch_sendexpr(handle, 'eval-result'))
+  call assert_equal([-3, 'ERROR'], ch_evalexpr(handle, 'eval-result'))
 
   " Send a bad eval request. There will be no response.
-  call assert_equal('ok', ch_sendexpr(handle, 'eval-bad'))
+  call assert_equal('ok', ch_evalexpr(handle, 'eval-bad'))
   sleep 10m
-  call assert_equal([-3, 'ERROR'], ch_sendexpr(handle, 'eval-result'))
+  call assert_equal([-3, 'ERROR'], ch_evalexpr(handle, 'eval-result'))
 
   " Send an expr request
-  call assert_equal('ok', ch_sendexpr(handle, 'an expr'))
+  call assert_equal('ok', ch_evalexpr(handle, 'an expr'))
   sleep 10m
   call assert_equal('one', getline(line('$') - 2))
   call assert_equal('two', getline(line('$') - 1))
   call assert_equal('three', getline('$'))
 
   " Request a redraw, we don't check for the effect.
-  call assert_equal('ok', ch_sendexpr(handle, 'redraw'))
-  call assert_equal('ok', ch_sendexpr(handle, 'redraw!'))
+  call assert_equal('ok', ch_evalexpr(handle, 'redraw'))
+  call assert_equal('ok', ch_evalexpr(handle, 'redraw!'))
 
-  call assert_equal('ok', ch_sendexpr(handle, 'empty-request'))
+  call assert_equal('ok', ch_evalexpr(handle, 'empty-request'))
 
   " Reading while there is nothing available.
   call assert_equal(v:none, ch_read(handle, {'timeout': 0}))
@@ -195,14 +195,14 @@ func s:communicate(port)
   call assert_true(reltimefloat(elapsed) < 0.6)
 
   " Send without waiting for a response, then wait for a response.
-  call ch_sendexpr(handle, 'wait a bit',  {'callback': 0})
+  call ch_sendexpr(handle, 'wait a bit')
   let resp = ch_read(handle)
   call assert_equal(type([]), type(resp))
   call assert_equal(type(11), type(resp[0]))
   call assert_equal('waited', resp[1])
 
   " make the server quit, can't check if this works, should not hang.
-  call ch_sendexpr(handle, '!quit!', {'callback': 0})
+  call ch_sendexpr(handle, '!quit!')
 endfunc
 
 func Test_communicate()
@@ -218,18 +218,18 @@ func s:two_channels(port)
     return
   endif
 
-  call assert_equal('got it', ch_sendexpr(handle, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(handle, 'hello!'))
 
   let newhandle = ch_open('localhost:' . a:port, s:chopt)
   if ch_status(newhandle) == "fail"
     call assert_false(1, "Can't open second channel")
     return
   endif
-  call assert_equal('got it', ch_sendexpr(newhandle, 'hello!'))
-  call assert_equal('got it', ch_sendexpr(handle, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(newhandle, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(handle, 'hello!'))
 
   call ch_close(handle)
-  call assert_equal('got it', ch_sendexpr(newhandle, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(newhandle, 'hello!'))
 
   call ch_close(newhandle)
 endfunc
@@ -247,7 +247,7 @@ func s:server_crash(port)
     return
   endif
 
-  call ch_sendexpr(handle, '!crash!')
+  call ch_evalexpr(handle, '!crash!')
 
   sleep 10m
 endfunc
@@ -271,12 +271,12 @@ func s:channel_handler(port)
   endif
 
   " Test that it works while waiting on a numbered message.
-  call assert_equal('ok', ch_sendexpr(handle, 'call me'))
+  call assert_equal('ok', ch_evalexpr(handle, 'call me'))
   sleep 10m
   call assert_equal('we called you', s:reply)
 
   " Test that it works while not waiting on a numbered message.
-  call ch_sendexpr(handle, 'call me again', {'callback': 0})
+  call ch_sendexpr(handle, 'call me again')
   sleep 10m
   call assert_equal('we did call you', s:reply)
 endfunc
@@ -334,15 +334,15 @@ func Test_raw_pipe()
   call assert_equal("run", job_status(job))
   try
     let handle = job_getchannel(job)
-    call ch_sendraw(handle, "echo something\n", {'callback': 0})
+    call ch_sendraw(handle, "echo something\n")
     let msg = ch_readraw(handle)
     call assert_equal("something\n", substitute(msg, "\r", "", 'g'))
 
-    call ch_sendraw(handle, "double this\n", {'callback': 0})
+    call ch_sendraw(handle, "double this\n")
     let msg = ch_readraw(handle)
     call assert_equal("this\nAND this\n", substitute(msg, "\r", "", 'g'))
 
-    let reply = ch_sendraw(handle, "quit\n")
+    let reply = ch_evalraw(handle, "quit\n")
     call assert_equal("Goodbye!\n", substitute(reply, "\r", "", 'g'))
   finally
     call job_stop(job)
@@ -358,20 +358,48 @@ func Test_nl_pipe()
   call assert_equal("run", job_status(job))
   try
     let handle = job_getchannel(job)
-    call ch_sendraw(handle, "echo something\n", {'callback': 0})
+    call ch_sendraw(handle, "echo something\n")
     call assert_equal("something", ch_readraw(handle))
 
-    call ch_sendraw(handle, "double this\n", {'callback': 0})
+    call ch_sendraw(handle, "double this\n")
     call assert_equal("this", ch_readraw(handle))
     call assert_equal("AND this", ch_readraw(handle))
 
-    let reply = ch_sendraw(handle, "quit\n")
+    let reply = ch_evalraw(handle, "quit\n")
     call assert_equal("Goodbye!", reply)
   finally
     call job_stop(job)
   endtry
 endfunc
 
+func Test_pipe_to_buffer()
+  if !has('job')
+    return
+  endif
+  call ch_log('Test_pipe_to_buffer()')
+  let job = job_start(s:python . " test_channel_pipe.py",
+	\ {'out-io': 'buffer', 'out-name': 'pipe-output'})
+  call assert_equal("run", job_status(job))
+  try
+    let handle = job_getchannel(job)
+    call ch_sendraw(handle, "echo line one\n")
+    call ch_sendraw(handle, "echo line two\n")
+    call ch_sendraw(handle, "double this\n")
+    call ch_sendraw(handle, "quit\n")
+    sp pipe-output
+    for i in range(100)
+      sleep 10m
+      if line('$') >= 6
+	break
+      endif
+    endfor
+    call assert_equal(['Reading from channel output...', 'line one', 'line two', 'this', 'AND this', 'Goodbye!'], getline(1, '$'))
+    bwipe!
+  finally
+    call job_stop(job)
+  endtry
+endfunc
+
 """"""""""
 
 let s:unletResponse = ''
@@ -434,7 +462,7 @@ func s:open_delay(port)
     call assert_false(1, "Can't open channel")
     return
   endif
-  call assert_equal('got it', ch_sendexpr(channel, 'hello!'))
+  call assert_equal('got it', ch_evalexpr(channel, 'hello!'))
   call ch_close(channel)
 endfunc
 
@@ -457,7 +485,7 @@ function s:test_call(port)
     return
   endif
 
-  call assert_equal('ok', ch_sendexpr(handle, 'call-func'))
+  call assert_equal('ok', ch_evalexpr(handle, 'call-func'))
   sleep 20m
   call assert_equal([1, 2, 3], s:call_ret)
 endfunc
@@ -507,7 +535,7 @@ function s:test_close_callback(port)
   endif
   call ch_setoptions(handle, {'close-cb': 'MyCloseCb'})
 
-  call assert_equal('', ch_sendexpr(handle, 'close me'))
+  call assert_equal('', ch_evalexpr(handle, 'close me'))
   sleep 20m
   call assert_equal('closed', s:ch_close_ret)
 endfunc
diff --git a/src/version.c b/src/version.c
index afa926f424..7384998f59 100644
--- a/src/version.c
+++ b/src/version.c
@@ -744,6 +744,8 @@ static char *(features[]) =
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1435,
+/**/
     1434,
 /**/
     1433,