Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

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

Legend:

Unmodified
Added
Removed

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

    r321 r331  
    55*/
    66
    7 #include "mruby.h"
     7#include <mruby.h>
    88
    99#include <limits.h>
    1010#include <stdio.h>
    1111#include <string.h>
    12 #include "mruby/string.h"
    13 #include "mruby/hash.h"
    14 #include "mruby/numeric.h"
     12#include <mruby/string.h>
     13#include <mruby/hash.h>
     14#include <mruby/numeric.h>
    1515#include <math.h>
    1616#include <ctype.h>
    … …  
    1818#define BIT_DIGITS(N)   (((N)*146)/485 + 1)  /* log2(10) =~ 146/485 */
    1919#define BITSPERDIG MRB_INT_BIT
    20 #define EXTENDSIGN(n, l) (((~0 << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0 << (n)))
     20#define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n)))
    2121
    2222mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
    … …  
    7272mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
    7373{
    74   char buf[64], *b = buf + sizeof buf;
     74  char buf[66], *b = buf + sizeof buf;
    7575  mrb_int num = mrb_fixnum(x);
    7676  uint64_t val = (uint64_t)num;
    … …  
    8080    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid radix %S", mrb_fixnum_value(base));
    8181  }
    82 
    83   if (val >= (1 << 10))
    84     val &= 0x3ff;
    85 
    8682  if (val == 0) {
    8783    return mrb_str_new_lit(mrb, "0");
    … …  
    121117#define CHECK(l) do {\
    122118/*  int cr = ENC_CODERANGE(result);*/\
    123   while (blen + (l) >= bsiz) {\
     119  while ((l) >= bsiz - blen) {\
    124120    bsiz*=2;\
     121    if (bsiz < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "too big specifier"); \
    125122  }\
    126123  mrb_str_resize(mrb, result, bsiz);\
    … …  
    141138} while (0)
    142139
    143 #define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : \
    144   posarg == -1 ? \
    145   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with numbered", mrb_fixnum_value(nextarg)), mrb_undef_value()) : \
    146   posarg == -2 ? \
    147   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with named", mrb_fixnum_value(nextarg)), mrb_undef_value()) : \
     140static void
     141check_next_arg(mrb_state *mrb, int posarg, int nextarg)
     142{
     143  switch (posarg) {
     144  case -1:
     145    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with numbered", mrb_fixnum_value(nextarg));
     146    break;
     147  case -2:
     148    mrb_raisef(mrb, E_ARGUMENT_ERROR, "unnumbered(%S) mixed with named", mrb_fixnum_value(nextarg));
     149    break;
     150  default:
     151    break;
     152  }
     153}
     154
     155static void
     156check_pos_arg(mrb_state *mrb, int posarg, int n)
     157{
     158  if (posarg > 0) {
     159    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after unnumbered(%S)",
     160               mrb_fixnum_value(n), mrb_fixnum_value(posarg));
     161  }
     162  if (posarg == -2) {
     163    mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after named", mrb_fixnum_value(n));
     164  }
     165  if (n < 1) {
     166    mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %S$", mrb_fixnum_value(n));
     167  }
     168}
     169
     170static void
     171check_name_arg(mrb_state *mrb, int posarg, const char *name, int len)
     172{
     173  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));
     176  }
     177  if (posarg == -1) {
     178    mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after numbered", mrb_str_new(mrb, (name), (len)));
     179  }
     180}
     181
     182#define GETNEXTARG() (\
     183  check_next_arg(mrb, posarg, nextarg),\
    148184  (posarg = nextarg++, GETNTHARG(posarg)))
    149185
    150 #define GETPOSARG(n) (posarg > 0 ? \
    151   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after unnumbered(%S)", mrb_fixnum_value(n), mrb_fixnum_value(posarg)), mrb_undef_value()) : \
    152   posarg == -2 ? \
    153   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "numbered(%S) after named", mrb_fixnum_value(n)), mrb_undef_value()) : \
    154   ((n < 1) ? \
    155   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid index - %S$", mrb_fixnum_value(n)), mrb_undef_value()) : \
    156   (posarg = -1, GETNTHARG(n))))
     186#define GETARG() (!mrb_undef_p(nextvalue) ? nextvalue : GETNEXTARG())
     187
     188#define GETPOSARG(n) (\
     189  check_pos_arg(mrb, posarg, n),\
     190  (posarg = -1, GETNTHARG(n)))
    157191
    158192#define GETNTHARG(nth) \
    159193  ((nth >= argc) ? (mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments"), mrb_undef_value()) : argv[nth])
    160194
    161 #define GETNAMEARG(id, name, len) ( \
    162   posarg > 0 ? \
    163   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after unnumbered(%S)", mrb_str_new(mrb, (name), (len)), mrb_fixnum_value(posarg)), mrb_undef_value()) : \
    164   posarg == -1 ? \
    165   (mrb_raisef(mrb, E_ARGUMENT_ERROR, "named%S after numbered", mrb_str_new(mrb, (name), (len))), mrb_undef_value()) :    \
     195#define GETNAMEARG(id, name, len) (\
     196  check_name_arg(mrb, posarg, name, len),\
    166197  (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
    167198
    … …  
    187218  } \
    188219  else { \
    189     tmp_v = GETARG(); \
     220    tmp_v = GETNEXTARG(); \
    190221    p = t; \
    191222  } \
    192   num = mrb_fixnum(tmp_v); \
     223  num = mrb_int(mrb, tmp_v); \
    193224} while (0)
    194225
    … …  
    536567
    537568    for (t = p; t < end && *t != '%'; t++) ;
     569    if (t + 1 == end) ++t;
    538570    PUSH(p, t - p);
    539571    if (t >= end)
    … …  
    680712          mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid character");
    681713        }
     714        mrb_check_type(mrb, tmp, MRB_TT_STRING);
    682715        c = RSTRING_PTR(tmp);
    683716        n = RSTRING_LEN(tmp);
    684717        if (!(flags & FWIDTH)) {
    685           CHECK(n);
    686           memcpy(buf+blen, c, n);
    687           blen += n;
     718          PUSH(c, n);
    688719        }
    689720        else if ((flags & FMINUS)) {
    690           CHECK(n);
    691           memcpy(buf+blen, c, n);
    692           blen += n;
    693           FILL(' ', width-1);
     721          PUSH(c, n);
     722          if (width>0) FILL(' ', width-1);
    694723        }
    695724        else {
    696           FILL(' ', width-1);
    697           CHECK(n);
    698           memcpy(buf+blen, c, n);
    699           blen += n;
     725          if (width>0) FILL(' ', width-1);
     726          PUSH(c, n);
    700727        }
    701728      }
    … …  
    717744          RSTRING(result)->flags &= ~MRB_STR_EMBED_LEN_MASK;
    718745          RSTRING(result)->flags |= tmp_n << MRB_STR_EMBED_LEN_SHIFT;
    719         } else {
     746        }
     747        else {
    720748          RSTRING(result)->as.heap.len = blen;
    721749        }
    … …  
    734762            width -= (int)slen;
    735763            if (!(flags&FMINUS)) {
    736               CHECK(width);
    737               while (width--) {
    738                 buf[blen++] = ' ';
    739               }
     764              FILL(' ', width);
    740765            }
    741             CHECK(len);
    742             memcpy(&buf[blen], RSTRING_PTR(str), len);
    743             blen += len;
     766            PUSH(RSTRING_PTR(str), len);
    744767            if (flags&FMINUS) {
    745               CHECK(width);
    746               while (width--) {
    747                 buf[blen++] = ' ';
    748               }
     768              FILL(' ', width);
    749769            }
    750770            break;
    … …  
    764784      case 'u': {
    765785        mrb_value val = GETARG();
    766         char fbuf[32], nbuf[64], *s;
     786        char nbuf[68], *s;
    767787        const char *prefix = NULL;
    768788        int sign = 0, dots = 0;
    769789        char sc = 0;
    770         mrb_int v = 0, org_v = 0;
     790        mrb_int v = 0;
    771791        int base;
    772792        mrb_int len;
    … …  
    775795          case 'd':
    776796          case 'i':
    777           case 'u':
    778797            sign = 1; break;
    779           case 'o':
    780           case 'x':
    781           case 'X':
    782           case 'b':
    783           case 'B':
    784             if (flags&(FPLUS|FSPACE)) sign = 1;
    785             break;
    786798          default:
    787799            break;
    … …  
    801813        switch (mrb_type(val)) {
    802814          case MRB_TT_FLOAT:
    803             if (FIXABLE(mrb_float(val))) {
    804               val = mrb_fixnum_value((mrb_int)mrb_float(val));
    805               goto bin_retry;
    806             }
    807815            val = mrb_flo_to_fixnum(mrb, val);
    808816            if (mrb_fixnum_p(val)) goto bin_retry;
    … …  
    836844
    837845        if (base == 2) {
    838           org_v = v;
    839846          if (v < 0 && !sign) {
    840847            val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
    … …  
    844851            val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
    845852          }
    846           v = mrb_fixnum(mrb_str_to_inum(mrb, val, 10, FALSE));
    847853        }
    848854        if (sign) {
    849           char c = *p;
    850           if (c == 'i') c = 'd'; /* %d and %i are identical */
    851           if (base == 2) c = 'd';
    852           if (v < 0) {
    853             v = -v;
    854             sc = '-';
    855             width--;
    856           }
    857           else if (flags & FPLUS) {
    858             sc = '+';
    859             width--;
    860           }
    861           else if (flags & FSPACE) {
    862             sc = ' ';
    863             width--;
    864           }
    865           snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
    866           snprintf(nbuf, sizeof(nbuf), fbuf, v);
     855          if (v > 0) {
     856            if (flags & FPLUS) {
     857              sc = '+';
     858              width--;
     859            }
     860            else if (flags & FSPACE) {
     861              sc = ' ';
     862              width--;
     863            }
     864          }
     865          switch (base) {
     866          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          }
    867879          s = nbuf;
    868880        }
    869881        else {
    870           char c = *p;
    871           if (c == 'X') c = 'x';
    872           if (base == 2) c = 'd';
    873882          s = nbuf;
    874           if (v < 0) {
     883          if (base != 10 && v < 0) {
    875884            dots = 1;
    876885          }
    877           snprintf(fbuf, sizeof(fbuf), "%%l%c", c);
    878           snprintf(++s, sizeof(nbuf) - 1, fbuf, v);
     886          switch (base) {
     887          case 2:
     888            strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-1);
     889            break;
     890          case 8:
     891            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIo, v);
     892            break;
     893          case 10:
     894            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRId, v);
     895            break;
     896          case 16:
     897            snprintf(++s, sizeof(nbuf)-1, "%" MRB_PRIx, v);
     898            break;
     899          }
    879900          if (v < 0) {
    880901            char d;
    … …  
    950971        }
    951972
    952         if (!(flags&FMINUS)) {
    953           CHECK(width);
    954           while (width-- > 0) {
    955             buf[blen++] = ' ';
    956           }
     973        if (!(flags&FMINUS) && width > 0) {
     974          FILL(' ', width);
    957975        }
    958976
    … …  
    963981          PUSH(prefix, plen);
    964982        }
    965         CHECK(prec - len);
    966983        if (dots) PUSH("..", 2);
    967984
    968         if (v < 0 || (base == 2 && org_v < 0)) {
    969           char c = sign_bits(base, p);
    970           while (len < prec--) {
    971             buf[blen++] = c;
    972           }
    973         }
    974         else if ((flags & (FMINUS|FPREC)) != FMINUS) {
    975           char c = '0';
    976           while (len < prec--) {
    977             buf[blen++] = c;
    978           }
    979         }
    980 
     985        if (prec > len) {
     986          CHECK(prec - len);
     987          if (v < 0) {
     988            char c = sign_bits(base, p);
     989            FILL(c, prec - len);
     990          }
     991          else if ((flags & (FMINUS|FPREC)) != FMINUS) {
     992            char c = '0';
     993            FILL(c, prec - len);
     994          }
     995        }
    981996        PUSH(s, len);
    982         CHECK(width);
    983         while (width-- > 0) {
    984           buf[blen++] = ' ';
     997        if (width > 0) {
     998          FILL(' ', width);
    985999        }
    9861000      }
    … …  
    10031017          const char *expr;
    10041018          const int elen = 3;
     1019          char sign = '\0';
    10051020
    10061021          if (isnan(fval)) {
    … …  
    10111026          }
    10121027          need = elen;
    1013           if ((!isnan(fval) && fval < 0.0) || (flags & FPLUS))
    1014             need++;
     1028          if (!isnan(fval) && fval < 0.0)
     1029            sign = '-';
     1030          else if (flags & (FPLUS|FSPACE))
     1031            sign = (flags & FPLUS) ? '+' : ' ';
     1032          if (sign)
     1033            ++need;
    10151034          if ((flags & FWIDTH) && need < width)
    10161035            need = width;
    10171036
    1018           CHECK(need + 1);
    1019           snprintf(&buf[blen], need + 1, "%*s", need, "");
     1037          if (need < 0) {
     1038            mrb_raise(mrb, E_ARGUMENT_ERROR, "width too big");
     1039          }
     1040          FILL(' ', need);
    10201041          if (flags & FMINUS) {
    1021             if (!isnan(fval) && fval < 0.0)
    1022               buf[blen++] = '-';
    1023             else if (flags & FPLUS)
    1024               buf[blen++] = '+';
    1025             else if (flags & FSPACE)
    1026               blen++;
    1027             memcpy(&buf[blen], expr, elen);
     1042            if (sign)
     1043              buf[blen - need--] = sign;
     1044            memcpy(&buf[blen - need], expr, elen);
    10281045          }
    10291046          else {
    1030             if (!isnan(fval) && fval < 0.0)
    1031               buf[blen + need - elen - 1] = '-';
    1032             else if (flags & FPLUS)
    1033               buf[blen + need - elen - 1] = '+';
    1034             else if ((flags & FSPACE) && need > width)
    1035               blen++;
    1036             memcpy(&buf[blen + need - elen], expr, elen);
    1037           }
    1038           blen += strlen(&buf[blen]);
     1047            if (sign)
     1048              buf[blen - elen - 1] = sign;
     1049            memcpy(&buf[blen - elen], expr, elen);
     1050          }
    10391051          break;
    10401052        }
    … …  
    10521064          need = width;
    10531065        need += 20;
     1066        if (need <= 0) {
     1067          mrb_raise(mrb, E_ARGUMENT_ERROR,
     1068                    (width > prec ? "width too big" : "prec too big"));
     1069        }
    10541070
    10551071        CHECK(need);
    10561072        n = snprintf(&buf[blen], need, fbuf, fval);
     1073        if (n < 0) {
     1074          mrb_raise(mrb, E_RUNTIME_ERROR, "formatting error");
     1075        }
    10571076        blen += n;
    10581077      }
Note: See TracChangeset for help on using the changeset viewer.