Ignore:
Timestamp:
Jul 9, 2020, 8:51:43 AM (4 years ago)
Author:
coas-nagasima
Message:

mrubyを2.1.1に更新

Location:
EcnlProtoTool/trunk/mruby-2.1.1
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-sprintf/src/sprintf.c

    r331 r439  
    77#include <mruby.h>
    88
     9#ifdef MRB_DISABLE_STDIO
     10# error sprintf conflicts 'MRB_DISABLE_STDIO' configuration in your 'build_config.rb'
     11#endif
     12
    913#include <limits.h>
    10 #include <stdio.h>
    1114#include <string.h>
    1215#include <mruby/string.h>
    1316#include <mruby/hash.h>
    1417#include <mruby/numeric.h>
     18#ifndef MRB_WITHOUT_FLOAT
    1519#include <math.h>
     20#endif
    1621#include <ctype.h>
    1722
    … …  
    2025#define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n)))
    2126
    22 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
     27mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value);
     28#ifndef MRB_WITHOUT_FLOAT
    2329static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int);
     30#endif
    2431
    2532static char*
    … …  
    7885
    7986  if (base != 2) {
    80     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base));
     87    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %d", base);
    8188  }
    8289  if (val == 0) {
    … …  
    116123
    117124#define CHECK(l) do {\
    118 /*  int cr = ENC_CODERANGE(result);*/\
    119125  while ((l) >= bsiz - blen) {\
     126    if (bsiz > MRB_INT_MAX/2) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \
    120127    bsiz*=2;\
    121     if (bsiz < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \
    122128  }\
    123129  mrb_str_resize(mrb, result, bsiz);\
    124 /*  ENC_CODERANGE_SET(result, cr);*/\
    125130  buf = RSTRING_PTR(result);\
    126131} while (0)
    … …  
    129134  CHECK(l);\
    130135  memcpy(&buf[blen], s, l);\
    131   blen += (l);\
     136  blen += (mrb_int)(l);\
    132137} while (0)
    133138
    … …  
    143148  switch (posarg) {
    144149  case -1:
    145     mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with numbered", mrb_fixnum_value(nextarg));
     150    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with numbered", nextarg);
    146151    break;
    147152  case -2:
    148     mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with named", mrb_fixnum_value(nextarg));
     153    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%d) mixed with named", nextarg);
    149154    break;
    150155  default:
    … …  
    154159
    155160static void
    156 check_pos_arg(mrb_state *mrb, int posarg, int n)
     161check_pos_arg(mrb_state *mrb, int posarg, mrb_int n)
    157162{
    158163  if (posarg > 0) {
    159     mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after unnumbered(%S)",
    160                mrb_fixnum_value(n), mrb_fixnum_value(posarg));
     164    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%i) after unnumbered(%d)",
     165               n, posarg);
    161166  }
    162167  if (posarg == -2) {
    163     mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after named", mrb_fixnum_value(n));
     168    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%i) after named", n);
    164169  }
    165170  if (n < 1) {
    166     mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %S$", mrb_fixnum_value(n));
     171    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %i$", n);
    167172  }
    168173}
    169174
    170175static void
    171 check_name_arg(mrb_state *mrb, int posarg, const char *name, int len)
     176check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
    172177{
    173178  if (posarg > 0) {
    174     mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after unnumbered(%S)",
    175                mrb_str_new(mrb, (name), (len)), mrb_fixnum_value(posarg));
     179    mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%l after unnumbered(%d)",
     180               name, len, posarg);
    176181  }
    177182  if (posarg == -1) {
    178     mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after numbered", mrb_str_new(mrb, (name), (len)));
     183    mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%l after numbered", name, len);
    179184  }
    180185}
    … …  
    199204#define GETNUM(n, val) \
    200205  for (; p < end && ISDIGIT(*p); p++) {\
    201     int next_n = 10 * n + (*p - '0'); \
    202     if (next_n / 10 != n) {\
     206    if (n > (MRB_INT_MAX - (*p - '0'))/10) {\
    203207      mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \
    204208    } \
    205     n = next_n; \
     209    n = 10 * n + (*p - '0'); \
    206210  } \
    207211  if (p >= end) { \
    … …  
    225229
    226230static mrb_value
    227 get_hash(mrb_state *mrb, mrb_value *hash, int argc, const mrb_value *argv)
     231get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
    228232{
    229233  mrb_value tmp;
    … …  
    233237    mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
    234238  }
    235   tmp = mrb_check_convert_type(mrb, argv[1], MRB_TT_HASH, "Hash", "to_hash");
     239  tmp = mrb_check_hash_type(mrb, argv[1]);
    236240  if (mrb_nil_p(tmp)) {
    237241    mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
    … …  
    519523
    520524mrb_value
    521 mrb_str_format(mrb_state *mrb, int argc, const mrb_value *argv, mrb_value fmt)
     525mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fmt)
    522526{
    523527  const char *p, *end;
    … …  
    529533  mrb_int width;
    530534  mrb_int prec;
    531   int flags = FNONE;
    532535  int nextarg = 1;
    533536  int posarg = 0;
    … …  
    553556  ++argc;
    554557  --argv;
    555   fmt = mrb_str_to_str(mrb, fmt);
     558  mrb_to_str(mrb, fmt);
    556559  p = RSTRING_PTR(fmt);
    557560  end = p + RSTRING_LEN(fmt);
    558561  blen = 0;
    559562  bsiz = 120;
    560   result = mrb_str_buf_new(mrb, bsiz);
     563  result = mrb_str_new_capa(mrb, bsiz);
    561564  buf = RSTRING_PTR(result);
    562565  memset(buf, 0, bsiz);
    … …  
    565568    const char *t;
    566569    mrb_sym id = 0;
     570    int flags = FNONE;
    567571
    568572    for (t = p; t < end && *t != '%'; t++) ;
    … …  
    580584    switch (*p) {
    581585      default:
    582         mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - \\%%S", mrb_str_new(mrb, p, 1));
     586        mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
    583587        break;
    584588
    … …  
    619623        if (*p == '$') {
    620624          if (!mrb_undef_p(nextvalue)) {
    621             mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %S$", mrb_fixnum_value(n));
     625            mrb_raisef(mrb, E_ARGUMENT_ERROR, "value given twice - %i$", n);
    622626          }
    623627          nextvalue = GETPOSARG(n);
    … …  
    639643          p++;
    640644        if (id) {
    641           mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%S after <%S>",
    642                      mrb_str_new(mrb, start, p - start + 1), mrb_sym2str(mrb, id));
     645          mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%l after <%n>",
     646                     start, p - start + 1, id);
    643647        }
    644648        symname = mrb_str_new(mrb, start + 1, p - start - 1);
    645649        id = mrb_intern_str(mrb, symname);
    646         nextvalue = GETNAMEARG(mrb_symbol_value(id), start, (int)(p - start + 1));
     650        nextvalue = GETNAMEARG(mrb_symbol_value(id), start, p - start + 1);
    647651        if (mrb_undef_p(nextvalue)) {
    648           mrb_raisef(mrb, E_KEY_ERROR, "key%S not found", mrb_str_new(mrb, start, p - start + 1));
     652          mrb_raisef(mrb, E_KEY_ERROR, "key%l not found", start, p - start + 1);
    649653        }
    650654        if (term == '}') goto format_s;
    … …  
    702706        tmp = mrb_check_string_type(mrb, val);
    703707        if (!mrb_nil_p(tmp)) {
    704           if (mrb_fixnum(mrb_funcall(mrb, tmp, "size", 0)) != 1 ) {
     708          if (RSTRING_LEN(tmp) != 1) {
    705709            mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
    706710          }
    707711        }
    708712        else if (mrb_fixnum_p(val)) {
    709           tmp = mrb_funcall(mrb, val, "chr", 0);
     713          mrb_int n = mrb_fixnum(val);
     714
     715          if (n < 0x80) {
     716            char buf[1];
     717
     718            buf[0] = (char)n;
     719            tmp = mrb_str_new(mrb, buf, 1);
     720          }
     721          else {
     722            tmp = mrb_funcall(mrb, val, "chr", 0);
     723            mrb_check_type(mrb, tmp, MRB_TT_STRING);
     724          }
    710725        }
    711726        else {
    712727          mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
    713728        }
    714         mrb_check_type(mrb, tmp, MRB_TT_STRING);
    715729        c = RSTRING_PTR(tmp);
    716730        n = RSTRING_LEN(tmp);
    … …  
    756770            char *p = RSTRING_PTR(str) + prec;
    757771            slen = prec;
    758             len = p - RSTRING_PTR(str);
     772            len = (mrb_int)(p - RSTRING_PTR(str));
    759773          }
    760774          /* need to adjust multi-byte string pos */
    … …  
    792806        mrb_int len;
    793807
    794         switch (*p) {
    795           case 'd':
    796           case 'i':
    797             sign = 1; break;
    798           default:
    799             break;
    800         }
    801808        if (flags & FSHARP) {
    802809          switch (*p) {
    … …  
    812819  bin_retry:
    813820        switch (mrb_type(val)) {
     821#ifndef MRB_WITHOUT_FLOAT
    814822          case MRB_TT_FLOAT:
    815823            val = mrb_flo_to_fixnum(mrb, val);
    816824            if (mrb_fixnum_p(val)) goto bin_retry;
    817825            break;
     826#endif
    818827          case MRB_TT_STRING:
    819828            val = mrb_str_to_inum(mrb, val, 0, TRUE);
    … …  
    839848          case 'd':
    840849          case 'i':
     850            sign = 1;
     851            /* fall through */
    841852          default:
    842853            base = 10; break;
    843854        }
    844855
    845         if (base == 2) {
    846           if (v < 0 && !sign) {
    847             val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
    848             dots = 1;
    849           }
    850           else {
    851             val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
    852           }
    853         }
    854856        if (sign) {
    855           if (v > 0) {
     857          if (v >= 0) {
    856858            if (flags & FPLUS) {
    857859              sc = '+';
    … …  
    863865            }
    864866          }
     867          else {
     868            sc = '-';
     869            width--;
     870          }
     871          mrb_assert(base == 10);
     872          snprintf(nbuf, sizeof(nbuf), "%" MRB_PRId, v);
     873          s = nbuf;
     874          if (v < 0) s++;       /* skip minus sign */
     875        }
     876        else {
     877          s = nbuf;
     878          if (v < 0) {
     879            dots = 1;
     880          }
    865881          switch (base) {
    866882          case 2:
    867             strncpy(nbuf, RSTRING_PTR(val), sizeof(nbuf));
    868             break;
    869           case 8:
    870             snprintf(nbuf, sizeof(nbuf), "%" MRB_PRIo, v);
    871             break;
    872           case 10:
    873             snprintf(nbuf, sizeof(nbuf), "%" MRB_PRId, v);
    874             break;
    875           case 16:
    876             snprintf(nbuf, sizeof(nbuf), "%" MRB_PRIx, v);
    877             break;
    878           }
    879           s = nbuf;
    880         }
    881         else {
    882           s = nbuf;
    883           if (base != 10 && v < 0) {
    884             dots = 1;
    885           }
    886           switch (base) {
    887           case 2:
     883            if (v < 0) {
     884              val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
     885            }
     886            else {
     887              val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
     888            }
    888889            strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-1);
    889890            break;
    890891          case 8:
    891892            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIo, v);
    892             break;
    893           case 10:
    894             snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRId, v);
    895893            break;
    896894          case 16:
    … …  
    921919        }
    922920
    923         if (dots) {
    924           prec -= 2;
    925           width -= 2;
    926         }
    927 
    928921        if (*p == 'X') {
    929922          char *pp = s;
    … …  
    973966        if (!(flags&FMINUS) && width > 0) {
    974967          FILL(' ', width);
     968          width = 0;
    975969        }
    976970
    … …  
    981975          PUSH(prefix, plen);
    982976        }
    983         if (dots) PUSH("..", 2);
     977        if (dots) {
     978          prec -= 2;
     979          width -= 2;
     980          PUSH("..", 2);
     981        }
    984982
    985983        if (prec > len) {
    986984          CHECK(prec - len);
    987           if (v < 0) {
     985          if ((flags & (FMINUS|FPREC)) != FMINUS) {
     986            char c = '0';
     987            FILL(c, prec - len);
     988          } else if (v < 0) {
    988989            char c = sign_bits(base, p);
    989             FILL(c, prec - len);
    990           }
    991           else if ((flags & (FMINUS|FPREC)) != FMINUS) {
    992             char c = '0';
    993990            FILL(c, prec - len);
    994991          }
    … …  
    1001998      break;
    1002999
     1000#ifndef MRB_WITHOUT_FLOAT
    10031001      case 'f':
    10041002      case 'g':
    … …  
    10101008        mrb_value val = GETARG();
    10111009        double fval;
    1012         int i, need = 6;
     1010        mrb_int need = 6;
    10131011        char fbuf[32];
    10141012
    … …  
    10161014        if (!isfinite(fval)) {
    10171015          const char *expr;
    1018           const int elen = 3;
     1016          const mrb_int elen = 3;
    10191017          char sign = '\0';
    10201018
    … …  
    10311029            sign = (flags & FPLUS) ? '+' : ' ';
    10321030          if (sign)
    1033             ++need;
     1031            ++need;
    10341032          if ((flags & FWIDTH) && need < width)
    10351033            need = width;
    … …  
    10551053        need = 0;
    10561054        if (*p != 'e' && *p != 'E') {
    1057           i = INT_MIN;
     1055          int i;
    10581056          frexp(fval, &i);
    10591057          if (i > 0)
    10601058            need = BIT_DIGITS(i);
    10611059        }
     1060        if (need > MRB_INT_MAX - ((flags&FPREC) ? prec : 6)) {
     1061        too_big_width:
     1062          mrb_raise(mrb, E_ARGUMENT_ERROR,
     1063                    (width > prec ? "width too big" : "prec too big"));
     1064        }
    10621065        need += (flags&FPREC) ? prec : 6;
    10631066        if ((flags&FWIDTH) && need < width)
    10641067          need = width;
     1068        if (need > MRB_INT_MAX - 20) {
     1069          goto too_big_width;
     1070        }
    10651071        need += 20;
    1066         if (need <= 0) {
    1067           mrb_raise(mrb, E_ARGUMENT_ERROR,
    1068                     (width > prec ? "width too big" : "prec too big"));
    1069         }
    10701072
    10711073        CHECK(need);
    10721074        n = snprintf(&buf[blen], need, fbuf, fval);
    1073         if (n < 0) {
     1075        if (n < 0 || n >= need) {
    10741076          mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error");
    10751077        }
    … …  
    10771079      }
    10781080      break;
     1081#endif
    10791082    }
    10801083    flags = FNONE;
    … …  
    10881091    const char *mesg = "too many arguments for format string";
    10891092    if (mrb_test(ruby_debug)) mrb_raise(mrb, E_ARGUMENT_ERROR, mesg);
    1090     if (mrb_test(ruby_verbose)) mrb_warn(mrb, "%S", mrb_str_new_cstr(mrb, mesg));
     1093    if (mrb_test(ruby_verbose)) mrb_warn(mrb, "%s", mesg);
    10911094  }
    10921095#endif
    … …  
    10961099}
    10971100
     1101#ifndef MRB_WITHOUT_FLOAT
    10981102static void
    10991103fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
    … …  
    11221126  *buf = '\0';
    11231127}
     1128#endif
Note: See TracChangeset for help on using the changeset viewer.