third_party/grpc/src/core/lib/json/json_writer.cc - bazel - Git at Google

 /*
  *
  * Copyright 2015 gRPC authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  */

 #include <grpc/support/port_platform.h>

 #include <string.h>

 #include "src/core/lib/json/json_writer.h"

 static void json_writer_output_char(grpc_json_writer* writer, char c) {
   writer->vtable->output_char(writer->userdata, c);
 }

 static void json_writer_output_string(grpc_json_writer* writer,
                                       const char* str) {
   writer->vtable->output_string(writer->userdata, str);
 }

 static void json_writer_output_string_with_len(grpc_json_writer* writer,
                                                const char* str, size_t len) {
   writer->vtable->output_string_with_len(writer->userdata, str, len);
 }

 void grpc_json_writer_init(grpc_json_writer* writer, int indent,
                            grpc_json_writer_vtable* vtable, void* userdata) {
   memset(writer, 0, sizeof(*writer));
   writer->container_empty = 1;
   writer->indent = indent;
   writer->vtable = vtable;
   writer->userdata = userdata;
 }

 static void json_writer_output_indent(grpc_json_writer* writer) {
   static const char spacesstr[] =
       "                "
       "                "
       "                "
       "                ";

   unsigned spaces = static_cast<unsigned>(writer->depth * writer->indent);

   if (writer->indent == 0) return;

   if (writer->got_key) {
     json_writer_output_char(writer, ' ');
     return;
   }

   while (spaces >= (sizeof(spacesstr) - 1)) {
     json_writer_output_string_with_len(writer, spacesstr,
                                        sizeof(spacesstr) - 1);
     spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1);
   }

   if (spaces == 0) return;

   json_writer_output_string_with_len(
       writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces);
 }

 static void json_writer_value_end(grpc_json_writer* writer) {
   if (writer->container_empty) {
     writer->container_empty = 0;
     if ((writer->indent == 0) || (writer->depth == 0)) return;
     json_writer_output_char(writer, '\n');
   } else {
     json_writer_output_char(writer, ',');
     if (writer->indent == 0) return;
     json_writer_output_char(writer, '\n');
   }
 }

 static void json_writer_escape_utf16(grpc_json_writer* writer, uint16_t utf16) {
   static const char hex[] = "0123456789abcdef";

   json_writer_output_string_with_len(writer, "\\u", 2);
   json_writer_output_char(writer, hex[(utf16 >> 12) & 0x0f]);
   json_writer_output_char(writer, hex[(utf16 >> 8) & 0x0f]);
   json_writer_output_char(writer, hex[(utf16 >> 4) & 0x0f]);
   json_writer_output_char(writer, hex[(utf16)&0x0f]);
 }

 static void json_writer_escape_string(grpc_json_writer* writer,
                                       const char* string) {
   json_writer_output_char(writer, '"');

   for (;;) {
     uint8_t c = static_cast<uint8_t>(*string++);
     if (c == 0) {
       break;
     } else if ((c >= 32) && (c <= 126)) {
       if ((c == '\\') || (c == '"')) json_writer_output_char(writer, '\\');
       json_writer_output_char(writer, static_cast<char>(c));
     } else if ((c < 32) || (c == 127)) {
       switch (c) {
         case '\b':
           json_writer_output_string_with_len(writer, "\\b", 2);
           break;
         case '\f':
           json_writer_output_string_with_len(writer, "\\f", 2);
           break;
         case '\n':
           json_writer_output_string_with_len(writer, "\\n", 2);
           break;
         case '\r':
           json_writer_output_string_with_len(writer, "\\r", 2);
           break;
         case '\t':
           json_writer_output_string_with_len(writer, "\\t", 2);
           break;
         default:
           json_writer_escape_utf16(writer, c);
           break;
       }
     } else {
       uint32_t utf32 = 0;
       int extra = 0;
       int i;
       int valid = 1;
       if ((c & 0xe0) == 0xc0) {
         utf32 = c & 0x1f;
         extra = 1;
       } else if ((c & 0xf0) == 0xe0) {
         utf32 = c & 0x0f;
         extra = 2;
       } else if ((c & 0xf8) == 0xf0) {
         utf32 = c & 0x07;
         extra = 3;
       } else {
         break;
       }
       for (i = 0; i < extra; i++) {
         utf32 <<= 6;
         c = static_cast<uint8_t>(*string++);
         /* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
         if ((c & 0xc0) != 0x80) {
           valid = 0;
           break;
         }
         utf32 |= c & 0x3f;
       }
       if (!valid) break;
       /* The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
        * Any other range is technically reserved for future usage, so if we
        * don't want the software to break in the future, we have to allow
        * anything else. The first non-unicode character is 0x110000. */
       if (((utf32 >= 0xd800) && (utf32 <= 0xdfff)) || (utf32 >= 0x110000))
         break;
       if (utf32 >= 0x10000) {
         /* If utf32 contains a character that is above 0xffff, it needs to be
          * broken down into a utf-16 surrogate pair. A surrogate pair is first
          * a high surrogate, followed by a low surrogate. Each surrogate holds
          * 10 bits of usable data, thus allowing a total of 20 bits of data.
          * The high surrogate marker is 0xd800, while the low surrogate marker
          * is 0xdc00. The low 10 bits of each will be the usable data.
          *
          * After re-combining the 20 bits of data, one has to add 0x10000 to
          * the resulting value, in order to obtain the original character.
          * This is obviously because the range 0x0000 - 0xffff can be written
          * without any special trick.
          *
          * Since 0x10ffff is the highest allowed character, we're working in
          * the range 0x00000 - 0xfffff after we decrement it by 0x10000.
          * That range is exactly 20 bits.
          */
         utf32 -= 0x10000;
         json_writer_escape_utf16(writer,
                                  static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
         json_writer_escape_utf16(
             writer, static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
       } else {
         json_writer_escape_utf16(writer, static_cast<uint16_t>(utf32));
       }
     }
   }

   json_writer_output_char(writer, '"');
 }

 void grpc_json_writer_container_begins(grpc_json_writer* writer,
                                        grpc_json_type type) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '{' : '[');
   writer->container_empty = 1;
   writer->got_key = 0;
   writer->depth++;
 }

 void grpc_json_writer_container_ends(grpc_json_writer* writer,
                                      grpc_json_type type) {
   if (writer->indent && !writer->container_empty)
     json_writer_output_char(writer, '\n');
   writer->depth--;
   if (!writer->container_empty) json_writer_output_indent(writer);
   json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '}' : ']');
   writer->container_empty = 0;
   writer->got_key = 0;
 }

 void grpc_json_writer_object_key(grpc_json_writer* writer, const char* string) {
   json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_escape_string(writer, string);
   json_writer_output_char(writer, ':');
   writer->got_key = 1;
 }

 void grpc_json_writer_value_raw(grpc_json_writer* writer, const char* string) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_output_string(writer, string);
   writer->got_key = 0;
 }

 void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
                                          const char* string, size_t len) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_output_string_with_len(writer, string, len);
   writer->got_key = 0;
 }

 void grpc_json_writer_value_string(grpc_json_writer* writer,
                                    const char* string) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_escape_string(writer, string);
   writer->got_key = 0;
 }
	/*
	*
	* Copyright 2015 gRPC authors.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	#include <grpc/support/port_platform.h>

	#include <string.h>

	#include "src/core/lib/json/json_writer.h"

	static void json_writer_output_char(grpc_json_writer* writer, char c) {
	writer->vtable->output_char(writer->userdata, c);
	}

	static void json_writer_output_string(grpc_json_writer* writer,
	const char* str) {
	writer->vtable->output_string(writer->userdata, str);
	}

	static void json_writer_output_string_with_len(grpc_json_writer* writer,
	const char* str, size_t len) {
	writer->vtable->output_string_with_len(writer->userdata, str, len);
	}

	void grpc_json_writer_init(grpc_json_writer* writer, int indent,
	grpc_json_writer_vtable* vtable, void* userdata) {
	memset(writer, 0, sizeof(*writer));
	writer->container_empty = 1;
	writer->indent = indent;
	writer->vtable = vtable;
	writer->userdata = userdata;
	}

	static void json_writer_output_indent(grpc_json_writer* writer) {
	static const char spacesstr[] =
	" "
	" "
	" "
	" ";

	unsigned spaces = static_cast<unsigned>(writer->depth * writer->indent);

	if (writer->indent == 0) return;

	if (writer->got_key) {
	json_writer_output_char(writer, ' ');
	return;
	}

	while (spaces >= (sizeof(spacesstr) - 1)) {
	json_writer_output_string_with_len(writer, spacesstr,
	sizeof(spacesstr) - 1);
	spaces -= static_cast<unsigned>(sizeof(spacesstr) - 1);
	}

	if (spaces == 0) return;

	json_writer_output_string_with_len(
	writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces);
	}

	static void json_writer_value_end(grpc_json_writer* writer) {
	if (writer->container_empty) {
	writer->container_empty = 0;
	if ((writer->indent == 0) \|\| (writer->depth == 0)) return;
	json_writer_output_char(writer, '\n');
	} else {
	json_writer_output_char(writer, ',');
	if (writer->indent == 0) return;
	json_writer_output_char(writer, '\n');
	}
	}

	static void json_writer_escape_utf16(grpc_json_writer* writer, uint16_t utf16) {
	static const char hex[] = "0123456789abcdef";

	json_writer_output_string_with_len(writer, "\\u", 2);
	json_writer_output_char(writer, hex[(utf16 >> 12) & 0x0f]);
	json_writer_output_char(writer, hex[(utf16 >> 8) & 0x0f]);
	json_writer_output_char(writer, hex[(utf16 >> 4) & 0x0f]);
	json_writer_output_char(writer, hex[(utf16)&0x0f]);
	}

	static void json_writer_escape_string(grpc_json_writer* writer,
	const char* string) {
	json_writer_output_char(writer, '"');

	for (;;) {
	uint8_t c = static_cast<uint8_t>(*string++);
	if (c == 0) {
	break;
	} else if ((c >= 32) && (c <= 126)) {
	if ((c == '\\') \|\| (c == '"')) json_writer_output_char(writer, '\\');
	json_writer_output_char(writer, static_cast<char>(c));
	} else if ((c < 32) \|\| (c == 127)) {
	switch (c) {
	case '\b':
	json_writer_output_string_with_len(writer, "\\b", 2);
	break;
	case '\f':
	json_writer_output_string_with_len(writer, "\\f", 2);
	break;
	case '\n':
	json_writer_output_string_with_len(writer, "\\n", 2);
	break;
	case '\r':
	json_writer_output_string_with_len(writer, "\\r", 2);
	break;
	case '\t':
	json_writer_output_string_with_len(writer, "\\t", 2);
	break;
	default:
	json_writer_escape_utf16(writer, c);
	break;
	}
	} else {
	uint32_t utf32 = 0;
	int extra = 0;
	int i;
	int valid = 1;
	if ((c & 0xe0) == 0xc0) {
	utf32 = c & 0x1f;
	extra = 1;
	} else if ((c & 0xf0) == 0xe0) {
	utf32 = c & 0x0f;
	extra = 2;
	} else if ((c & 0xf8) == 0xf0) {
	utf32 = c & 0x07;
	extra = 3;
	} else {
	break;
	}
	for (i = 0; i < extra; i++) {
	utf32 <<= 6;
	c = static_cast<uint8_t>(*string++);
	/* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
	if ((c & 0xc0) != 0x80) {
	valid = 0;
	break;
	}
	utf32 \|= c & 0x3f;
	}
	if (!valid) break;
	/* The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
	* Any other range is technically reserved for future usage, so if we
	* don't want the software to break in the future, we have to allow
	* anything else. The first non-unicode character is 0x110000. */
	if (((utf32 >= 0xd800) && (utf32 <= 0xdfff)) \|\| (utf32 >= 0x110000))
	break;
	if (utf32 >= 0x10000) {
	/* If utf32 contains a character that is above 0xffff, it needs to be
	* broken down into a utf-16 surrogate pair. A surrogate pair is first
	* a high surrogate, followed by a low surrogate. Each surrogate holds
	* 10 bits of usable data, thus allowing a total of 20 bits of data.
	* The high surrogate marker is 0xd800, while the low surrogate marker
	* is 0xdc00. The low 10 bits of each will be the usable data.
	*
	* After re-combining the 20 bits of data, one has to add 0x10000 to
	* the resulting value, in order to obtain the original character.
	* This is obviously because the range 0x0000 - 0xffff can be written
	* without any special trick.
	*
	* Since 0x10ffff is the highest allowed character, we're working in
	* the range 0x00000 - 0xfffff after we decrement it by 0x10000.
	* That range is exactly 20 bits.
	*/
	utf32 -= 0x10000;
	json_writer_escape_utf16(writer,
	static_cast<uint16_t>(0xd800 \| (utf32 >> 10)));
	json_writer_escape_utf16(
	writer, static_cast<uint16_t>(0xdc00 \| (utf32 & 0x3ff)));
	} else {
	json_writer_escape_utf16(writer, static_cast<uint16_t>(utf32));
	}
	}
	}

	json_writer_output_char(writer, '"');
	}

	void grpc_json_writer_container_begins(grpc_json_writer* writer,
	grpc_json_type type) {
	if (!writer->got_key) json_writer_value_end(writer);
	json_writer_output_indent(writer);
	json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '{' : '[');
	writer->container_empty = 1;
	writer->got_key = 0;
	writer->depth++;
	}

	void grpc_json_writer_container_ends(grpc_json_writer* writer,
	grpc_json_type type) {
	if (writer->indent && !writer->container_empty)
	json_writer_output_char(writer, '\n');
	writer->depth--;
	if (!writer->container_empty) json_writer_output_indent(writer);
	json_writer_output_char(writer, type == GRPC_JSON_OBJECT ? '}' : ']');
	writer->container_empty = 0;
	writer->got_key = 0;
	}

	void grpc_json_writer_object_key(grpc_json_writer* writer, const char* string) {
	json_writer_value_end(writer);
	json_writer_output_indent(writer);
	json_writer_escape_string(writer, string);
	json_writer_output_char(writer, ':');
	writer->got_key = 1;
	}

	void grpc_json_writer_value_raw(grpc_json_writer* writer, const char* string) {
	if (!writer->got_key) json_writer_value_end(writer);
	json_writer_output_indent(writer);
	json_writer_output_string(writer, string);
	writer->got_key = 0;
	}

	void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
	const char* string, size_t len) {
	if (!writer->got_key) json_writer_value_end(writer);
	json_writer_output_indent(writer);
	json_writer_output_string_with_len(writer, string, len);
	writer->got_key = 0;
	}

	void grpc_json_writer_value_string(grpc_json_writer* writer,
	const char* string) {
	if (!writer->got_key) json_writer_value_end(writer);
	json_writer_output_indent(writer);
	json_writer_escape_string(writer, string);
	writer->got_key = 0;
	}