Major refactoring: upb_string is gone in favor of upb_strref.

1 files changed, 47 insertions, 58 deletions

diff --git a/src/upb_strstream.c b/src/upb_strstream.c
index 284a4d7..9e17d75 100644
--- a/src/upb_strstream.c
+++ b/src/upb_strstream.c
@@ -8,61 +8,45 @@
 #include "upb_strstream.h"
 
 #include <stdlib.h>
-#include "upb_string.h"
 
 
 /* upb_stringsrc **************************************************************/
 
-static upb_strlen_t upb_stringsrc_read(upb_bytesrc *_src, void *buf,
-                                       upb_strlen_t count, upb_status *status) {
-  upb_stringsrc *src = (upb_stringsrc*)_src;
-  if (src->offset == upb_string_len(src->str)) {
-    status->code = UPB_EOF;
-    return -1;
-  } else {
-    upb_strlen_t to_read = UPB_MIN(count, upb_string_len(src->str) - src->offset);
-    memcpy(buf, upb_string_getrobuf(src->str) + src->offset, to_read);
-    src->offset += to_read;
-    return to_read;
-  }
+size_t upb_stringsrc_fetch(void *_src, uint64_t ofs, upb_status *s) {
+  upb_stringsrc *src = _src;
+  size_t bytes = src->len - ofs;
+  if (bytes == 0) s->code = UPB_EOF;
+  return bytes;
 }
 
-static bool upb_stringsrc_getstr(upb_bytesrc *_src, upb_string *str,
-                                 upb_status *status) {
-  upb_stringsrc *src = (upb_stringsrc*)_src;
-  if (src->offset == upb_string_len(src->str)) {
-    status->code = UPB_EOF;
-    return false;
-  } else {
-    upb_strlen_t len = upb_string_len(src->str) - src->offset;
-    upb_string_substr(str, src->str, src->offset, len);
-    src->offset += len;
-    assert(src->offset == upb_string_len(src->str));
-    return true;
-  }
+void upb_stringsrc_read(void *_src, uint64_t src_ofs, size_t len, char *dst) {
+  upb_stringsrc *src = _src;
+  memcpy(dst, src->str + src_ofs, len);
+}
+
+const char *upb_stringsrc_getptr(void *_src, uint64_t ofs, size_t *len) {
+  upb_stringsrc *src = _src;
+  *len = src->len - ofs;
+  return src->str + ofs;
 }
 
 void upb_stringsrc_init(upb_stringsrc *s) {
   static upb_bytesrc_vtbl vtbl = {
-    upb_stringsrc_read,
-    upb_stringsrc_getstr,
+    &upb_stringsrc_fetch,
+    &upb_stringsrc_read,
+    &upb_stringsrc_getptr,
+    NULL, NULL, NULL, NULL
   };
   upb_bytesrc_init(&s->bytesrc, &vtbl);
   s->str = NULL;
 }
 
-void upb_stringsrc_reset(upb_stringsrc *s, upb_string *str) {
-  if (str != s->str) {
-    upb_string_unref(s->str);
-    s->str = upb_string_getref(str);
-  }
-  s->offset = 0;
-}
-
-void upb_stringsrc_uninit(upb_stringsrc *s) {
-  upb_string_unref(s->str);
+void upb_stringsrc_reset(upb_stringsrc *s, const char *str, size_t len) {
+  s->str = str;
+  s->len = len;
 }
 
+void upb_stringsrc_uninit(upb_stringsrc *s) { (void)s; }
 
 upb_bytesrc *upb_stringsrc_bytesrc(upb_stringsrc *s) {
   return &s->bytesrc;
@@ -72,44 +56,49 @@ upb_bytesrc *upb_stringsrc_bytesrc(upb_stringsrc *s) {
 /* upb_stringsink *************************************************************/
 
 void upb_stringsink_uninit(upb_stringsink *s) {
-  upb_string_unref(s->str);
+  free(s->str);
 }
 
 // Resets the stringsink to a state where it will append to the given string.
 // The string must be newly created or recycled.  The stringsink will take a
 // reference on the string, so the caller need not ensure that it outlives the
 // stringsink.  A stringsink can be reset multiple times.
-void upb_stringsink_reset(upb_stringsink *s, upb_string *str) {
-  if (str != s->str) {
-    upb_string_unref(s->str);
-    s->str = upb_string_getref(str);
-  }
-  // Resize to 0.
-  upb_string_getrwbuf(s->str, 0);
+void upb_stringsink_reset(upb_stringsink *s, char *str, size_t size) {
+  free(s->str);
+  s->str = str;
+  s->len = 0;
+  s->size = size;
 }
 
 upb_bytesink *upb_stringsink_bytesink(upb_stringsink *s) {
   return &s->bytesink;
 }
 
-static upb_strlen_t upb_stringsink_vprintf(upb_bytesink *_sink, upb_status *s,
-                                           const char *fmt, va_list args) {
-  (void)s;  // No errors can occur.
-  upb_stringsink *sink = (upb_stringsink*)_sink;
-  return upb_string_vprintf_at(sink->str, upb_string_len(sink->str), fmt, args);
+static int32_t upb_stringsink_vprintf(void *_s, upb_status *status,
+                                      const char *fmt, va_list args) {
+  (void)status;  // TODO: report realloc() errors.
+  upb_stringsink *s = _s;
+  int ret = upb_vrprintf(&s->str, &s->size, s->len, fmt, args);
+  if (ret >= 0) s->len += ret;
+  return ret;
 }
 
-static upb_strlen_t upb_stringsink_putstr(upb_bytesink *_sink, upb_string *str,
-                                          upb_status *s) {
-  (void)s;  // No errors can occur.
-  upb_stringsink *sink = (upb_stringsink*)_sink;
-  upb_strcat(sink->str, str);
-  return upb_string_len(str);
+bool upb_stringsink_write(void *_s, const char *buf, size_t len,
+                          upb_status *status) {
+  (void)status;  // TODO: report realloc() errors.
+  upb_stringsink *s = _s;
+  if (s->len + len > s->size) {
+    while(s->len + len > s->size) s->size *= 2;
+    s->str = realloc(s->str, s->size);
+  }
+  memcpy(s->str + s->len, buf, len);
+  s->len += len;
+  return true;
 }
 
 void upb_stringsink_init(upb_stringsink *s) {
   static upb_bytesink_vtbl vtbl = {
-    upb_stringsink_putstr,
+    upb_stringsink_write,
     upb_stringsink_vprintf
   };
   upb_bytesink_init(&s->bytesink, &vtbl);