patch 7.4.1279

Problem:    jsonencode() is not producing strict JSON.
Solution:   Add jsencode() and jsdecode().  Make jsonencode() and jsondecode()
            strict.

Author: brammool

runtime/doc/channel.txt

@@ -1,4 +1,4 @@
-*channel.txt*      For Vim version 7.4.  Last change: 2016 Feb 06
+*channel.txt*      For Vim version 7.4.  Last change: 2016 Feb 07
 
 
 		  VIM REFERENCE MANUAL	  by Bram Moolenaar
@@ -16,7 +16,7 @@ The Netbeans interface also uses a channel. |netbeans|
 
 1. Demo					|channel-demo|
 2. Opening a channel			|channel-open|
-3. Using a JSON channel			|channel-use|
+3. Using a JSON or JS channel		|channel-use|
 4. Vim commands				|channel-commands|
 5. Using a raw channel			|channel-use|
 6. Job control				|job-control|
@@ -77,6 +77,7 @@ To open a channel: >
 
 "mode" can be:						*channel-mode*
 	"json" - Use JSON, see below; most convenient way. Default.
+	"js"   - Use JavaScript encoding, more efficient than JSON.
 	"raw"  - Use raw messages
 
 							*channel-callback*
@@ -86,7 +87,7 @@ message. Example: >
 	func Handle(handle, msg)
 	  echo 'Received: ' . a:msg
 	endfunc
-	let handle = ch_open("localhost:8765", 'json', "Handle")
+	let handle = ch_open("localhost:8765", {"callback": "Handle"})
 
 "waittime" is the time to wait for the connection to be made in milliseconds.
 The default is zero, don't wait, which is useful if the server is supposed to
@@ -95,12 +96,12 @@ be running already.  A negative number waits forever.
 "timeout" is the time to wait for a request when blocking, using
 ch_sendexpr().  Again in milliseconds.  The default is 2000 (2 seconds).
 
-When "mode" is "json" the "msg" argument is the body of the received message,
-converted to Vim types.
+When "mode" is "json" or "js" the "msg" argument is the body of the received
+message, converted to Vim types.
 When "mode" is "raw" the "msg" argument is the whole message as a string.
 
-When "mode" is "json" the "callback" is optional.  When omitted it is only
-possible to receive a message after sending one.
+When "mode" is "json" or "js" the "callback" is optional.  When omitted it is
+only possible to receive a message after sending one.
 
 The handler can be added or changed later: >
     call ch_setcallback(handle, {callback})
@@ -123,12 +124,15 @@ If there is an error reading or writing a channel it will be closed.
 *E896* *E630* *E631* 
 
 ==============================================================================
-3. Using a JSON channel					*channel-use*
+3. 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(handle, {expr})
 This awaits a response from the other side.
 
+When {mode} is "js" this works the same, except that the messages use
+JavaScript encoding.  See |jsencode()| for the difference.
+
 To send a message, without handling a response: >
     call ch_sendexpr(handle, {expr}, 0)
 
@@ -231,7 +235,8 @@ Here {number} is the same as what was in the request.  Use a negative number
 to avoid confusion with message that Vim sends.
 
 {result} is the result of the evaluation and is JSON encoded.  If the
-evaluation fails it is the string "ERROR".
+evaluation fails or the result can't be encoded in JSON it is the string
+"ERROR".
 
 
 Command "expr" ~

runtime/doc/eval.txt

@@ -1956,6 +1956,8 @@ job_start({command} [, {options}]) Job	start a job
 job_status({job})		String	get the status of a job
 job_stop({job} [, {how}])	Number	stop a job
 join( {list} [, {sep}])		String	join {list} items into one String
+jsdecode( {string})		any	decode JS style JSON
+jsencode( {expr})		String	encode JS style JSON
 jsondecode( {string})		any	decode JSON
 jsonencode( {expr})		String	encode JSON
 keys( {dict})			List	keys in {dict}
@@ -2439,7 +2441,6 @@ bufwinnr({expr})					*bufwinnr()*
 		|:wincmd|.
 		Only deals with the current tab page.
 
-
 byte2line({byte})					*byte2line()*
 		Return the line number that contains the character at byte
 		count {byte} in the current buffer.  This includes the
@@ -2688,7 +2689,7 @@ ch_open({address} [, {argdict}])				*ch_open()*
 
 		If {argdict} is given it must be a |Dictionary|.  The optional
 		items are:
-			mode        "raw" or "json".
+			mode        "raw", "js" or "json".
 				    Default "json".
 			callback    function to call for requests with a zero
 				    sequence number.  See |channel-callback|.
@@ -4381,17 +4382,33 @@ join({list} [, {sep}])					*join()*
 		converted into a string like with |string()|.
 		The opposite function is |split()|.
 
