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/src/codedump.c

    r331 r439  
    77
    88#ifndef MRB_DISABLE_STDIO
    9 static int
    10 print_r(mrb_state *mrb, mrb_irep *irep, size_t n, int pre)
     9static void
     10print_r(mrb_state *mrb, mrb_irep *irep, size_t n)
    1111{
    1212  size_t i;
    1313
    14   if (n == 0) return 0;
     14  if (n == 0) return;
    1515
    1616  for (i=0; i+1<irep->nlocals; i++) {
    1717    if (irep->lv[i].r == n) {
    1818      mrb_sym sym = irep->lv[i].name;
    19       if (pre) printf(" ");
    20       printf("R%d:%s", (int)n, mrb_sym2name(mrb, sym));
    21       return 1;
     19      printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, sym));
     20      break;
    2221    }
    2322  }
    24   return 0;
    25 }
    26 
    27 #define RA  1
    28 #define RB  2
    29 #define RAB 3
     23}
    3024
    3125static void
    32 print_lv(mrb_state *mrb, mrb_irep *irep, mrb_code c, int r)
    33 {
    34   int pre = 0;
    35 
    36   if (!irep->lv
    37       || ((!(r & RA) || GETARG_A(c) >= irep->nlocals)
    38        && (!(r & RB) || GETARG_B(c) >= irep->nlocals))) {
     26print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
     27{
     28  if (!irep->lv || a >= irep->nlocals || a == 0) {
    3929    printf("\n");
    4030    return;
    4131  }
    42   printf("\t; ");
    43   if (r & RA) {
    44     pre = print_r(mrb, irep, GETARG_A(c), 0);
    45   }
    46   if (r & RB) {
    47     print_r(mrb, irep, GETARG_B(c), pre);
    48   }
     32  printf("\t;");
     33  print_r(mrb, irep, a);
    4934  printf("\n");
    5035}
    51 #endif
     36
     37static void
     38print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
     39{
     40  if (!irep->lv || (a >= irep->nlocals && b >= irep->nlocals) || a+b == 0) {
     41    printf("\n");
     42    return;
     43  }
     44  printf("\t;");
     45  if (a > 0) print_r(mrb, irep, a);
     46  if (b > 0) print_r(mrb, irep, b);
     47  printf("\n");
     48}
     49
     50static void
     51print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
     52{
     53  int32_t line;
     54
     55  line = mrb_debug_get_line(mrb, irep, i);
     56  if (line < 0) {
     57    printf("      ");
     58  }
     59  else {
     60    printf("%5d ", line);
     61  }
     62
     63  printf("%03d ", (int)i);
     64}
     65
     66#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
    5267
    5368static void
    5469codedump(mrb_state *mrb, mrb_irep *irep)
    5570{
    56 #ifndef MRB_DISABLE_STDIO
    57   int i;
    5871  int ai;
    59   mrb_code c;
     72  const mrb_code *pc, *pcend;
     73  mrb_code ins;
    6074  const char *file = NULL, *next_file;
    61   int32_t line;
    6275
    6376  if (!irep) return;
    64   printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d\n", (void*)irep,
    65          irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen);
    66 
    67   for (i = 0; i < (int)irep->ilen; i++) {
     77  printf("irep %p nregs=%d nlocals=%d pools=%d syms=%d reps=%d iseq=%d\n", (void*)irep,
     78         irep->nregs, irep->nlocals, (int)irep->plen, (int)irep->slen, (int)irep->rlen, (int)irep->ilen);
     79
     80  if (irep->lv) {
     81    int i;
     82
     83    printf("local variable names:\n");
     84    for (i = 1; i < irep->nlocals; ++i) {
     85      char const *s = mrb_sym_dump(mrb, irep->lv[i - 1].name);
     86      int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i;
     87      printf("  R%d:%s\n", n, s ? s : "");
     88    }
     89  }
     90
     91  pc = irep->iseq;
     92  pcend = pc + irep->ilen;
     93  while (pc < pcend) {
     94    ptrdiff_t i;
     95    uint32_t a;
     96    uint16_t b;
     97    uint8_t c;
     98
    6899    ai = mrb_gc_arena_save(mrb);
    69100
    70     next_file = mrb_debug_get_filename(irep, i);
     101    i = pc - irep->iseq;
     102    next_file = mrb_debug_get_filename(mrb, irep, i);
    71103    if (next_file && file != next_file) {
    72104      printf("file: %s\n", next_file);
    73105      file = next_file;
    74106    }
    75     line = mrb_debug_get_line(irep, i);
    76     if (line < 0) {
    77       printf("      ");
    78     }
    79     else {
    80       printf("%5d ", line);
    81     }
    82 
    83     printf("%03d ", i);
    84     c = irep->iseq[i];
    85     switch (GET_OPCODE(c)) {
    86     case OP_NOP:
     107    print_header(mrb, irep, i);
     108    ins = READ_B();
     109    switch (ins) {
     110    CASE(OP_NOP, Z):
    87111      printf("OP_NOP\n");
    88112      break;
    89     case OP_MOVE:
    90       printf("OP_MOVE\tR%d\tR%d\t", GETARG_A(c), GETARG_B(c));
    91       print_lv(mrb, irep, c, RAB);
    92       break;
    93     case OP_LOADL:
     113    CASE(OP_MOVE, BB):
     114      printf("OP_MOVE\tR%d\tR%d\t", a, b);
     115      print_lv_ab(mrb, irep, a, b);
     116      break;
     117    CASE(OP_LOADL, BB):
    94118      {
    95         mrb_value v = irep->pool[GETARG_Bx(c)];
     119        mrb_value v = irep->pool[b];
    96120        mrb_value s = mrb_inspect(mrb, v);
    97         printf("OP_LOADL\tR%d\tL(%d)\t; %s", GETARG_A(c), GETARG_Bx(c), RSTRING_PTR(s));
     121        printf("OP_LOADL\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
    98122      }
    99       print_lv(mrb, irep, c, RA);
    100       break;
    101     case OP_LOADI:
    102       printf("OP_LOADI\tR%d\t%d\t", GETARG_A(c), GETARG_sBx(c));
    103       print_lv(mrb, irep, c, RA);
    104       break;
    105     case OP_LOADSYM:
    106       printf("OP_LOADSYM\tR%d\t:%s", GETARG_A(c),
    107              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    108       print_lv(mrb, irep, c, RA);
    109       break;
    110     case OP_LOADNIL:
    111       printf("OP_LOADNIL\tR%d\t\t", GETARG_A(c));
    112       print_lv(mrb, irep, c, RA);
    113       break;
    114     case OP_LOADSELF:
    115       printf("OP_LOADSELF\tR%d\t\t", GETARG_A(c));
    116       print_lv(mrb, irep, c, RA);
    117       break;
    118     case OP_LOADT:
    119       printf("OP_LOADT\tR%d\t\t", GETARG_A(c));
    120       print_lv(mrb, irep, c, RA);
    121       break;
    122     case OP_LOADF:
    123       printf("OP_LOADF\tR%d\t\t", GETARG_A(c));
    124       print_lv(mrb, irep, c, RA);
    125       break;
    126     case OP_GETGLOBAL:
    127       printf("OP_GETGLOBAL\tR%d\t:%s", GETARG_A(c),
    128              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    129       print_lv(mrb, irep, c, RA);
    130       break;
    131     case OP_SETGLOBAL:
    132       printf("OP_SETGLOBAL\t:%s\tR%d\t",
    133              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
    134              GETARG_A(c));
    135       print_lv(mrb, irep, c, RA);
    136       break;
    137     case OP_GETCONST:
    138       printf("OP_GETCONST\tR%d\t:%s", GETARG_A(c),
    139              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    140       print_lv(mrb, irep, c, RA);
    141       break;
    142     case OP_SETCONST:
    143       printf("OP_SETCONST\t:%s\tR%d\t",
    144              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
    145              GETARG_A(c));
    146       print_lv(mrb, irep, c, RA);
    147       break;
    148     case OP_GETMCNST:
    149       printf("OP_GETMCNST\tR%d\tR%d::%s", GETARG_A(c), GETARG_A(c),
    150              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    151       print_lv(mrb, irep, c, RAB);
    152       break;
    153     case OP_SETMCNST:
    154       printf("OP_SETMCNST\tR%d::%s\tR%d", GETARG_A(c)+1,
    155              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
    156              GETARG_A(c));
    157       print_lv(mrb, irep, c, RA);
    158       break;
    159     case OP_GETIV:
    160       printf("OP_GETIV\tR%d\t%s", GETARG_A(c),
    161              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    162       print_lv(mrb, irep, c, RA);
    163       break;
    164     case OP_SETIV:
    165       printf("OP_SETIV\t%s\tR%d",
    166              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
    167              GETARG_A(c));
    168       print_lv(mrb, irep, c, RA);
    169       break;
    170     case OP_GETUPVAR:
    171       printf("OP_GETUPVAR\tR%d\t%d\t%d",
    172              GETARG_A(c), GETARG_B(c), GETARG_C(c));
    173       print_lv(mrb, irep, c, RA);
    174       break;
    175     case OP_SETUPVAR:
    176       printf("OP_SETUPVAR\tR%d\t%d\t%d",
    177              GETARG_A(c), GETARG_B(c), GETARG_C(c));
    178       print_lv(mrb, irep, c, RA);
    179       break;
    180     case OP_GETCV:
    181       printf("OP_GETCV\tR%d\t%s", GETARG_A(c),
    182              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]));
    183       print_lv(mrb, irep, c, RA);
    184       break;
    185     case OP_SETCV:
    186       printf("OP_SETCV\t%s\tR%d",
    187              mrb_sym2name(mrb, irep->syms[GETARG_Bx(c)]),
    188              GETARG_A(c));
    189       print_lv(mrb, irep, c, RA);
    190       break;
    191     case OP_JMP:
    192       printf("OP_JMP\t%03d\n", i+GETARG_sBx(c));
    193       break;
    194     case OP_JMPIF:
    195       printf("OP_JMPIF\tR%d\t%03d\n", GETARG_A(c), i+GETARG_sBx(c));
    196       break;
    197     case OP_JMPNOT:
    198       printf("OP_JMPNOT\tR%d\t%03d\n", GETARG_A(c), i+GETARG_sBx(c));
    199       break;
    200     case OP_SEND:
    201       printf("OP_SEND\tR%d\t:%s\t%d\n", GETARG_A(c),
    202              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    203              GETARG_C(c));
    204       break;
    205     case OP_SENDB:
    206       printf("OP_SENDB\tR%d\t:%s\t%d\n", GETARG_A(c),
    207              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    208              GETARG_C(c));
    209       break;
    210     case OP_TAILCALL:
    211       printf("OP_TAILCALL\tR%d\t:%s\t%d\n", GETARG_A(c),
    212              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    213              GETARG_C(c));
    214       break;
    215     case OP_SUPER:
    216       printf("OP_SUPER\tR%d\t%d\n", GETARG_A(c),
    217              GETARG_C(c));
    218       break;
    219     case OP_ARGARY:
    220       printf("OP_ARGARY\tR%d\t%d:%d:%d:%d", GETARG_A(c),
    221              (GETARG_Bx(c)>>10)&0x3f,
    222              (GETARG_Bx(c)>>9)&0x1,
    223              (GETARG_Bx(c)>>4)&0x1f,
    224              (GETARG_Bx(c)>>0)&0xf);
    225       print_lv(mrb, irep, c, RA);
    226       break;
    227 
    228     case OP_ENTER:
     123      print_lv_a(mrb, irep, a);
     124      break;
     125    CASE(OP_LOADI, BB):
     126      printf("OP_LOADI\tR%d\t%d\t", a, b);
     127      print_lv_a(mrb, irep, a);
     128      break;
     129    CASE(OP_LOADINEG, BB):
     130      printf("OP_LOADI\tR%d\t-%d\t", a, b);
     131      print_lv_a(mrb, irep, a);
     132      break;
     133    CASE(OP_LOADI__1, B):
     134      printf("OP_LOADI__1\tR%d\t\t", a);
     135      print_lv_a(mrb, irep, a);
     136      break;
     137    CASE(OP_LOADI_0, B): goto L_LOADI;
     138    CASE(OP_LOADI_1, B): goto L_LOADI;
     139    CASE(OP_LOADI_2, B): goto L_LOADI;
     140    CASE(OP_LOADI_3, B): goto L_LOADI;
     141    CASE(OP_LOADI_4, B): goto L_LOADI;
     142    CASE(OP_LOADI_5, B): goto L_LOADI;
     143    CASE(OP_LOADI_6, B): goto L_LOADI;
     144    CASE(OP_LOADI_7, B):
     145    L_LOADI:
     146      printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a);
     147      print_lv_a(mrb, irep, a);
     148      break;
     149    CASE(OP_LOADSYM, BB):
     150      printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
     151      print_lv_a(mrb, irep, a);
     152      break;
     153    CASE(OP_LOADNIL, B):
     154      printf("OP_LOADNIL\tR%d\t\t", a);
     155      print_lv_a(mrb, irep, a);
     156      break;
     157    CASE(OP_LOADSELF, B):
     158      printf("OP_LOADSELF\tR%d\t\t", a);
     159      print_lv_a(mrb, irep, a);
     160      break;
     161    CASE(OP_LOADT, B):
     162      printf("OP_LOADT\tR%d\t\t", a);
     163      print_lv_a(mrb, irep, a);
     164      break;
     165    CASE(OP_LOADF, B):
     166      printf("OP_LOADF\tR%d\t\t", a);
     167      print_lv_a(mrb, irep, a);
     168      break;
     169    CASE(OP_GETGV, BB):
     170      printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     171      print_lv_a(mrb, irep, a);
     172      break;
     173    CASE(OP_SETGV, BB):
     174      printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
     175      print_lv_a(mrb, irep, a);
     176      break;
     177    CASE(OP_GETSV, BB):
     178      printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     179      print_lv_a(mrb, irep, a);
     180      break;
     181    CASE(OP_SETSV, BB):
     182      printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
     183      print_lv_a(mrb, irep, a);
     184      break;
     185    CASE(OP_GETCONST, BB):
     186      printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     187      print_lv_a(mrb, irep, a);
     188      break;
     189    CASE(OP_SETCONST, BB):
     190      printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
     191      print_lv_a(mrb, irep, a);
     192      break;
     193    CASE(OP_GETMCNST, BB):
     194      printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b]));
     195      print_lv_a(mrb, irep, a);
     196      break;
     197    CASE(OP_SETMCNST, BB):
     198      printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a);
     199      print_lv_a(mrb, irep, a);
     200      break;
     201    CASE(OP_GETIV, BB):
     202      printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     203      print_lv_a(mrb, irep, a);
     204      break;
     205    CASE(OP_SETIV, BB):
     206      printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
     207      print_lv_a(mrb, irep, a);
     208      break;
     209    CASE(OP_GETUPVAR, BBB):
     210      printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c);
     211      print_lv_a(mrb, irep, a);
     212      break;
     213    CASE(OP_SETUPVAR, BBB):
     214      printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c);
     215      print_lv_a(mrb, irep, a);
     216      break;
     217    CASE(OP_GETCV, BB):
     218      printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     219      print_lv_a(mrb, irep, a);
     220      break;
     221    CASE(OP_SETCV, BB):
     222      printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
     223      print_lv_a(mrb, irep, a);
     224      break;
     225    CASE(OP_JMP, S):
     226      printf("OP_JMP\t\t%03d\n", a);
     227      break;
     228    CASE(OP_JMPIF, BS):
     229      printf("OP_JMPIF\tR%d\t%03d\t", a, b);
     230      print_lv_a(mrb, irep, a);
     231      break;
     232    CASE(OP_JMPNOT, BS):
     233      printf("OP_JMPNOT\tR%d\t%03d\t", a, b);
     234      print_lv_a(mrb, irep, a);
     235      break;
     236    CASE(OP_JMPNIL, BS):
     237      printf("OP_JMPNIL\tR%d\t%03d\t", a, b);
     238      print_lv_a(mrb, irep, a);
     239      break;
     240    CASE(OP_SENDV, BB):
     241      printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
     242      break;
     243    CASE(OP_SENDVB, BB):
     244      printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
     245      break;
     246    CASE(OP_SEND, BBB):
     247      printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
     248      break;
     249    CASE(OP_SENDB, BBB):
     250      printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
     251      break;
     252    CASE(OP_CALL, Z):
     253      printf("OP_CALL\n");
     254      break;
     255    CASE(OP_SUPER, BB):
     256      printf("OP_SUPER\tR%d\t%d\n", a, b);
     257      break;
     258    CASE(OP_ARGARY, BS):
     259      printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
     260             (b>>11)&0x3f,
     261             (b>>10)&0x1,
     262             (b>>5)&0x1f,
     263             (b>>4)&0x1,
     264             (b>>0)&0xf);
     265      print_lv_a(mrb, irep, a);
     266      break;
     267    CASE(OP_ENTER, W):
    229268      printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
    230              (GETARG_Ax(c)>>18)&0x1f,
    231              (GETARG_Ax(c)>>13)&0x1f,
    232              (GETARG_Ax(c)>>12)&0x1,
    233              (GETARG_Ax(c)>>7)&0x1f,
    234              (GETARG_Ax(c)>>2)&0x1f,
    235              (GETARG_Ax(c)>>1)&0x1,
    236              GETARG_Ax(c) & 0x1);
    237       break;
    238     case OP_RETURN:
    239       printf("OP_RETURN\tR%d", GETARG_A(c));
    240       switch (GETARG_B(c)) {
    241       case OP_R_NORMAL:
    242         printf("\tnormal\t"); break;
    243       case OP_R_RETURN:
    244         printf("\treturn\t"); break;
    245       case OP_R_BREAK:
    246         printf("\tbreak\t"); break;
    247       default:
    248         printf("\tbroken\t"); break;
     269             MRB_ASPEC_REQ(a),
     270             MRB_ASPEC_OPT(a),
     271             MRB_ASPEC_REST(a),
     272             MRB_ASPEC_POST(a),
     273             MRB_ASPEC_KEY(a),
     274             MRB_ASPEC_KDICT(a),
     275             MRB_ASPEC_BLOCK(a));
     276      break;
     277    CASE(OP_KEY_P, BB):
     278      printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
     279      print_lv_a(mrb, irep, a);
     280      break;
     281    CASE(OP_KEYEND, Z):
     282      printf("OP_KEYEND\n");
     283      break;
     284    CASE(OP_KARG, BB):
     285      printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
     286      print_lv_a(mrb, irep, a);
     287      break;
     288    CASE(OP_RETURN, B):
     289      printf("OP_RETURN\tR%d\t\t", a);
     290      print_lv_a(mrb, irep, a);
     291      break;
     292    CASE(OP_RETURN_BLK, B):
     293      printf("OP_RETURN_BLK\tR%d\t\t", a);
     294      print_lv_a(mrb, irep, a);
     295      break;
     296    CASE(OP_BREAK, B):
     297      printf("OP_BREAK\tR%d\t\t", a);
     298      print_lv_a(mrb, irep, a);
     299      break;
     300    CASE(OP_BLKPUSH, BS):
     301      printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
     302             (b>>11)&0x3f,
     303             (b>>10)&0x1,
     304             (b>>5)&0x1f,
     305             (b>>4)&0x1,
     306             (b>>0)&0xf);
     307      print_lv_a(mrb, irep, a);
     308      break;
     309    CASE(OP_LAMBDA, BB):
     310      printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
     311      break;
     312    CASE(OP_BLOCK, BB):
     313      printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
     314      break;
     315    CASE(OP_METHOD, BB):
     316      printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
     317      break;
     318    CASE(OP_RANGE_INC, B):
     319      printf("OP_RANGE_INC\tR%d\n", a);
     320      break;
     321    CASE(OP_RANGE_EXC, B):
     322      printf("OP_RANGE_EXC\tR%d\n", a);
     323      break;
     324    CASE(OP_DEF, BB):
     325      printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
     326      break;
     327    CASE(OP_UNDEF, B):
     328      printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a]));
     329      break;
     330    CASE(OP_ALIAS, BB):
     331      printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b]));
     332      break;
     333    CASE(OP_ADD, B):
     334      printf("OP_ADD\tR%d\t\n", a);
     335      break;
     336    CASE(OP_ADDI, BB):
     337      printf("OP_ADDI\tR%d\t%d\n", a, b);
     338      break;
     339    CASE(OP_SUB, B):
     340      printf("OP_SUB\tR%d\t\n", a);
     341      break;
     342    CASE(OP_SUBI, BB):
     343      printf("OP_SUBI\tR%d\t%d\n", a, b);
     344      break;
     345    CASE(OP_MUL, B):
     346      printf("OP_MUL\tR%d\t\n", a);
     347      break;
     348    CASE(OP_DIV, B):
     349      printf("OP_DIV\tR%d\t\n", a);
     350      break;
     351    CASE(OP_LT, B):
     352      printf("OP_LT\t\tR%d\t\n", a);
     353      break;
     354    CASE(OP_LE, B):
     355      printf("OP_LE\t\tR%d\t\n", a);
     356      break;
     357    CASE(OP_GT, B):
     358      printf("OP_GT\t\tR%d\t\n", a);
     359      break;
     360    CASE(OP_GE, B):
     361      printf("OP_GE\t\tR%d\t\n", a);
     362      break;
     363    CASE(OP_EQ, B):
     364      printf("OP_EQ\t\tR%d\t\n", a);
     365      break;
     366    CASE(OP_ARRAY, BB):
     367      printf("OP_ARRAY\tR%d\t%d\t", a, b);
     368      print_lv_a(mrb, irep, a);
     369      break;
     370    CASE(OP_ARRAY2, BBB):
     371      printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c);
     372      print_lv_ab(mrb, irep, a, b);
     373      break;
     374    CASE(OP_ARYCAT, B):
     375      printf("OP_ARYCAT\tR%d\t", a);
     376      print_lv_a(mrb, irep, a);
     377      break;
     378    CASE(OP_ARYPUSH, B):
     379      printf("OP_ARYPUSH\tR%d\t", a);
     380      print_lv_a(mrb, irep, a);
     381      break;
     382    CASE(OP_ARYDUP, B):
     383      printf("OP_ARYDUP\tR%d\t", a);
     384      print_lv_a(mrb, irep, a);
     385      break;
     386    CASE(OP_AREF, BBB):
     387      printf("OP_AREF\tR%d\tR%d\t%d", a, b, c);
     388      print_lv_ab(mrb, irep, a, b);
     389      break;
     390    CASE(OP_ASET, BBB):
     391      printf("OP_ASET\tR%d\tR%d\t%d", a, b, c);
     392      print_lv_ab(mrb, irep, a, b);
     393      break;
     394    CASE(OP_APOST, BBB):
     395      printf("OP_APOST\tR%d\t%d\t%d", a, b, c);
     396      print_lv_a(mrb, irep, a);
     397      break;
     398    CASE(OP_INTERN, B):
     399      printf("OP_INTERN\tR%d", a);
     400      print_lv_a(mrb, irep, a);
     401      break;
     402    CASE(OP_STRING, BB):
     403      {
     404        mrb_value v = irep->pool[b];
     405        mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
     406        printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
    249407      }
    250       print_lv(mrb, irep, c, RA);
    251       break;
    252     case OP_BLKPUSH:
    253       printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d", GETARG_A(c),
    254              (GETARG_Bx(c)>>10)&0x3f,
    255              (GETARG_Bx(c)>>9)&0x1,
    256              (GETARG_Bx(c)>>4)&0x1f,
    257              (GETARG_Bx(c)>>0)&0xf);
    258       print_lv(mrb, irep, c, RA);
    259       break;
    260 
    261     case OP_LAMBDA:
    262       printf("OP_LAMBDA\tR%d\tI(%+d)\t", GETARG_A(c), GETARG_b(c)+1);
    263       switch (GETARG_c(c)) {
    264       case OP_L_METHOD:
    265         printf("method"); break;
    266       case OP_L_BLOCK:
    267         printf("block"); break;
    268       case OP_L_LAMBDA:
    269         printf("lambda"); break;
    270       }
    271       print_lv(mrb, irep, c, RA);
    272       break;
    273     case OP_RANGE:
    274       printf("OP_RANGE\tR%d\tR%d\t%d", GETARG_A(c), GETARG_B(c), GETARG_C(c));
    275       print_lv(mrb, irep, c, RAB);
    276       break;
    277     case OP_METHOD:
    278       printf("OP_METHOD\tR%d\t:%s", GETARG_A(c),
    279              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
    280       print_lv(mrb, irep, c, RA);
    281       break;
    282 
    283     case OP_ADD:
    284       printf("OP_ADD\tR%d\t:%s\t%d\n", GETARG_A(c),
    285              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    286              GETARG_C(c));
    287       break;
    288     case OP_ADDI:
    289       printf("OP_ADDI\tR%d\t:%s\t%d\n", GETARG_A(c),
    290              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    291              GETARG_C(c));
    292       break;
    293     case OP_SUB:
    294       printf("OP_SUB\tR%d\t:%s\t%d\n", GETARG_A(c),
    295              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    296              GETARG_C(c));
    297       break;
    298     case OP_SUBI:
    299       printf("OP_SUBI\tR%d\t:%s\t%d\n", GETARG_A(c),
    300              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    301              GETARG_C(c));
    302       break;
    303     case OP_MUL:
    304       printf("OP_MUL\tR%d\t:%s\t%d\n", GETARG_A(c),
    305              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    306              GETARG_C(c));
    307       break;
    308     case OP_DIV:
    309       printf("OP_DIV\tR%d\t:%s\t%d\n", GETARG_A(c),
    310              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    311              GETARG_C(c));
    312       break;
    313     case OP_LT:
    314       printf("OP_LT\tR%d\t:%s\t%d\n", GETARG_A(c),
    315              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    316              GETARG_C(c));
    317       break;
    318     case OP_LE:
    319       printf("OP_LE\tR%d\t:%s\t%d\n", GETARG_A(c),
    320              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    321              GETARG_C(c));
    322       break;
    323     case OP_GT:
    324       printf("OP_GT\tR%d\t:%s\t%d\n", GETARG_A(c),
    325              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    326              GETARG_C(c));
    327       break;
    328     case OP_GE:
    329       printf("OP_GE\tR%d\t:%s\t%d\n", GETARG_A(c),
    330              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    331              GETARG_C(c));
    332       break;
    333     case OP_EQ:
    334       printf("OP_EQ\t\tR%d\t:%s\t%d\n", GETARG_A(c),
    335              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]),
    336              GETARG_C(c));
    337       break;
    338 
    339     case OP_STOP:
    340       printf("OP_STOP\n");
    341       break;
    342 
    343     case OP_ARRAY:
    344       printf("OP_ARRAY\tR%d\tR%d\t%d", GETARG_A(c), GETARG_B(c), GETARG_C(c));
    345       print_lv(mrb, irep, c, RAB);
    346       break;
    347     case OP_ARYCAT:
    348       printf("OP_ARYCAT\tR%d\tR%d\t", GETARG_A(c), GETARG_B(c));
    349       print_lv(mrb, irep, c, RAB);
    350       break;
    351     case OP_ARYPUSH:
    352       printf("OP_ARYPUSH\tR%d\tR%d\t", GETARG_A(c), GETARG_B(c));
    353       print_lv(mrb, irep, c, RAB);
    354       break;
    355     case OP_AREF:
    356       printf("OP_AREF\tR%d\tR%d\t%d", GETARG_A(c), GETARG_B(c), GETARG_C(c));
    357       print_lv(mrb, irep, c, RAB);
    358       break;
    359     case OP_APOST:
    360       printf("OP_APOST\tR%d\t%d\t%d", GETARG_A(c), GETARG_B(c), GETARG_C(c));
    361       print_lv(mrb, irep, c, RA);
    362       break;
    363     case OP_STRING:
     408      print_lv_a(mrb, irep, a);
     409      break;
     410    CASE(OP_STRCAT, B):
     411      printf("OP_STRCAT\tR%d\t", a);
     412      print_lv_a(mrb, irep, a);
     413      break;
     414    CASE(OP_HASH, BB):
     415      printf("OP_HASH\tR%d\t%d\t", a, b);
     416      print_lv_a(mrb, irep, a);
     417      break;
     418    CASE(OP_HASHADD, BB):
     419      printf("OP_HASHADD\tR%d\t%d\t", a, b);
     420      print_lv_a(mrb, irep, a);
     421      break;
     422    CASE(OP_HASHCAT, B):
     423      printf("OP_HASHCAT\tR%d\t", a);
     424      print_lv_a(mrb, irep, a);
     425      break;
     426
     427    CASE(OP_OCLASS, B):
     428      printf("OP_OCLASS\tR%d\t\t", a);
     429      print_lv_a(mrb, irep, a);
     430      break;
     431    CASE(OP_CLASS, BB):
     432      printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     433      print_lv_a(mrb, irep, a);
     434      break;
     435    CASE(OP_MODULE, BB):
     436      printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
     437      print_lv_a(mrb, irep, a);
     438      break;
     439    CASE(OP_EXEC, BB):
     440      printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]);
     441      print_lv_a(mrb, irep, a);
     442      break;
     443    CASE(OP_SCLASS, B):
     444      printf("OP_SCLASS\tR%d\t", a);
     445      print_lv_a(mrb, irep, a);
     446      break;
     447    CASE(OP_TCLASS, B):
     448      printf("OP_TCLASS\tR%d\t\t", a);
     449      print_lv_a(mrb, irep, a);
     450      break;
     451    CASE(OP_ERR, B):
    364452      {
    365         mrb_value v = irep->pool[GETARG_Bx(c)];
    366         mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
    367         printf("OP_STRING\tR%d\tL(%d)\t; %s", GETARG_A(c), GETARG_Bx(c), RSTRING_PTR(s));
    368       }
    369       print_lv(mrb, irep, c, RA);
    370       break;
    371     case OP_STRCAT:
    372       printf("OP_STRCAT\tR%d\tR%d\t", GETARG_A(c), GETARG_B(c));
    373       print_lv(mrb, irep, c, RAB);
    374       break;
    375     case OP_HASH:
    376       printf("OP_HASH\tR%d\tR%d\t%d", GETARG_A(c), GETARG_B(c), GETARG_C(c));
    377       print_lv(mrb, irep, c, RAB);
    378       break;
    379 
    380     case OP_OCLASS:
    381       printf("OP_OCLASS\tR%d\t\t", GETARG_A(c));
    382       print_lv(mrb, irep, c, RA);
    383       break;
    384     case OP_CLASS:
    385       printf("OP_CLASS\tR%d\t:%s", GETARG_A(c),
    386              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
    387       print_lv(mrb, irep, c, RA);
    388       break;
    389     case OP_MODULE:
    390       printf("OP_MODULE\tR%d\t:%s", GETARG_A(c),
    391              mrb_sym2name(mrb, irep->syms[GETARG_B(c)]));
    392       print_lv(mrb, irep, c, RA);
    393       break;
    394     case OP_EXEC:
    395       printf("OP_EXEC\tR%d\tI(%+d)", GETARG_A(c), GETARG_Bx(c)+1);
    396       print_lv(mrb, irep, c, RA);
    397       break;
    398     case OP_SCLASS:
    399       printf("OP_SCLASS\tR%d\tR%d\t", GETARG_A(c), GETARG_B(c));
    400       print_lv(mrb, irep, c, RAB);
    401       break;
    402     case OP_TCLASS:
    403       printf("OP_TCLASS\tR%d\t\t", GETARG_A(c));
    404       print_lv(mrb, irep, c, RA);
    405       break;
    406     case OP_ERR:
    407       {
    408         mrb_value v = irep->pool[GETARG_Bx(c)];
     453        mrb_value v = irep->pool[a];
    409454        mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
    410455        printf("OP_ERR\t%s\n", RSTRING_PTR(s));
    411456      }
    412457      break;
    413     case OP_EPUSH:
    414       printf("OP_EPUSH\t:I(%+d)\n", GETARG_Bx(c)+1);
    415       break;
    416     case OP_ONERR:
    417       printf("OP_ONERR\t%03d\n", i+GETARG_sBx(c));
    418       break;
    419     case OP_RESCUE:
    420       {
    421         int a = GETARG_A(c);
    422         int b = GETARG_B(c);
    423         int cnt = GETARG_C(c);
    424 
    425         if (b == 0) {
    426           printf("OP_RESCUE\tR%d\t\t%s", a, cnt ? "cont" : "");
    427           print_lv(mrb, irep, c, RA);
    428           break;
    429         }
    430         else {
    431           printf("OP_RESCUE\tR%d\tR%d\t%s", a, b, cnt ? "cont" : "");
    432           print_lv(mrb, irep, c, RAB);
    433           break;
    434         }
     458    CASE(OP_EPUSH, B):
     459      printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]);
     460      break;
     461    CASE(OP_ONERR, S):
     462      printf("OP_ONERR\t%03d\n", a);
     463      break;
     464    CASE(OP_EXCEPT, B):
     465      printf("OP_EXCEPT\tR%d\t\t", a);
     466      print_lv_a(mrb, irep, a);
     467      break;
     468    CASE(OP_RESCUE, BB):
     469      printf("OP_RESCUE\tR%d\tR%d", a, b);
     470      print_lv_ab(mrb, irep, a, b);
     471      break;
     472    CASE(OP_RAISE, B):
     473      printf("OP_RAISE\tR%d\t\t", a);
     474      print_lv_a(mrb, irep, a);
     475      break;
     476    CASE(OP_POPERR, B):
     477      printf("OP_POPERR\t%d\t\t\n", a);
     478      break;
     479    CASE(OP_EPOP, B):
     480      printf("OP_EPOP\t%d\n", a);
     481      break;
     482
     483    CASE(OP_DEBUG, BBB):
     484      printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c);
     485      break;
     486
     487    CASE(OP_STOP, Z):
     488      printf("OP_STOP\n");
     489      break;
     490
     491    CASE(OP_EXT1, Z):
     492      ins = READ_B();
     493      printf("OP_EXT1\n");
     494      print_header(mrb, irep, pc-irep->iseq-2);
     495      switch (ins) {
     496#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
     497#include "mruby/ops.h"
     498#undef OPCODE
    435499      }
    436500      break;
    437     case OP_RAISE:
    438       printf("OP_RAISE\tR%d\t\t", GETARG_A(c));
    439       print_lv(mrb, irep, c, RA);
    440       break;
    441     case OP_POPERR:
    442       printf("OP_POPERR\t%d\t\t\n", GETARG_A(c));
    443       break;
    444     case OP_EPOP:
    445       printf("OP_EPOP\t%d\n", GETARG_A(c));
     501    CASE(OP_EXT2, Z):
     502      ins = READ_B();
     503      printf("OP_EXT2\n");
     504      print_header(mrb, irep, pc-irep->iseq-2);
     505      switch (ins) {
     506#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
     507#include "mruby/ops.h"
     508#undef OPCODE
     509      }
     510      break;
     511    CASE(OP_EXT3, Z):
     512      ins = READ_B();
     513      printf("OP_EXT3\n");
     514      print_header(mrb, irep, pc-irep->iseq-2);
     515      switch (ins) {
     516#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
     517#include "mruby/ops.h"
     518#undef OPCODE
     519      }
    446520      break;
    447521
    448522    default:
    449       printf("OP_unknown %d\t%d\t%d\t%d\n", GET_OPCODE(c),
    450              GETARG_A(c), GETARG_B(c), GETARG_C(c));
     523      printf("OP_unknown (0x%x)\n", ins);
    451524      break;
    452525    }
    … …  
    454527  }
    455528  printf("\n");
    456 #endif
    457529}
    458530
    … …  
    460532codedump_recur(mrb_state *mrb, mrb_irep *irep)
    461533{
    462   size_t i;
     534  int i;
    463535
    464536  codedump(mrb, irep);
    … …  
    467539  }
    468540}
     541#endif
    469542
    470543void
    471544mrb_codedump_all(mrb_state *mrb, struct RProc *proc)
    472545{
     546#ifndef MRB_DISABLE_STDIO
    473547  codedump_recur(mrb, proc->body.irep);
    474 }
     548#endif
     549}
Note: See TracChangeset for help on using the changeset viewer.