Move string writing functions to stage 2

jkeiser · jkeiser · commit 6da709a2a5df · 2020-05-07T14:30:27.000-07:00
diff --git a/include/simdjson/document.h b/include/simdjson/document.h
@@ -1019,14 +1019,16 @@ class parser {
   really_inline bool on_true_atom() noexcept; ///< @private
   really_inline bool on_false_atom() noexcept; ///< @private
   really_inline bool on_null_atom() noexcept; ///< @private
-  really_inline uint8_t *on_start_string() noexcept; ///< @private
-  really_inline bool on_end_string(uint8_t *dst) noexcept; ///< @private
+  really_inline void write_string_length(uint32_t length) noexcept; ///< @private
   really_inline bool on_number_s64(int64_t value) noexcept; ///< @private
   really_inline bool on_number_u64(uint64_t value) noexcept; ///< @private
   really_inline bool on_number_double(double value) noexcept; ///< @private
 
   really_inline void increment_count(uint32_t depth) noexcept; ///< @private
   really_inline void end_scope(uint32_t depth) noexcept; ///< @private
+
+  really_inline void write_tape(uint64_t val, internal::tape_type t) noexcept;
+
 private:
   /**
    * The maximum document length this parser will automatically support.
@@ -1071,8 +1073,6 @@ class parser {
   //
   //
 
-  inline void write_tape(uint64_t val, internal::tape_type t) noexcept;
-
   /**
    * Ensure we have enough capacity to handle at least desired_capacity bytes,
    * and auto-allocate if not.
diff --git a/src/document_parser_callbacks.h b/src/document_parser_callbacks.h
@@ -86,24 +86,11 @@ really_inline bool parser::on_null_atom() noexcept {
   return true;
 }
 
-really_inline uint8_t *parser::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.string_buf.get(), internal::tape_type::STRING);
-  return current_string_buf_loc + sizeof(uint32_t);
-}
-
-really_inline bool parser::on_end_string(uint8_t *dst) noexcept {
-  uint32_t str_length = uint32_t(dst - (current_string_buf_loc + sizeof(uint32_t)));
+really_inline void parser::write_string_length(uint32_t str_length) noexcept {
   // 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));
-  // 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;
-  return true;
 }
 
 really_inline bool parser::on_number_s64(int64_t value) noexcept {
diff --git a/src/generic/stage2_build_tape.h b/src/generic/stage2_build_tape.h
@@ -163,12 +163,20 @@ struct structural_parser {
   }
 
   WARN_UNUSED really_inline bool parse_string() {
-    uint8_t *dst = doc_parser.on_start_string();
+    /* we advance the point, accounting for the fact that we have a NULL
+      * termination         */
+    doc_parser.write_tape(doc_parser.current_string_buf_loc - doc_parser.doc.string_buf.get(), internal::tape_type::STRING);
+    uint8_t *dst = doc_parser.current_string_buf_loc + sizeof(uint32_t);
     dst = stringparsing::parse_string(structurals.current(), dst);
     if (dst == nullptr) {
       return true;
     }
-    return !doc_parser.on_end_string(dst);
+    uint32_t str_length = uint32_t(dst - (doc_parser.current_string_buf_loc + sizeof(uint32_t)));
+    // doc_parser.write_string_length(str_length);
+    memcpy(doc_parser.current_string_buf_loc, &str_length, sizeof(uint32_t));
+    *dst = 0;
+    doc_parser.current_string_buf_loc = dst + 1;
+    return false;
   }
 
   WARN_UNUSED really_inline bool parse_number(const uint8_t *src, bool found_minus) {