+jsdecode({string})					*jsdecode()*
+		This is similar to |jsondecode()| with these differences:
+		- Object key names do not have to be in quotes.
+		- Empty items in an array (between two commas) are allowed and
+		  result in v:none items.
+
+jsencode({expr})					*jsencode()*
+		This is similar to |jsonencode()| with these differences:
+		- Object key names are not in quotes.
+		- v:none items in an array result in an empty item between
+		  commas.
+		For example, the Vim object:
+			[1,v:none,{"one":1}],v:none ~
+		Will be encoded as:
+			[1,,{one:1},,] ~
+		While jsonencode() would produce:
+			[1,null,{"one":1},null] ~
+		This encoding is valid for JavaScript. It is more efficient
+		than JSON, especially when using an array with optional items.
+
+
 jsondecode({string})					*jsondecode()*
 		This parses a JSON formatted string and returns the equivalent
 		in Vim values.  See |jsonencode()| for the relation between
 		JSON and Vim values.
 		The decoding is permissive:
 		- A trailing comma in an array and object is ignored.
-		- An empty item in an array, two commas with nothing or white
-		  space in between, results in v:none.
-		- When an object member name is not a string it is converted
-		  to a string.  E.g. the number 123 is used as the string
-		  "123".
 		- More floating point numbers are recognized, e.g. "1." for
 		  "1.0".
 		The result must be a valid Vim type:
@@ -4413,7 +4430,7 @@ jsonencode({expr})					*jsonencode()*
 		   			used recursively: {}
 		   v:false		"false"
 		   v:true		"true"
-		   v:none		nothing
+		   v:none		"null"
 		   v:null		"null"
 		Note that using v:none is permitted, although the JSON
 		standard does not allow empty items.  This can be useful for

src/channel.c

@@ -119,7 +119,7 @@ typedef struct {
     char_u    *ch_callback;	/* function to call when a msg is not handled */
     cbq_T     ch_cb_head;	/* dummy node for pre-request callbacks */
 
-    int	      ch_json_mode;	/* TRUE for a json channel */
+    ch_mode_T ch_mode;
     jsonq_T   ch_json_head;	/* dummy node, header for circular queue */
 
     int       ch_timeout;	/* request timeout in msec */
@@ -526,12 +526,12 @@ channel_open(char *hostname, int port_in, int waittime, void (*close_cb)(void))
 }
 
 /*
- * Set the json mode of channel "idx" to TRUE or FALSE.
+ * Set the json mode of channel "idx" to "ch_mode".
  */
     void
-channel_set_json_mode(int idx, int json_mode)
+channel_set_json_mode(int idx, ch_mode_T ch_mode)
 {
-    channels[idx].ch_json_mode = json_mode;
+    channels[idx].ch_mode = ch_mode;
 }
 
 /*
@@ -672,7 +672,8 @@ channel_parse_json(int ch_idx)
     js_read_T	reader;
     typval_T	listtv;
     jsonq_T	*item;
-    jsonq_T	*head = &channels[ch_idx].ch_json_head;
+    channel_T	*channel = &channels[ch_idx];
+    jsonq_T	*head = &channel->ch_json_head;
     int		ret;
 
     if (channel_peek(ch_idx) == NULL)
@@ -685,7 +686,8 @@ channel_parse_json(int ch_idx)
     reader.js_fill = NULL;
     /* reader.js_fill = channel_fill; */
     reader.js_cookie = &ch_idx;
