Store current_string_buf_loc in doc_parser

jkeiser · jkeiser · commit 856d3622cec8 · 2020-05-21T09:48:21.000-07:00
diff --git a/include/simdjson/dom/parser.h b/include/simdjson/dom/parser.h
@@ -349,6 +349,8 @@ class parser {
 
   /** @private Next location to write to in the tape */
   uint32_t current_loc{0};
+  /** @private Current location in string buffer */
+  uint8_t *current_string_buf_loc;
 
   /** @private Number of structural indices passed from stage 1 to stage 2 */
   uint32_t n_structural_indexes{0};
diff --git a/src/generic/stage2/streaming_structural_parser.h b/src/generic/stage2/streaming_structural_parser.h
@@ -1,7 +1,12 @@
 namespace stage2 {
 
 struct streaming_structural_parser: structural_parser {
-  really_inline streaming_structural_parser(const uint8_t *buf, size_t len, parser &_doc_parser, size_t &next_structural, uint8_t *&_current_string_buf_loc) : structural_parser(buf, len, _doc_parser, next_structural, _current_string_buf_loc) {}
+  really_inline streaming_structural_parser(
+    const uint8_t *buf,
+    size_t len,
+    parser &_doc_parser,
+    size_t &next_structural
+  ) : structural_parser(buf, len, _doc_parser, next_structural) {}
 
   // override to add streaming
   WARN_UNUSED really_inline error_code start(UNUSED size_t len) {
@@ -41,8 +46,7 @@ struct streaming_structural_parser: structural_parser {
  * for documentation.
  ***********/
 WARN_UNUSED error_code implementation::stage2(const uint8_t *buf, size_t len, parser &doc_parser, size_t &next_json) const noexcept {
-  uint8_t *current_string_buf_loc = doc_parser.doc.string_buf.get();
-  stage2::streaming_structural_parser parser(buf, len, doc_parser, next_json, current_string_buf_loc);
+  stage2::streaming_structural_parser parser(buf, len, doc_parser, next_json);
   error_code result = parser.start(len);
   if (result) { return result; }
 
diff --git a/src/generic/stage2/structural_parser.h b/src/generic/stage2/structural_parser.h
@@ -31,31 +31,25 @@ struct number_writer {
 struct structural_parser {
   structural_iterator structurals;
   parser &doc_parser;
-  /** Next write location in the string buf for stage 2 parsing */
-  uint8_t *&current_string_buf_loc;
   uint32_t depth;
 
   really_inline structural_parser(
     const uint8_t *buf,
     size_t len,
     parser &_doc_parser,
-    size_t &next_structural,
-    uint8_t *&_current_string_buf_loc
+    size_t &next_structural
   ) : structurals(buf, len, _doc_parser.structural_indexes.get(), next_structural),
       doc_parser{_doc_parser},
-      current_string_buf_loc{_current_string_buf_loc},
       depth{0} {
   }
 
   really_inline structural_parser(
     const uint8_t *buf,
     parser &_doc_parser,
     size_t &next_structural,
-    uint8_t *&_current_string_buf_loc,
     uint32_t _depth
   ) : structurals(buf, 0, _doc_parser.structural_indexes.get(), next_structural),
       doc_parser{_doc_parser},
-      current_string_buf_loc{_current_string_buf_loc},
       depth{_depth} {
   }
 
@@ -112,20 +106,20 @@ struct structural_parser {
 
   really_inline uint8_t *on_start_string() noexcept {
     // we advance the point, accounting for the fact that we have a NULL termination
-    write_tape(current_string_buf_loc - doc_parser.doc.string_buf.get(), internal::tape_type::STRING);
-    return current_string_buf_loc + sizeof(uint32_t);
+    write_tape(doc_parser.current_string_buf_loc - doc_parser.doc.string_buf.get(), internal::tape_type::STRING);
+    return doc_parser.current_string_buf_loc + sizeof(uint32_t);
   }
 
   really_inline void on_end_string(uint8_t *dst) noexcept {
-    uint32_t str_length = uint32_t(dst - (current_string_buf_loc + sizeof(uint32_t)));
+    uint32_t str_length = uint32_t(dst - (doc_parser.current_string_buf_loc + sizeof(uint32_t)));
     // TODO check for overflow in case someone has a crazy string (>=4GB?)
     // But only add the overflow check when the document itself exceeds 4GB
     // Currently unneeded because we refuse to parse docs larger or equal to 4GB.
-    memcpy(current_string_buf_loc, &str_length, sizeof(uint32_t));
+    memcpy(doc_parser.current_string_buf_loc, &str_length, sizeof(uint32_t));
     // NULL termination is still handy if you expect all your strings to
     // be NULL terminated? It comes at a small cost
     *dst = 0;
-    current_string_buf_loc = dst + 1;
+    doc_parser.current_string_buf_loc = dst + 1;
   }
 
   WARN_UNUSED really_inline bool parse_string(bool key = false) {
@@ -250,19 +244,17 @@ struct structural_parser {
   }
 
   WARN_UNUSED really_inline bool parse_object() {
-    return parse_object(structurals.buf, doc_parser, structurals.next_structural, current_string_buf_loc, depth+1);
+    return parse_object(structurals.buf, doc_parser, structurals.next_structural, depth+1);
   }
 
   WARN_UNUSED static bool parse_object(
       const uint8_t *buf,
       parser &doc_parser,
       size_t &next_structural,
-      uint8_t *&current_string_buf_loc,
       uint32_t depth) {
-    structural_parser parser(buf, doc_parser, next_structural, current_string_buf_loc, depth);
+    structural_parser parser(buf, doc_parser, next_structural, depth);
     bool result = parser.parse_object_inline();
     next_structural = parser.structurals.next_structural;
-    current_string_buf_loc = parser.current_string_buf_loc;
     return result;
   }
 
@@ -310,19 +302,17 @@ struct structural_parser {
   }
 
   WARN_UNUSED really_inline bool parse_array() {
-    return parse_array(structurals.buf, doc_parser, structurals.next_structural, current_string_buf_loc, depth+1);
+    return parse_array(structurals.buf, doc_parser, structurals.next_structural, depth+1);
   }
 
   WARN_UNUSED static bool parse_array(
       const uint8_t *buf,
       parser &doc_parser,
       size_t &next_structural,
-      uint8_t *&current_string_buf_loc,
       uint32_t depth) {
-    structural_parser parser(buf, doc_parser, next_structural, current_string_buf_loc, depth);
+    structural_parser parser(buf, doc_parser, next_structural, depth);
     bool result = parser.parse_array_inline();
     next_structural = parser.structurals.next_structural;
-    current_string_buf_loc = parser.current_string_buf_loc;
     return result;
   }
 
@@ -361,10 +351,6 @@ struct structural_parser {
       return on_error(TAPE_ERROR);
     }
     end_document(0, 1);
-    if (depth != 0) {
-      log_error("Unclosed objects or arrays!");
-      return on_error(TAPE_ERROR);
-    }
 
     return on_success(SUCCESS);
   }
@@ -420,7 +406,7 @@ struct structural_parser {
   }
 
   really_inline void init() {
-    current_string_buf_loc = doc_parser.doc.string_buf.get();
+    doc_parser.current_string_buf_loc = doc_parser.doc.string_buf.get();
     doc_parser.current_loc = 0;
     doc_parser.valid = false;
     doc_parser.error = UNINITIALIZED;
@@ -476,8 +462,7 @@ struct structural_parser {
  ***********/
 WARN_UNUSED error_code implementation::stage2(const uint8_t *buf, size_t len, parser &doc_parser) const noexcept {
   size_t next_structural = 0;
-  uint8_t *current_string_buf_loc = doc_parser.doc.string_buf.get();
-  stage2::structural_parser parser(buf, len, doc_parser, next_structural, current_string_buf_loc);
+  stage2::structural_parser parser(buf, len, doc_parser, next_structural);
   error_code result = parser.start(len);
   if (result) { return result; }
 
