grpc 1.7.3 → 1.8.0

data/src/core/lib/json/json_reader.h

@@ -22,6 +22,10 @@
 #include <grpc/support/port_platform.h>
 #include "src/core/lib/json/json_common.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum {
   GRPC_JSON_STATE_OBJECT_KEY_BEGIN,
   GRPC_JSON_STATE_OBJECT_KEY_STRING,
@@ -67,27 +71,27 @@ struct grpc_json_reader;
 
 typedef struct grpc_json_reader_vtable {
   /* Clears your internal string scratchpad. */
-  void (*string_clear)(void *userdata);
+  void (*string_clear)(void* userdata);
   /* Adds a char to the string scratchpad. */
-  void (*string_add_char)(void *userdata, uint32_t c);
+  void (*string_add_char)(void* userdata, uint32_t c);
   /* Adds a utf32 char to the string scratchpad. */
-  void (*string_add_utf32)(void *userdata, uint32_t c);
+  void (*string_add_utf32)(void* userdata, uint32_t c);
   /* Reads a character from your input. May be utf-8, 16 or 32. */
-  uint32_t (*read_char)(void *userdata);
+  uint32_t (*read_char)(void* userdata);
   /* Starts a container of type GRPC_JSON_ARRAY or GRPC_JSON_OBJECT. */
-  void (*container_begins)(void *userdata, grpc_json_type type);
+  void (*container_begins)(void* userdata, grpc_json_type type);
   /* Ends the current container. Must return the type of its parent. */
-  grpc_json_type (*container_ends)(void *userdata);
+  grpc_json_type (*container_ends)(void* userdata);
   /* Your internal string scratchpad is an object's key. */
-  void (*set_key)(void *userdata);
+  void (*set_key)(void* userdata);
   /* Your internal string scratchpad is a string value. */
-  void (*set_string)(void *userdata);
+  void (*set_string)(void* userdata);
   /* Your internal string scratchpad is a numerical value. Return 1 if valid. */
-  int (*set_number)(void *userdata);
+  int (*set_number)(void* userdata);
   /* Sets the values true, false or null. */
-  void (*set_true)(void *userdata);
-  void (*set_false)(void *userdata);
-  void (*set_null)(void *userdata);
+  void (*set_true)(void* userdata);
+  void (*set_false)(void* userdata);
+  void (*set_null)(void* userdata);
 } grpc_json_reader_vtable;
 
 typedef struct grpc_json_reader {
@@ -95,8 +99,8 @@ typedef struct grpc_json_reader {
    * The definition is public so you can put it on your stack.
    */
 
-  void *userdata;
-  grpc_json_reader_vtable *vtable;
+  void* userdata;
+  grpc_json_reader_vtable* vtable;
   int depth;
   int in_object;
   int in_array;
@@ -129,17 +133,21 @@ typedef enum {
  *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
  *      internal state.
  */
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader);
+grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader);
 
 /* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader *reader,
-                           grpc_json_reader_vtable *vtable, void *userdata);
+void grpc_json_reader_init(grpc_json_reader* reader,
+                           grpc_json_reader_vtable* vtable, void* userdata);
 
 /* You may call this from the read_char callback if you don't know where is the
  * end of your input stream, and you'd like the json reader to hint you that it
  * has completed reading its input, so you can return an EOF to it. Note that
  * there might still be trailing whitespaces after that point.
  */
-int grpc_json_reader_is_complete(grpc_json_reader *reader);
+int grpc_json_reader_is_complete(grpc_json_reader* reader);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_JSON_JSON_READER_H */

data/src/core/lib/json/{json_string.c → json_string.cc}

@@ -38,13 +38,13 @@
  * input size, and never expands it.
  */
 typedef struct {
-  grpc_json *top;
-  grpc_json *current_container;
-  grpc_json *current_value;
-  uint8_t *input;
-  uint8_t *key;
-  uint8_t *string;
-  uint8_t *string_ptr;
+  grpc_json* top;
+  grpc_json* current_container;
+  grpc_json* current_value;
+  uint8_t* input;
+  uint8_t* key;
+  uint8_t* string;
+  uint8_t* string_ptr;
   size_t remaining_input;
 } json_reader_userdata;
 
@@ -52,7 +52,7 @@ typedef struct {
  * The point is that we allocate that string in chunks of 256 bytes.
  */
 typedef struct {
-  char *output;
+  char* output;
   size_t free_space;
   size_t string_len;
   size_t allocated;
@@ -62,35 +62,35 @@ typedef struct {
  * and will enlarge it if necessary. We're only allocating chunks of 256
  * bytes at a time (or multiples thereof).
  */
-static void json_writer_output_check(void *userdata, size_t needed) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+static void json_writer_output_check(void* userdata, size_t needed) {
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   if (state->free_space >= needed) return;
   needed -= state->free_space;
   /* Round up by 256 bytes. */
   needed = (needed + 0xff) & ~0xffU;
-  state->output = (char *)gpr_realloc(state->output, state->allocated + needed);
+  state->output = (char*)gpr_realloc(state->output, state->allocated + needed);
   state->free_space += needed;
   state->allocated += needed;
 }
 
 /* These are needed by the writer's implementation. */
-static void json_writer_output_char(void *userdata, char c) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+static void json_writer_output_char(void* userdata, char c) {
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   json_writer_output_check(userdata, 1);
   state->output[state->string_len++] = c;
   state->free_space--;
 }
 
-static void json_writer_output_string_with_len(void *userdata, const char *str,
+static void json_writer_output_string_with_len(void* userdata, const char* str,
                                                size_t len) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   json_writer_output_check(userdata, len);
   memcpy(state->output + state->string_len, str, len);
   state->string_len += len;
   state->free_space -= len;
 }
 
-static void json_writer_output_string(void *userdata, const char *str) {
+static void json_writer_output_string(void* userdata, const char* str) {
   size_t len = strlen(str);
   json_writer_output_string_with_len(userdata, str, len);
 }
@@ -98,8 +98,8 @@ static void json_writer_output_string(void *userdata, const char *str) {
 /* The reader asks us to clear our scratchpad. In our case, we'll simply mark
  * the end of the current string, and advance our output pointer.
  */
-static void json_reader_string_clear(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_string_clear(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   if (state->string) {
     GPR_ASSERT(state->string_ptr < state->input);
     *state->string_ptr++ = 0;
@@ -107,8 +107,8 @@ static void json_reader_string_clear(void *userdata) {
   state->string = state->string_ptr;
 }
 
-static void json_reader_string_add_char(void *userdata, uint32_t c) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_string_add_char(void* userdata, uint32_t c) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   GPR_ASSERT(state->string_ptr < state->input);
   GPR_ASSERT(c <= 0xff);
   *state->string_ptr++ = (uint8_t)c;
@@ -117,7 +117,7 @@ static void json_reader_string_add_char(void *userdata, uint32_t c) {
 /* We are converting a UTF-32 character into UTF-8 here,
  * as described by RFC3629.
  */
-static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
+static void json_reader_string_add_utf32(void* userdata, uint32_t c) {
   if (c <= 0x7f) {
     json_reader_string_add_char(userdata, c);
   } else if (c <= 0x7ff) {
@@ -147,9 +147,9 @@ static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
 /* We consider that the input may be a zero-terminated string. So we
  * can end up hitting eof before the end of the alleged string length.
  */
-static uint32_t json_reader_read_char(void *userdata) {
+static uint32_t json_reader_read_char(void* userdata) {
   uint32_t r;
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
 
   if (state->remaining_input == 0) return GRPC_JSON_READ_CHAR_EOF;
 
@@ -167,9 +167,9 @@ static uint32_t json_reader_read_char(void *userdata) {
 /* Helper function to create a new grpc_json object and link it into
  * our tree-in-progress inside our opaque structure.
  */
-static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = grpc_json_create(type);
+static grpc_json* json_create_and_link(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = grpc_json_create(type);
 
   json->parent = state->current_container;
   json->prev = state->current_value;
@@ -183,7 +183,7 @@ static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
       json->parent->child = json;
     }
     if (json->parent->type == GRPC_JSON_OBJECT) {
-      json->key = (char *)state->key;
+      json->key = (char*)state->key;
     }
   }
   if (!state->top) {
@@ -193,15 +193,15 @@ static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
   return json;
 }
 
-static void json_reader_container_begins(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *container;
+static void json_reader_container_begins(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* container;
 
   GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT);
 
   container = json_create_and_link(userdata, type);
   state->current_container = container;
-  state->current_value = NULL;
+  state->current_value = nullptr;
 }
 
 /* It's important to remember that the reader is mostly stateless, so it
@@ -213,9 +213,9 @@ static void json_reader_container_begins(void *userdata, grpc_json_type type) {
  * Also note that if we're at the top of the tree, and the last container
  * ends, we have to return GRPC_JSON_TOP_LEVEL.
  */
-static grpc_json_type json_reader_container_ends(void *userdata) {
+static grpc_json_type json_reader_container_ends(void* userdata) {
   grpc_json_type container_type = GRPC_JSON_TOP_LEVEL;
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
 
   GPR_ASSERT(state->current_container);
 
@@ -235,36 +235,36 @@ static grpc_json_type json_reader_container_ends(void *userdata) {
  * Note that in the set_number case, we're not going to try interpreting it.
  * We'll keep it as a string, and leave it to the caller to evaluate it.
  */
-static void json_reader_set_key(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_set_key(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   state->key = state->string;
 }
 
-static void json_reader_set_string(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = json_create_and_link(userdata, GRPC_JSON_STRING);
-  json->value = (char *)state->string;
+static void json_reader_set_string(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_STRING);
+  json->value = (char*)state->string;
 }
 
-static int json_reader_set_number(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
-  json->value = (char *)state->string;
+static int json_reader_set_number(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
+  json->value = (char*)state->string;
   return 1;
 }
 
 /* The object types true, false and null are self-sufficient, and don't need
  * any more information beside their type.
  */
-static void json_reader_set_true(void *userdata) {
+static void json_reader_set_true(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_TRUE);
 }
 
-static void json_reader_set_false(void *userdata) {
+static void json_reader_set_false(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_FALSE);
 }
 
-static void json_reader_set_null(void *userdata) {
+static void json_reader_set_null(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_NULL);
 }
 
@@ -277,17 +277,17 @@ static grpc_json_reader_vtable reader_vtable = {
     json_reader_set_false,        json_reader_set_null};
 
 /* And finally, let's define our public API. */
-grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) {
+grpc_json* grpc_json_parse_string_with_len(char* input, size_t size) {
   grpc_json_reader reader;
   json_reader_userdata state;
-  grpc_json *json = NULL;
+  grpc_json* json = nullptr;
   grpc_json_reader_status status;
 
-  if (!input) return NULL;
+  if (!input) return nullptr;
 
-  state.top = state.current_container = state.current_value = NULL;
-  state.string = state.key = NULL;
-  state.string_ptr = state.input = (uint8_t *)input;
+  state.top = state.current_container = state.current_value = nullptr;
+  state.string = state.key = nullptr;
+  state.string_ptr = state.input = (uint8_t*)input;
   state.remaining_input = size;
   grpc_json_reader_init(&reader, &reader_vtable, &state);
 
@@ -296,7 +296,7 @@ grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) {
 
   if ((status != GRPC_JSON_DONE) && json) {
     grpc_json_destroy(json);
-    json = NULL;
+    json = nullptr;
   }
 
   return json;
@@ -304,11 +304,11 @@ grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) {
 
 #define UNBOUND_JSON_STRING_LENGTH 0x7fffffff
 
-grpc_json *grpc_json_parse_string(char *input) {
+grpc_json* grpc_json_parse_string(char* input) {
   return grpc_json_parse_string_with_len(input, UNBOUND_JSON_STRING_LENGTH);
 }
 
-static void json_dump_recursive(grpc_json_writer *writer, grpc_json *json,
+static void json_dump_recursive(grpc_json_writer* writer, grpc_json* json,
                                 int in_object) {
   while (json) {
     if (in_object) grpc_json_writer_object_key(writer, json->key);
@@ -348,11 +348,11 @@ static grpc_json_writer_vtable writer_vtable = {
     json_writer_output_char, json_writer_output_string,
     json_writer_output_string_with_len};
 
-char *grpc_json_dump_to_string(grpc_json *json, int indent) {
+char* grpc_json_dump_to_string(grpc_json* json, int indent) {
   grpc_json_writer writer;
   json_writer_userdata state;
 
-  state.output = NULL;
+  state.output = nullptr;
   state.free_space = state.string_len = state.allocated = 0;
   grpc_json_writer_init(&writer, indent, &writer_vtable, &state);
 

data/src/core/lib/json/{json_writer.c → json_writer.cc}

@@ -22,22 +22,22 @@
 
 #include "src/core/lib/json/json_writer.h"
 
-static void json_writer_output_char(grpc_json_writer *writer, char c) {
+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) {
+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) {
+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) {
+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;
@@ -45,7 +45,7 @@ void grpc_json_writer_init(grpc_json_writer *writer, int indent,
   writer->userdata = userdata;
 }
 
-static void json_writer_output_indent(grpc_json_writer *writer) {
+static void json_writer_output_indent(grpc_json_writer* writer) {
   static const char spacesstr[] =
       "                "
       "                "
@@ -73,7 +73,7 @@ static void json_writer_output_indent(grpc_json_writer *writer) {
       writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces);
 }
 
-static void json_writer_value_end(grpc_json_writer *writer) {
+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;
@@ -85,7 +85,7 @@ static void json_writer_value_end(grpc_json_writer *writer) {
   }
 }
 
-static void json_writer_escape_utf16(grpc_json_writer *writer, uint16_t utf16) {
+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);
@@ -95,8 +95,8 @@ static void json_writer_escape_utf16(grpc_json_writer *writer, uint16_t utf16) {
   json_writer_output_char(writer, hex[(utf16)&0x0f]);
 }
 
-static void json_writer_escape_string(grpc_json_writer *writer,
-                                      const char *string) {
+static void json_writer_escape_string(grpc_json_writer* writer,
+                                      const char* string) {
   json_writer_output_char(writer, '"');
 
   for (;;) {
@@ -190,7 +190,7 @@ static void json_writer_escape_string(grpc_json_writer *writer,
   json_writer_output_char(writer, '"');
 }
 
-void grpc_json_writer_container_begins(grpc_json_writer *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);
@@ -200,7 +200,7 @@ void grpc_json_writer_container_begins(grpc_json_writer *writer,
   writer->depth++;
 }
 
-void grpc_json_writer_container_ends(grpc_json_writer *writer,
+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');
@@ -211,7 +211,7 @@ void grpc_json_writer_container_ends(grpc_json_writer *writer,
   writer->got_key = 0;
 }
 
-void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string) {
+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);
@@ -219,23 +219,23 @@ void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string) {
   writer->got_key = 1;
 }
 
-void grpc_json_writer_value_raw(grpc_json_writer *writer, const char *string) {
+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) {
+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) {
+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);