-    ret = json_decode(&reader, &listtv);
+    ret = json_decode(&reader, &listtv,
+				   channel->ch_mode == MODE_JS ? JSON_JS : 0);
     if (ret == OK)
     {
 	/* Only accept the response when it is a list with at least two
@@ -854,22 +856,26 @@ channel_exe_cmd(int idx, char_u *cmd, typval_T *arg2, typval_T *arg3)
 	    typval_T	*tv;
 	    typval_T	err_tv;
 	    char_u	*json = NULL;
+	    channel_T	*channel = &channels[idx];
+	    int		options = channel->ch_mode == MODE_JS ? JSON_JS : 0;
 
 	    /* Don't pollute the display with errors. */
 	    ++emsg_skip;
 	    tv = eval_expr(arg, NULL);
 	    if (is_eval)
 	    {
 		if (tv != NULL)
-		    json = json_encode_nr_expr(arg3->vval.v_number, tv);
+		    json = json_encode_nr_expr(arg3->vval.v_number, tv,
+								     options);
 		if (tv == NULL || (json != NULL && *json == NUL))
 		{
 		    /* If evaluation failed or the result can't be encoded
 		     * then return the string "ERROR". */
 		    err_tv.v_type = VAR_STRING;
 		    err_tv.vval.v_string = (char_u *)"ERROR";
 		    tv = &err_tv;
-		    json = json_encode_nr_expr(arg3->vval.v_number, tv);
+		    json = json_encode_nr_expr(arg3->vval.v_number, tv,
+								     options);
 		}
 		if (json != NULL)
 		{
@@ -900,13 +906,13 @@ may_invoke_callback(int idx)
     typval_T	argv[3];
     int		seq_nr = -1;
     channel_T	*channel = &channels[idx];
-    int		json_mode = channel->ch_json_mode;
+    ch_mode_T	ch_mode = channel->ch_mode;
 
     if (channel->ch_close_cb != NULL)
 	/* this channel is handled elsewhere (netbeans) */
 	return FALSE;
 
-    if (json_mode)
+    if (ch_mode != MODE_RAW)
     {
 	/* Get any json message in the queue. */
 	if (channel_get_json(idx, -1, &listtv) == FAIL)

src/eval.c

@@ -628,6 +628,8 @@ static void f_job_stop(typval_T *argvars, typval_T *rettv);
 static void f_job_status(typval_T *argvars, typval_T *rettv);
 #endif
 static void f_join(typval_T *argvars, typval_T *rettv);
+static void f_jsdecode(typval_T *argvars, typval_T *rettv);
+static void f_jsencode(typval_T *argvars, typval_T *rettv);
 static void f_jsondecode(typval_T *argvars, typval_T *rettv);
 static void f_jsonencode(typval_T *argvars, typval_T *rettv);
 static void f_keys(typval_T *argvars, typval_T *rettv);
@@ -8206,6 +8208,8 @@ static struct fst
     {"job_stop",	1, 1, f_job_stop},
 #endif
     {"join",		1, 2, f_join},
+    {"jsdecode",	1, 1, f_jsdecode},
+    {"jsencode",	1, 1, f_jsencode},
     {"jsondecode",	1, 1, f_jsondecode},
     {"jsonencode",	1, 1, f_jsonencode},
     {"keys",		1, 1, f_keys},
@@ -9829,7 +9833,7 @@ f_ch_open(typval_T *argvars, typval_T *rettv)
     int		port;
     int		waittime = 0;
     int		timeout = 2000;
-    int		json_mode = TRUE;
+    ch_mode_T	ch_mode = MODE_JSON;
     int		ch_idx;
 
     /* default: fail */
@@ -9868,8 +9872,12 @@ f_ch_open(typval_T *argvars, typval_T *rettv)
 	{
 	    mode = get_dict_string(dict, (char_u *)"mode", FALSE);
 	    if (STRCMP(mode, "raw") == 0)
-		json_mode = FALSE;
-	    else if (STRCMP(mode, "json") != 0)
+		ch_mode = MODE_RAW;
+	    else if (STRCMP(mode, "js") == 0)
+		ch_mode = MODE_JS;
+	    else if (STRCMP(mode, "json") == 0)
+		ch_mode = MODE_JSON;
+	    else
 	    {
 		EMSG2(_(e_invarg2), mode);
 		return;
@@ -9891,7 +9899,7 @@ f_ch_open(typval_T *argvars, typval_T *rettv)
     ch_idx = channel_open((char *)address, port, waittime, NULL);
     if (ch_idx >= 0)
     {
-	channel_set_json_mode(ch_idx, json_mode);
+	channel_set_json_mode(ch_idx, ch_mode);
 	channel_set_timeout(ch_idx, timeout);
 	if (callback != NULL && *callback != NUL)
 	    channel_set_callback(ch_idx, callback);
@@ -9946,7 +9954,7 @@ f_ch_sendexpr(typval_T *argvars, typval_T *rettv)
     rettv->vval.v_string = NULL;
 
     id = channel_get_id();
-    text = json_encode_nr_expr(id, &argvars[1]);
+    text = json_encode_nr_expr(id, &argvars[1], 0);
     if (text == NULL)
 	return;
 
@@ -14442,6 +14450,31 @@ f_join(typval_T *argvars, typval_T *rettv)
 	rettv->vval.v_string = NULL;
 }
 
+/*
+ * "jsdecode()" function
+ */
+    static void
+f_jsdecode(typval_T *argvars, typval_T *rettv)
+{
+    js_read_T	reader;
+
+    reader.js_buf = get_tv_string(&argvars[0]);
+    reader.js_fill = NULL;
+    reader.js_used = 0;
+    if (json_decode_all(&reader, rettv, JSON_JS) != OK)
+	EMSG(_(e_invarg));
+}
+
+/*
+ * "jsencode()" function
+ */
+    static void
+f_jsencode(typval_T *argvars, typval_T *rettv)
+{
+    rettv->v_type = VAR_STRING;
+    rettv->vval.v_string = json_encode(&argvars[0], JSON_JS);
+}
+
 /*
  * "jsondecode()" function
  */
@@ -14453,7 +14486,7 @@ f_jsondecode(typval_T *argvars, typval_T *rettv)
     reader.js_buf = get_tv_string(&argvars[0]);
     reader.js_fill = NULL;
     reader.js_used = 0;
-    if (json_decode_all(&reader, rettv) != OK)
+    if (json_decode_all(&reader, rettv, 0) != OK)
 	EMSG(_(e_invarg));
 }
 
@@ -14464,7 +14497,7 @@ f_jsondecode(typval_T *argvars, typval_T *rettv)
 f_jsonencode(typval_T *argvars, typval_T *rettv)
 {
     rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = json_encode(&argvars[0]);
+    rettv->vval.v_string = json_encode(&argvars[0], 0);
 }
 
 /*