buf: alternative constructor with C type arguments.

Many functions call make_buf, having to convert C
types to the Lisp arguments using num or unum. Those conversions
immediately get undone inside make_buf, and are subject
to a wasteful type check.

* buf.c (make_buf_fast): New function.

* buf.h (make_buf): Misleading parameter renamed.
(make_buf_fast): Declared.
(sub_buf, buf_list, make_buf_stream, buf_fash,
buf_and, buf_trunc): Replace make_buf with make_buf_fast.

* lib.c (seq_build_init): Likewise.

* ffi.c (ffi_put): Likewise.

* stream.c (get_line_as_buf, iobuf_get): Likewise.

* parser.y (buflit, buflit_items): Likewise.

* y.tab.c.shipped: Regenerated.

7 files changed, 32 insertions, 19 deletions

diff --git a/buf.c b/buf.c
index 73695e7d..9d3380b8 100644
--- a/buf.c
+++ b/buf.c
@@ -229,6 +229,20 @@ val make_buf(val len, val init_pat, val alloc_size)
   return obj;
 }
 
+val make_buf_fast(ucnum len, int init_val, ucnum alloc_size)
+{
+  val obj = make_obj();
+  bug_unless (alloc_size != BUF_BORROWED);
+  if (alloc_size == 0)
+    alloc_size = len;
+  obj->b.type = BUF;
+  obj->b.data = chk_malloc(alloc_size);
+  obj->b.len = len;
+  obj->b.size = alloc_size;
+  memset(obj->b.data, init_val, len);
+  return obj;
+}
+
 val bufp(val object)
 {
   return tnil(type(object) == BUF);
@@ -460,7 +474,7 @@ val sub_buf(val buf, val from, val to)
   to = max2(zero, min2(to, len));
 
   if (ge(from, to)) {
-    return make_buf(zero, nil, zero);
+    return make_buf_fast(0, 0, 0);
   } else if (from == zero && to == len) {
     return buf;
   } else {
@@ -591,7 +605,7 @@ val replace_buf(val buf, val items, val from, val to)
 val buf_list(val list)
 {
   val self = lit("buf-list");
-  val buf = make_buf(zero, zero, num_fast(32));
+  val buf = make_buf_fast(0, 0, 32);
   struct buf *b = us_buf_handle(buf);
   seq_iter_t iter;
   val elem;
@@ -1396,7 +1410,7 @@ val make_buf_stream(val buf_opt)
 {
   val self = lit("make-buf-stream");
   val stream;
-  val buf = default_arg(buf_opt, make_buf(zero, zero, num_fast(64)));
+  val buf = default_arg(buf_opt, make_buf_fast(0, 0, 64));
   struct buf_strm *s = coerce(struct buf_strm *, chk_malloc(sizeof *s));
 
   (void) buf_handle(buf, self);
@@ -1755,8 +1769,7 @@ val buf_fash(val buf, val bits)
     ucnum bytes = b / 8;
 
     if (bytes >= len) {
-      val len = unum(bh->len);
-      return make_buf(len, zero, len);
+      return make_buf_fast(bh->len, 0, bh->len);
     } else {
       ucnum r = b % 8;
       unsigned acc = 0;
@@ -1780,8 +1793,7 @@ val buf_fash(val buf, val bits)
     ucnum bytes = (-b) / 8;
 
     if (bytes >= len) {
-      val len = unum(bh->len);
-      return make_buf(len, zero, len);
+      return make_buf_fast(bh->len, 0, bh->len);
     } else {
       ucnum r = (-b) % 8;
       unsigned acc = 0;
@@ -1815,9 +1827,9 @@ val buf_and(val bufa, val bufb)
   ucnum lb = bb->len;
 
   if (la == 0) {
-    return make_buf(unum(bb->len), zero, unum(bb->len));
+    return make_buf_fast(bb->len, 0, bb->len);
   } else if (lb == 0) {
-    return make_buf(unum(ab->len), zero, unum(ab->len));
+    return make_buf_fast(ab->len, 0, ab->len);
   } else if (la < lb) {
     return buf_and(bufb, bufa);
   } else {
@@ -1946,7 +1958,7 @@ val buf_trunc(val buf, val bits)
   ucnum l = bh->len;
 
   if (b <= 0) {
-    return make_buf(zero, nil, zero);
+    return make_buf_fast(0, 0, 0);;
   } else {
     ucnum bytes = (b + 7) / 8;
     val obuf = make_ubuf(bytes);
diff --git a/buf.h b/buf.h
index af574f74..8922339d 100644
--- a/buf.h
+++ b/buf.h
@@ -26,7 +26,8 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-val make_buf(val len, val init_val, val alloc_size);
+val make_buf(val len, val init_pat, val alloc_size);
+val make_buf_fast(ucnum len, int init_val, ucnum alloc_size);
 val bufp(val object);
 val make_borrowed_buf(ucnum len, mem_t *data);
 val init_borrowed_buf(obj_t *buf, ucnum len, mem_t *data);
diff --git a/ffi.c b/ffi.c
index 239c8d3c..6b6c448f 100644
--- a/ffi.c
+++ b/ffi.c
@@ -5855,7 +5855,7 @@ val ffi_put(val obj, val type)
 {
   val self = lit("ffi-put");
   struct txr_ffi_type *tft = ffi_type_struct_checked(self, type);
-  val buf = make_buf(num(tft->dynsize(tft, obj, self)), zero, nil);
+  val buf = make_buf_fast(tft->dynsize(tft, obj, self), 0, 0);
   mem_t *dst = buf_get(buf, self);
   tft->put(tft, obj, dst, self);
   return buf;
diff --git a/lib.c b/lib.c
index 5babae42..bd647111 100644
--- a/lib.c
+++ b/lib.c
@@ -1777,7 +1777,7 @@ void seq_build_init(val self, seq_build_t *bu, val likeobj)
     bu->ops = &sb_str_ops;
     break;
   case BUF:
-    bu->obj = make_buf(zero, zero, num_fast(32));
+    bu->obj = make_buf_fast(0, 0, 32);
     bu->ops = &sb_buf_ops;
     break;
   case COBJ:
diff --git a/parser.y b/parser.y
index e183a95e..0d2a4da0 100644
--- a/parser.y
+++ b/parser.y
@@ -1462,7 +1462,7 @@ wordsqlit : '`'                  { $$ = nil; }
                                    $$ = rlc(cons(qword, $3), $1); }
           ;
 
-buflit : HASH_B_QUOTE '\''               { $$ = make_buf(zero, nil, nil);
+buflit : HASH_B_QUOTE '\''               { $$ = make_buf_fast(0, 0, 0);
                                            end_of_buflit(scnr); }
        | HASH_B_QUOTE buflit_items '\''  { end_of_buflit(scnr);
                                            buf_trim($2);
@@ -1474,7 +1474,7 @@ buflit : HASH_B_QUOTE '\''               { $$ = make_buf(zero, nil, nil);
 
 buflit_items : buflit_items buflit_item { buf_put_u8($1, length_buf($$), $2);
                                           $$ = $1; }
-             | buflit_item              { $$ = make_buf(zero, nil, num_fast(512));
+             | buflit_item              { $$ = make_buf_fast(0, 0, 512);
                                           buf_put_u8($$, zero, $1); }
              ;
 
diff --git a/stream.c b/stream.c
index e6dfd24d..a9f37427 100644
--- a/stream.c
+++ b/stream.c
@@ -3483,7 +3483,7 @@ val get_line_as_buf(val stream_in)
   val stream = default_arg_strict(stream_in, std_input);
   struct strm_ops *ops = coerce(struct strm_ops *,
                                 cobj_ops(self, stream, stream_cls));
-  val buf = make_buf(zero, nil, num_fast(128));
+  val buf = make_buf_fast(0, 0, 128);
   unsigned char bytes[128];
   size_t count = 0;
 
@@ -5941,7 +5941,7 @@ val iobuf_get(void)
     iobuf_free_list = next;
     return buf;
   } else {
-    return make_buf(num_fast(BUFSIZ), nil, nil);
+    return make_buf_fast(BUFSIZ, 0, BUFSIZ);
   }
 }
 
diff --git a/y.tab.c.shipped b/y.tab.c.shipped
index f3433f68..ecfd5b97 100644
--- a/y.tab.c.shipped
+++ b/y.tab.c.shipped
@@ -6807,7 +6807,7 @@ yyreduce:
 
 /* Line 1806 of yacc.c  */
 #line 1465 "parser.y"
-    { (yyval.val) = make_buf(zero, nil, nil);
+    { (yyval.val) = make_buf_fast(0, 0, 0);
                                            end_of_buflit(scnr); }
     break;
 
@@ -6841,7 +6841,7 @@ yyreduce:
 
 /* Line 1806 of yacc.c  */
 #line 1477 "parser.y"
-    { (yyval.val) = make_buf(zero, nil, num_fast(512));
+    { (yyval.val) = make_buf_fast(0, 0, 512);
                                           buf_put_u8((yyval.val), zero, (yyvsp[(1) - (1)].val)); }
     break;