reduce calling mrb_str_new_cstr() to avoid strlen(); #301

src/class.c

@@ -972,15 +972,23 @@ mrb_class_path(mrb_state *mrb, struct RClass *c)
     struct RClass *outer = mrb_class_outer_module(mrb, c);
     mrb_sym sym = class_sym(mrb, c, outer);
     if (outer && outer != mrb->object_class) {
+      char *name;
+      int len;
+
       mrb_value base = mrb_class_path(mrb, outer);
-      path = mrb_str_plus(mrb, base, mrb_str_new_cstr(mrb, "::"));
-      mrb_str_concat(mrb, path, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym)));
+      path = mrb_str_plus(mrb, base, mrb_str_new(mrb, "::", 2));
+      name = mrb_sym2name_len(mrb, sym, &len);
+      mrb_str_concat(mrb, path, mrb_str_new(mrb, name, len));
     }
     else if (sym == 0) {
       return mrb_nil_value();
     }
     else {
-      path = mrb_str_new_cstr(mrb, mrb_sym2name(mrb, sym));
+      char *name;
+      int len;
+
+      name = mrb_sym2name_len(mrb, sym, &len);
+      path = mrb_str_new(mrb, name, len);
     }
     mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern(mrb, "__classpath__"), path);
   }
@@ -1114,9 +1122,8 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const
 static mrb_value
 mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
 {
-  //if (FL_TEST(klass, FL_SINGLETON)) {
   if (mrb_type(klass) == MRB_TT_SCLASS) {
-    mrb_value s = mrb_str_new_cstr(mrb, "#<");
+    mrb_value s = mrb_str_new(mrb, "#<", 2);
     mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__"));
 
     mrb_str_cat2(mrb, s, "Class:");

src/codegen.c

@@ -1534,10 +1534,11 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_BACK_REF:
     {
       char buf[4];
+      int len;
       int sym;
 
-      snprintf(buf, 3, "$%c", (int)(intptr_t)tree);
-      sym = new_sym(s, mrb_intern(s->mrb, buf));
+      len = snprintf(buf, 3, "$%c", (int)(intptr_t)tree);
+      sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
     }
@@ -1546,10 +1547,11 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_NTH_REF:
     {
       char buf[4];
+      int len;
       int sym;
 
-      snprintf(buf, 3, "$%d", (int)(intptr_t)tree);
-      sym = new_sym(s, mrb_intern(s->mrb, buf));
+      len = snprintf(buf, 3, "$%d", (int)(intptr_t)tree);
+      sym = new_sym(s, mrb_intern2(s->mrb, buf, len));
       genop(s, MKOP_ABx(OP_GETGLOBAL, cursp(), sym));
       push();
     }

src/hash.c

@@ -889,9 +889,9 @@ inspect_hash(mrb_state *mrb, mrb_value hash, int recur)
   khash_t(ht) *h = RHASH_TBL(hash);
   khiter_t k;
 
-  if (recur) return mrb_str_new_cstr(mrb, "{...}");
+  if (recur) return mrb_str_new(mrb, "{...}", 5);
 
-  str = mrb_str_new_cstr(mrb, "{");
+  str = mrb_str_new(mrb, "{", 1);
   if (h && kh_size(h) > 0) {
     for (k = kh_begin(h); k != kh_end(h); k++) {
       int ai;
@@ -934,7 +934,7 @@ mrb_hash_inspect(mrb_state *mrb, mrb_value hash)
   khash_t(ht) *h = RHASH_TBL(hash);
 
   if (!h || kh_size(h) == 0)
-    return mrb_str_new_cstr(mrb, "{}");
+    return mrb_str_new(mrb, "{}", 2);
   return inspect_hash(mrb, hash, 0);
 }
 

src/kernel.c

@@ -117,7 +117,7 @@ mrb_obj_inspect(mrb_state *mrb, mrb_value obj)
     return mrb_any_to_s(mrb, obj);
   }
   else if (mrb_nil_p(obj)) {
-    return mrb_str_new_cstr(mrb, "nil");
+    return mrb_str_new(mrb, "nil", 3);
   }
   return mrb_funcall(mrb, obj, "to_s", 0, 0);
 }

src/object.c

@@ -151,7 +151,7 @@ true_xor(mrb_state *mrb, mrb_value obj)
 static mrb_value
 true_to_s(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_str_new_cstr(mrb, "true");
+  return mrb_str_new(mrb, "true", 4);
 }
 
 /* 15.2.5.3.4  */
@@ -264,7 +264,7 @@ false_or(mrb_state *mrb, mrb_value obj)
 static mrb_value
 false_to_s(mrb_state *mrb, mrb_value obj)
 {
-    return mrb_str_new_cstr(mrb, "false");
+  return mrb_str_new(mrb, "false", 5);
 }
 
 void
@@ -462,9 +462,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
   len = strlen(cname)+6+16;
   str = mrb_str_new(mrb, 0, len); /* 6:tags 16:addr */
   s = mrb_str_ptr(str);
-  //  snprintf(RSTRING(str)->ptr, len+1, "#<%s:0x%lx>", cname, obj);
-  sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
-  s->len = strlen(s->ptr);
+  s->len = sprintf(s->ptr, "#<%s:0x%lx>", cname, (unsigned long)(obj.value.p));
 
   return str;
 }

src/re.c

@@ -354,10 +354,10 @@ mrb_reg_options(mrb_state *mrb, mrb_value re)
 static mrb_value
 mrb_reg_desc(mrb_state *mrb, const char *s, long len, mrb_value re)
 {
-  mrb_value str = mrb_str_new_cstr(mrb, "/");//mrb_str_buf_new2("/");
+  mrb_value str = mrb_str_new(mrb, "/", 1);
 
   mrb_reg_expr_str(mrb, str, s, len);
-  mrb_str_buf_cat(mrb, str, "/", sizeof("/"));
+  mrb_str_buf_cat(mrb, str, "/", 1);
   if (re.tt) {
     char opts[4];
     mrb_reg_check(mrb, re);
@@ -1688,9 +1688,10 @@ mrb_reg_expr_str(mrb_state *mrb, mrb_value str, const char *s, long len)
       }
       else if (!ISSPACE(c)) {
         char b[8];
+	int n;
 
-        snprintf(b, sizeof(b), "\\x%02X", c);
-        mrb_str_buf_cat(mrb, str, b, 4);
+        n = snprintf(b, sizeof(b), "\\x%02X", c);
+        mrb_str_buf_cat(mrb, str, b, n);
       }
       else {
         mrb_str_buf_cat(mrb, str, p, 1);
@@ -1728,7 +1729,7 @@ mrb_reg_to_s(mrb_state *mrb, mrb_value re)
   const int embeddable = ONIG_OPTION_MULTILINE|ONIG_OPTION_IGNORECASE|ONIG_OPTION_EXTEND;
   long len;
   const UChar* ptr;
-  mrb_value str = mrb_str_new_cstr(mrb, "(?");
+  mrb_value str = mrb_str_new(mrb, "(?", 2);
   char optbuf[5];
   mrb_encoding *enc = mrb_enc_get(mrb, re);
 
@@ -1918,7 +1919,7 @@ mrb_match_inspect(mrb_state *mrb, mrb_value match)
     onig_foreach_name(regexp->ptr,
             match_inspect_name_iter, names);
 
-    str = mrb_str_new_cstr(mrb, "#<");//mrb_str_buf_new2("#<");
+    str = mrb_str_new(mrb, "#<", 2);
     mrb_str_buf_cat(mrb, str, cname, strlen(cname));
 
     for (i = 0; i < num_regs; i++) {

src/sprintf.c

@@ -1061,6 +1061,8 @@ static void
 fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
 {
     char *end = buf + size;
+    int n;
+
     *buf++ = '%';
     if (flags & FSHARP) *buf++ = '#';
     if (flags & FPLUS)  *buf++ = '+';
@@ -1069,13 +1071,13 @@ fmt_setup(char *buf, size_t size, int c, int flags, int width, int prec)
     if (flags & FSPACE) *buf++ = ' ';
 
     if (flags & FWIDTH) {
-      snprintf(buf, end - buf, "%d", width);
-      buf += strlen(buf);
+      n = snprintf(buf, end - buf, "%d", width);
+      buf += n;
     }
 
     if (flags & FPREC) {
-      snprintf(buf, end - buf, ".%d", prec);
-      buf += strlen(buf);
+      n = snprintf(buf, end - buf, ".%d", prec);
+      buf += n;
     }
 
     *buf++ = c;

src/string.c

@@ -2517,6 +2517,7 @@ bad:
       printf("Integer");
   return mrb_fixnum_value(0);
 }
+
 char *
 mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr)
 {
@@ -2535,10 +2536,8 @@ mrb_str_to_inum(mrb_state *mrb, mrb_value str, int base, int badcheck)
   char *s;
   int len;
 
-  //StringValue(str);
   mrb_string_value(mrb, &str);
   if (badcheck) {
-    //s = StringValueCStr(str);
     s = mrb_string_value_cstr(mrb, &str);
   }
   else {
@@ -2949,7 +2948,7 @@ mrb_str_inspect(mrb_state *mrb, mrb_value str)
 {
     const char *p, *pend;
     char buf[CHAR_ESC_LEN + 1];
-    mrb_value result = mrb_str_new_cstr(mrb, "\"");
+    mrb_value result = mrb_str_new(mrb, "\"", 1);
 
     p = RSTRING_PTR(str); pend = RSTRING_END(str);
     for (;p < pend; p++) {

src/struct.c

@@ -521,8 +521,11 @@ inspect_struct(mrb_state *mrb, mrb_value s, mrb_value dummy, int recur)
       slot = ptr_members[i];
       id = SYM2ID(slot);
       if (mrb_is_local_id(id) || mrb_is_const_id(id)) {
-        //mrb_str_append(str, mrb_id2str(id));
-        mrb_str_append(mrb, str, mrb_str_new_cstr(mrb, mrb_sym2name(mrb, id)));
+	char *name;
+	int len;
+
+	name = mrb_sym2name_len(mrb, id, &len);
+        mrb_str_append(mrb, str, mrb_str_new(mrb, name, len));
       }
       else {
           mrb_str_append(mrb, str, mrb_inspect(mrb, slot));
@@ -804,9 +807,7 @@ mrb_init_struct(mrb_state *mrb)
 {
   struct RClass *st;
   st = mrb_define_class(mrb, "Struct",  mrb->object_class);
-  //mrb_include_module(mrb_cStruct, rb_mEnumerable);
 
-  //mrb_undef_alloc_func(mrb_cStruct);
   mrb_define_class_method(mrb, st, "new",             mrb_struct_s_def,       ARGS_ANY());  /* 15.2.18.3.1  */
 
   mrb_define_method(mrb, st,       "==",              mrb_struct_equal,       ARGS_REQ(1)); /* 15.2.18.4.1  */

src/time.c

@@ -430,16 +430,17 @@ mrb_time_asctime(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
   struct tm *d;
   char buf[256];
+  int len;
 
   tm = mrb_get_datatype(mrb, self, &mrb_time_type);
   if (!tm) return mrb_nil_value();
   d = &tm->datetime;
-  snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d",
-	   wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, 
-	   d->tm_hour, d->tm_min, d->tm_sec,
-	   tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
-	   d->tm_year + 1900);
-  return mrb_str_new_cstr(mrb, buf);
+  len = snprintf(buf, 256, "%s %s %02d %02d:%02d:%02d %s%d",
+		 wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday, 
+		 d->tm_hour, d->tm_min, d->tm_sec,
+		 tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
+		 d->tm_year + 1900);
+  return mrb_str_new(mrb, buf, len);
 }
 
 /* 15.2.19.7.6 */

src/vm.c

@@ -292,10 +292,11 @@ static void
 localjump_error(mrb_state *mrb, const char *kind)
 {
   char buf[256];
+  int len;
   mrb_value exc;
 
-  snprintf(buf, 256, "unexpected %s", kind);
-  exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, strlen(buf));
+  len = snprintf(buf, 256, "unexpected %s", kind);
+  exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, buf, len);
   mrb->exc = (struct RObject*)mrb_object(exc);
 }
 
@@ -303,18 +304,19 @@ static void
 argnum_error(mrb_state *mrb, int num)
 {
   char buf[256];
+  int len;
   mrb_value exc;
 
   if (mrb->ci->mid) {
-    snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)",
-	     mrb_sym2name(mrb, mrb->ci->mid),
-	     mrb->ci->argc, num);
+    len = snprintf(buf, 256, "'%s': wrong number of arguments (%d for %d)",
+		   mrb_sym2name(mrb, mrb->ci->mid),
+		   mrb->ci->argc, num);
   }
   else {
-    snprintf(buf, 256, "wrong number of arguments (%d for %d)",
-	     mrb->ci->argc, num);
+    len = snprintf(buf, 256, "wrong number of arguments (%d for %d)",
+		   mrb->ci->argc, num);
   }
-  exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, strlen(buf));
+  exc = mrb_exc_new(mrb, E_ARGUMENT_ERROR, buf, len);
   mrb->exc = (struct RObject*)mrb_object(exc);
 }