← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to regexec.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-09-04 16:01:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070904160117-i15zckg2nhxe9fyw
Tags: 1.9.0+20070830-2ubuntu1
* Sync from Debian; remaining changes:
  - Add -g to CFLAGS.
* Fixes build failure on ia64.
* Fixes build failure with gcc-4.2 on lpia.
* Robustify check for target_os, fixing build failure on lpia.
* Set Ubuntu maintainer address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
regexec.c
111
111
        (OnigCaptureTreeNode** )xrealloc(parent->childs,
112
112
                                         sizeof(OnigCaptureTreeNode*) * n);
113
113
    }
114
 
    CHECK_NULL_RETURN_VAL(parent->childs, ONIGERR_MEMORY);
 
114
    CHECK_NULL_RETURN_MEMERR(parent->childs);
115
115
    for (i = parent->allocated; i < n; i++) {
116
116
      parent->childs[i] = (OnigCaptureTreeNode* )0;
117
117
    }
331
331
  (msa).region   = (arg_region);\
332
332
  (msa).start    = (arg_start);\
333
333
  (msa).best_len = ONIG_MISMATCH;\
334
 
} while (0)
 
334
} while(0)
335
335
#else
336
336
#define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start) do {\
337
337
  (msa).stack_p  = (void* )0;\
338
338
  (msa).options  = (arg_option);\
339
339
  (msa).region   = (arg_region);\
340
340
  (msa).start    = (arg_start);\
341
 
} while (0)
 
341
} while(0)
342
342
#endif
343
343
 
344
344
#ifdef USE_COMBINATION_EXPLOSION_CHECK
367
367
    (msa).state_check_buff = (void* )0;\
368
368
    (msa).state_check_buff_size = 0;\
369
369
  }\
370
 
} while (0)
 
370
  } while(0)
371
371
 
372
372
#define MATCH_ARG_FREE(msa) do {\
373
373
  if ((msa).stack_p) xfree((msa).stack_p);\
374
374
  if ((msa).state_check_buff_size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) { \
375
375
    if ((msa).state_check_buff) xfree((msa).state_check_buff);\
376
376
  }\
377
 
} while (0);
 
377
} while(0)
378
378
#else
379
379
#define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num)
380
380
#define MATCH_ARG_FREE(msa)  if ((msa).stack_p) xfree((msa).stack_p)
623
623
      level--;\
624
624
    }\
625
625
  }\
626
 
} while (0)
 
626
} while(0)
627
627
 
628
628
#define STACK_GET_MEM_RANGE(k, mnum, start, end) do {\
629
629
  int level = 0;\
641
641
    }\
642
642
    k++;\
643
643
  }\
644
 
} while (0)
 
644
} while(0)
645
645
 
646
646
#define STACK_PUSH_NULL_CHECK_START(cnum, s) do {\
647
647
  STACK_ENSURE(1);\
939
939
    else if (k->type == STK_CALL_FRAME) level--;\
940
940
    else if (k->type == STK_RETURN)     level++;\
941
941
  }\
942
 
} while (0)
 
942
} while(0)
943
943
 
944
944
#define STACK_RETURN(addr)  do {\
945
945
  int level = 0;\
1045
1045
      if (n <= ONIG_MAX_CAPTURE_HISTORY_GROUP &&
1046
1046
          BIT_STATUS_AT(reg->capture_history, n) != 0) {
1047
1047
        child = history_node_new();
1048
 
        CHECK_NULL_RETURN_VAL(child, ONIGERR_MEMORY);
 
1048
        CHECK_NULL_RETURN_MEMERR(child);
1049
1049
        child->group = n;
1050
1050
        child->beg = (int )(k->u.mem.pstr - str);
1051
1051
        r = history_tree_add_child(node, child);
1174
1174
static int OpPrevTarget = OP_FAIL;
1175
1175
static int MaxStackDepth = 0;
1176
1176
 
1177
 
#define STAT_OP_IN(opcode) do {\
 
1177
#define MOP_IN(opcode) do {\
1178
1178
  if (opcode == OpPrevTarget) OpPrevCounter[OpCurr]++;\
1179
1179
  OpCurr = opcode;\
1180
1180
  OpCounter[opcode]++;\
1181
1181
  GETTIME(ts);\
1182
 
} while (0)
 
1182
} while(0)
1183
1183
 
1184
 
#define STAT_OP_OUT do {\
 
1184
#define MOP_OUT do {\
1185
1185
  GETTIME(te);\
1186
1186
  OpTime[OpCurr] += TIMEDIFF(te, ts);\
1187
 
} while (0)
 
1187
} while(0)
1188
1188
 
1189
1189
extern void
1190
1190
onig_statistics_init(void)
1212
1212
  stk++;\
1213
1213
  if (stk - stk_base > MaxStackDepth) \
1214
1214
    MaxStackDepth = stk - stk_base;\
1215
 
} while (0)
 
1215
} while(0)
1216
1216
 
1217
1217
#else
1218
1218
#define STACK_INC     stk++
1219
1219
 
1220
 
#define STAT_OP_IN(opcode)
1221
 
#define STAT_OP_OUT
 
1220
#define MOP_IN(opcode)
 
1221
#define MOP_OUT
1222
1222
#endif
1223
1223
 
1224
 
extern int
1225
 
onig_is_in_code_range(const UChar* p, OnigCodePoint code)
1226
 
{
1227
 
  OnigCodePoint n, *data;
1228
 
  OnigCodePoint low, high, x;
1229
 
 
1230
 
  GET_CODE_POINT(n, p);
1231
 
  data = (OnigCodePoint* )p;
1232
 
  data++;
1233
 
 
1234
 
  for (low = 0, high = n; low < high; ) {
1235
 
    x = (low + high) >> 1;
1236
 
    if (code > data[x * 2 + 1])
1237
 
      low = x + 1;
1238
 
    else
1239
 
      high = x;
1240
 
  }
1241
 
 
1242
 
  return ((low < n && code >= data[low * 2]) ? 1 : 0);
1243
 
}
1244
 
 
1245
 
static int
1246
 
is_code_in_cc(int enclen, OnigCodePoint code, CClassNode* cc)
1247
 
{
1248
 
  int found;
1249
 
 
1250
 
  if (enclen > 1 || (code >= SINGLE_BYTE_SIZE)) {
1251
 
    if (IS_NULL(cc->mbuf)) {
1252
 
      found = 0;
1253
 
    }
1254
 
    else {
1255
 
      found = (onig_is_in_code_range(cc->mbuf->p, code) != 0 ? 1 : 0);
1256
 
    }
1257
 
  }
1258
 
  else {
1259
 
    found = (BITSET_AT(cc->bs, code) == 0 ? 0 : 1);
1260
 
  }
1261
 
 
1262
 
  if (IS_CCLASS_NOT(cc))
1263
 
    return !found;
1264
 
  else
1265
 
    return found;
1266
 
}
1267
 
 
1268
 
extern int
1269
 
onig_is_code_in_cc(OnigEncoding enc, OnigCodePoint code, CClassNode* cc)
1270
 
{
1271
 
  int len;
1272
 
 
1273
 
  if (ONIGENC_MBC_MINLEN(enc) > 1) {
1274
 
    len = 2;
1275
 
  }
1276
 
  else {
1277
 
    len = ONIGENC_CODE_TO_MBCLEN(enc, code);
1278
 
  }
1279
 
  return is_code_in_cc(len, code, cc);
1280
 
}
1281
 
 
1282
1224
 
1283
1225
/* matching region of POSIX API */
1284
1226
typedef int regoff_t;
1369
1311
 
1370
1312
    sbegin = s;
1371
1313
    switch (*p++) {
1372
 
    case OP_END:  STAT_OP_IN(OP_END);
 
1314
    case OP_END:  MOP_IN(OP_END);
1373
1315
      n = s - sstart;
1374
1316
      if (n > best_len) {
1375
1317
        OnigRegion* region;
1435
1377
 
1436
1378
              if (IS_NULL(region->history_root)) {
1437
1379
                region->history_root = node = history_node_new();
1438
 
                CHECK_NULL_RETURN_VAL(node, ONIGERR_MEMORY);
 
1380
                CHECK_NULL_RETURN_MEMERR(node);
1439
1381
              }
1440
1382
              else {
1441
1383
                node = region->history_root;
1464
1406
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
1465
1407
    end_best_len:
1466
1408
#endif
1467
 
      STAT_OP_OUT;
 
1409
      MOP_OUT;
1468
1410
 
1469
1411
      if (IS_FIND_CONDITION(option)) {
1470
1412
        if (IS_FIND_NOT_EMPTY(option) && s == sstart) {
1480
1422
      goto finish;
1481
1423
      break;
1482
1424
 
1483
 
    case OP_EXACT1:  STAT_OP_IN(OP_EXACT1);
 
1425
    case OP_EXACT1:  MOP_IN(OP_EXACT1);
1484
1426
#if 0
1485
1427
      DATA_ENSURE(1);
1486
1428
      if (*p != *s) goto fail;
1489
1431
      if (*p != *s++) goto fail;
1490
1432
      DATA_ENSURE(0);
1491
1433
      p++;
1492
 
      STAT_OP_OUT;
 
1434
      MOP_OUT;
1493
1435
      break;
1494
1436
 
1495
 
    case OP_EXACT1_IC:  STAT_OP_IN(OP_EXACT1_IC);
 
1437
    case OP_EXACT1_IC:  MOP_IN(OP_EXACT1_IC);
1496
1438
      {
1497
1439
        int len;
1498
 
        UChar *q, *ss, *sp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
 
1440
        UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
1499
1441
 
1500
1442
        DATA_ENSURE(1);
1501
 
        ss = s;
1502
 
        sp = p;
1503
 
 
1504
1443
        len = ONIGENC_MBC_CASE_FOLD(encode,
1505
1444
                    /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
1506
1445
                    case_fold_flag,
1514
1453
          p++; q++;
1515
1454
        }
1516
1455
      }
1517
 
      STAT_OP_OUT;
 
1456
      MOP_OUT;
1518
1457
      break;
1519
1458
 
1520
 
    case OP_EXACT2:  STAT_OP_IN(OP_EXACT2);
 
1459
    case OP_EXACT2:  MOP_IN(OP_EXACT2);
1521
1460
      DATA_ENSURE(2);
1522
1461
      if (*p != *s) goto fail;
1523
1462
      p++; s++;
1524
1463
      if (*p != *s) goto fail;
1525
1464
      sprev = s;
1526
1465
      p++; s++;
1527
 
      STAT_OP_OUT;
 
1466
      MOP_OUT;
1528
1467
      continue;
1529
1468
      break;
1530
1469
 
1531
 
    case OP_EXACT3:  STAT_OP_IN(OP_EXACT3);
 
1470
    case OP_EXACT3:  MOP_IN(OP_EXACT3);
1532
1471
      DATA_ENSURE(3);
1533
1472
      if (*p != *s) goto fail;
1534
1473
      p++; s++;
1537
1476
      if (*p != *s) goto fail;
1538
1477
      sprev = s;
1539
1478
      p++; s++;
1540
 
      STAT_OP_OUT;
 
1479
      MOP_OUT;
1541
1480
      continue;
1542
1481
      break;
1543
1482
 
1544
 
    case OP_EXACT4:  STAT_OP_IN(OP_EXACT4);
 
1483
    case OP_EXACT4:  MOP_IN(OP_EXACT4);
1545
1484
      DATA_ENSURE(4);
1546
1485
      if (*p != *s) goto fail;
1547
1486
      p++; s++;
1552
1491
      if (*p != *s) goto fail;
1553
1492
      sprev = s;
1554
1493
      p++; s++;
1555
 
      STAT_OP_OUT;
 
1494
      MOP_OUT;
1556
1495
      continue;
1557
1496
      break;
1558
1497
 
1559
 
    case OP_EXACT5:  STAT_OP_IN(OP_EXACT5);
 
1498
    case OP_EXACT5:  MOP_IN(OP_EXACT5);
1560
1499
      DATA_ENSURE(5);
1561
1500
      if (*p != *s) goto fail;
1562
1501
      p++; s++;
1569
1508
      if (*p != *s) goto fail;
1570
1509
      sprev = s;
1571
1510
      p++; s++;
1572
 
      STAT_OP_OUT;
 
1511
      MOP_OUT;
1573
1512
      continue;
1574
1513
      break;
1575
1514
 
1576
 
    case OP_EXACTN:  STAT_OP_IN(OP_EXACTN);
 
1515
    case OP_EXACTN:  MOP_IN(OP_EXACTN);
1577
1516
      GET_LENGTH_INC(tlen, p);
1578
1517
      DATA_ENSURE(tlen);
1579
1518
      while (tlen-- > 0) {
1580
1519
        if (*p++ != *s++) goto fail;
1581
1520
      }
1582
1521
      sprev = s - 1;
1583
 
      STAT_OP_OUT;
 
1522
      MOP_OUT;
1584
1523
      continue;
1585
1524
      break;
1586
1525
 
1587
 
    case OP_EXACTN_IC:  STAT_OP_IN(OP_EXACTN_IC);
 
1526
    case OP_EXACTN_IC:  MOP_IN(OP_EXACTN_IC);
1588
1527
      {
1589
1528
        int len;
1590
 
        UChar *ss, *sp, *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
 
1529
        UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
1591
1530
 
1592
1531
        GET_LENGTH_INC(tlen, p);
1593
1532
        endp = p + tlen;
1595
1534
        while (p < endp) {
1596
1535
          sprev = s;
1597
1536
          DATA_ENSURE(1);
1598
 
          ss = s;
1599
 
          sp = p;
1600
 
 
1601
1537
          len = ONIGENC_MBC_CASE_FOLD(encode,
1602
1538
                      /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */
1603
1539
                      case_fold_flag,
1611
1547
        }
1612
1548
      }
1613
1549
 
1614
 
      STAT_OP_OUT;
 
1550
      MOP_OUT;
1615
1551
      continue;
1616
1552
      break;
1617
1553
 
1618
 
    case OP_EXACTMB2N1:  STAT_OP_IN(OP_EXACTMB2N1);
 
1554
    case OP_EXACTMB2N1:  MOP_IN(OP_EXACTMB2N1);
1619
1555
      DATA_ENSURE(2);
1620
1556
      if (*p != *s) goto fail;
1621
1557
      p++; s++;
1622
1558
      if (*p != *s) goto fail;
1623
1559
      p++; s++;
1624
 
      STAT_OP_OUT;
 
1560
      MOP_OUT;
1625
1561
      break;
1626
1562
 
1627
 
    case OP_EXACTMB2N2:  STAT_OP_IN(OP_EXACTMB2N2);
 
1563
    case OP_EXACTMB2N2:  MOP_IN(OP_EXACTMB2N2);
1628
1564
      DATA_ENSURE(4);
1629
1565
      if (*p != *s) goto fail;
1630
1566
      p++; s++;
1635
1571
      p++; s++;
1636
1572
      if (*p != *s) goto fail;
1637
1573
      p++; s++;
1638
 
      STAT_OP_OUT;
 
1574
      MOP_OUT;
1639
1575
      continue;
1640
1576
      break;
1641
1577
 
1642
 
    case OP_EXACTMB2N3:  STAT_OP_IN(OP_EXACTMB2N3);
 
1578
    case OP_EXACTMB2N3:  MOP_IN(OP_EXACTMB2N3);
1643
1579
      DATA_ENSURE(6);
1644
1580
      if (*p != *s) goto fail;
1645
1581
      p++; s++;
1654
1590
      p++; s++;
1655
1591
      if (*p != *s) goto fail;
1656
1592
      p++; s++;
1657
 
      STAT_OP_OUT;
 
1593
      MOP_OUT;
1658
1594
      continue;
1659
1595
      break;
1660
1596
 
1661
 
    case OP_EXACTMB2N:  STAT_OP_IN(OP_EXACTMB2N);
 
1597
    case OP_EXACTMB2N:  MOP_IN(OP_EXACTMB2N);
1662
1598
      GET_LENGTH_INC(tlen, p);
1663
1599
      DATA_ENSURE(tlen * 2);
1664
1600
      while (tlen-- > 0) {
1668
1604
        p++; s++;
1669
1605
      }
1670
1606
      sprev = s - 2;
1671
 
      STAT_OP_OUT;
 
1607
      MOP_OUT;
1672
1608
      continue;
1673
1609
      break;
1674
1610
 
1675
 
    case OP_EXACTMB3N:  STAT_OP_IN(OP_EXACTMB3N);
 
1611
    case OP_EXACTMB3N:  MOP_IN(OP_EXACTMB3N);
1676
1612
      GET_LENGTH_INC(tlen, p);
1677
1613
      DATA_ENSURE(tlen * 3);
1678
1614
      while (tlen-- > 0) {
1684
1620
        p++; s++;
1685
1621
      }
1686
1622
      sprev = s - 3;
1687
 
      STAT_OP_OUT;
 
1623
      MOP_OUT;
1688
1624
      continue;
1689
1625
      break;
1690
1626
 
1691
 
    case OP_EXACTMBN:  STAT_OP_IN(OP_EXACTMBN);
 
1627
    case OP_EXACTMBN:  MOP_IN(OP_EXACTMBN);
1692
1628
      GET_LENGTH_INC(tlen,  p);  /* mb-len */
1693
1629
      GET_LENGTH_INC(tlen2, p);  /* string len */
1694
1630
      tlen2 *= tlen;
1698
1634
        p++; s++;
1699
1635
      }
1700
1636
      sprev = s - tlen;
1701
 
      STAT_OP_OUT;
 
1637
      MOP_OUT;
1702
1638
      continue;
1703
1639
      break;
1704
1640
 
1705
 
    case OP_CCLASS:  STAT_OP_IN(OP_CCLASS);
 
1641
    case OP_CCLASS:  MOP_IN(OP_CCLASS);
1706
1642
      DATA_ENSURE(1);
1707
1643
      if (BITSET_AT(((BitSetRef )p), *s) == 0) goto fail;
1708
1644
      p += SIZE_BITSET;
1709
1645
      s += enc_len(encode, s);   /* OP_CCLASS can match mb-code. \D, \S */
1710
 
      STAT_OP_OUT;
 
1646
      MOP_OUT;
1711
1647
      break;
1712
1648
 
1713
 
    case OP_CCLASS_MB:  STAT_OP_IN(OP_CCLASS_MB);
 
1649
    case OP_CCLASS_MB:  MOP_IN(OP_CCLASS_MB);
1714
1650
      if (! ONIGENC_IS_MBC_HEAD(encode, s)) goto fail;
1715
1651
 
1716
1652
    cclass_mb:
1736
1672
#endif
1737
1673
      }
1738
1674
      p += tlen;
1739
 
      STAT_OP_OUT;
 
1675
      MOP_OUT;
1740
1676
      break;
1741
1677
 
1742
 
    case OP_CCLASS_MIX:  STAT_OP_IN(OP_CCLASS_MIX);
 
1678
    case OP_CCLASS_MIX:  MOP_IN(OP_CCLASS_MIX);
1743
1679
      DATA_ENSURE(1);
1744
1680
      if (ONIGENC_IS_MBC_HEAD(encode, s)) {
1745
1681
        p += SIZE_BITSET;
1754
1690
        p += tlen;
1755
1691
        s++;
1756
1692
      }
1757
 
      STAT_OP_OUT;
 
1693
      MOP_OUT;
1758
1694
      break;
1759
1695
 
1760
 
    case OP_CCLASS_NOT:  STAT_OP_IN(OP_CCLASS_NOT);
 
1696
    case OP_CCLASS_NOT:  MOP_IN(OP_CCLASS_NOT);
1761
1697
      DATA_ENSURE(1);
1762
1698
      if (BITSET_AT(((BitSetRef )p), *s) != 0) goto fail;
1763
1699
      p += SIZE_BITSET;
1764
1700
      s += enc_len(encode, s);
1765
 
      STAT_OP_OUT;
 
1701
      MOP_OUT;
1766
1702
      break;
1767
1703
 
1768
 
    case OP_CCLASS_MB_NOT:  STAT_OP_IN(OP_CCLASS_MB_NOT);
 
1704
    case OP_CCLASS_MB_NOT:  MOP_IN(OP_CCLASS_MB_NOT);
1769
1705
      DATA_ENSURE(1);
1770
1706
      if (! ONIGENC_IS_MBC_HEAD(encode, s)) {
1771
1707
        s++;
1803
1739
      p += tlen;
1804
1740
 
1805
1741
    cc_mb_not_success:
1806
 
      STAT_OP_OUT;
 
1742
      MOP_OUT;
1807
1743
      break;
1808
1744
 
1809
 
    case OP_CCLASS_MIX_NOT:  STAT_OP_IN(OP_CCLASS_MIX_NOT);
 
1745
    case OP_CCLASS_MIX_NOT:  MOP_IN(OP_CCLASS_MIX_NOT);
1810
1746
      DATA_ENSURE(1);
1811
1747
      if (ONIGENC_IS_MBC_HEAD(encode, s)) {
1812
1748
        p += SIZE_BITSET;
1821
1757
        p += tlen;
1822
1758
        s++;
1823
1759
      }
1824
 
      STAT_OP_OUT;
 
1760
      MOP_OUT;
1825
1761
      break;
1826
1762
 
1827
 
    case OP_CCLASS_NODE:  STAT_OP_IN(OP_CCLASS_NODE);
 
1763
    case OP_CCLASS_NODE:  MOP_IN(OP_CCLASS_NODE);
1828
1764
      {
1829
1765
        OnigCodePoint code;
1830
1766
        void *node;
1838
1774
        s += mb_len;
1839
1775
        DATA_ENSURE(0);
1840
1776
        code = ONIGENC_MBC_TO_CODE(encode, ss, s);
1841
 
        if (is_code_in_cc(mb_len, code, node) == 0) goto fail;
 
1777
        if (onig_is_code_in_cc_len(mb_len, code, node) == 0) goto fail;
1842
1778
      }
1843
 
      STAT_OP_OUT;
 
1779
      MOP_OUT;
1844
1780
      break;
1845
1781
 
1846
 
    case OP_ANYCHAR:  STAT_OP_IN(OP_ANYCHAR);
 
1782
    case OP_ANYCHAR:  MOP_IN(OP_ANYCHAR);
1847
1783
      DATA_ENSURE(1);
1848
1784
      n = enc_len(encode, s);
1849
1785
      DATA_ENSURE(n);
1850
1786
      if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail;
1851
1787
      s += n;
1852
 
      STAT_OP_OUT;
 
1788
      MOP_OUT;
1853
1789
      break;
1854
1790
 
1855
 
    case OP_ANYCHAR_ML:  STAT_OP_IN(OP_ANYCHAR_ML);
 
1791
    case OP_ANYCHAR_ML:  MOP_IN(OP_ANYCHAR_ML);
1856
1792
      DATA_ENSURE(1);
1857
1793
      n = enc_len(encode, s);
1858
1794
      DATA_ENSURE(n);
1859
1795
      s += n;
1860
 
      STAT_OP_OUT;
1861
 
      break;
1862
 
 
1863
 
    case OP_ANYCHAR_STAR:  STAT_OP_IN(OP_ANYCHAR_STAR);
1864
 
      while (DATA_ENSURE_CHECK1) {
1865
 
        STACK_PUSH_ALT(p, s, sprev);
1866
 
        n = enc_len(encode, s);
1867
 
        DATA_ENSURE(n);
1868
 
        if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
1869
 
        sprev = s;
1870
 
        s += n;
1871
 
      }
1872
 
      STAT_OP_OUT;
1873
 
      break;
1874
 
 
1875
 
    case OP_ANYCHAR_ML_STAR:  STAT_OP_IN(OP_ANYCHAR_ML_STAR);
1876
 
      while (DATA_ENSURE_CHECK1) {
1877
 
        STACK_PUSH_ALT(p, s, sprev);
1878
 
        n = enc_len(encode, s);
1879
 
        if (n > 1) {
1880
 
          DATA_ENSURE(n);
1881
 
          sprev = s;
1882
 
          s += n;
1883
 
        }
1884
 
        else {
1885
 
          sprev = s;
1886
 
          s++;
1887
 
        }
1888
 
      }
1889
 
      STAT_OP_OUT;
1890
 
      break;
1891
 
 
1892
 
    case OP_ANYCHAR_STAR_PEEK_NEXT:  STAT_OP_IN(OP_ANYCHAR_STAR_PEEK_NEXT);
1893
 
      while (DATA_ENSURE_CHECK1) {
1894
 
        if (*p == *s) {
1895
 
          STACK_PUSH_ALT(p + 1, s, sprev);
1896
 
        }
1897
 
        n = enc_len(encode, s);
1898
 
        DATA_ENSURE(n);
1899
 
        if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
1900
 
        sprev = s;
1901
 
        s += n;
1902
 
      }
1903
 
      p++;
1904
 
      STAT_OP_OUT;
1905
 
      break;
1906
 
 
1907
 
    case OP_ANYCHAR_ML_STAR_PEEK_NEXT:STAT_OP_IN(OP_ANYCHAR_ML_STAR_PEEK_NEXT);
1908
 
      while (DATA_ENSURE_CHECK1) {
1909
 
        if (*p == *s) {
1910
 
          STACK_PUSH_ALT(p + 1, s, sprev);
1911
 
        }
1912
 
        n = enc_len(encode, s);
1913
 
        if (n >1) {
1914
 
          DATA_ENSURE(n);
1915
 
          sprev = s;
1916
 
          s += n;
1917
 
        }
1918
 
        else {
1919
 
          sprev = s;
1920
 
          s++;
1921
 
        }
1922
 
      }
1923
 
      p++;
1924
 
      STAT_OP_OUT;
 
1796
      MOP_OUT;
 
1797
      break;
 
1798
 
 
1799
    case OP_ANYCHAR_STAR:  MOP_IN(OP_ANYCHAR_STAR);
 
1800
      while (DATA_ENSURE_CHECK1) {
 
1801
        STACK_PUSH_ALT(p, s, sprev);
 
1802
        n = enc_len(encode, s);
 
1803
        DATA_ENSURE(n);
 
1804
        if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
 
1805
        sprev = s;
 
1806
        s += n;
 
1807
      }
 
1808
      MOP_OUT;
 
1809
      break;
 
1810
 
 
1811
    case OP_ANYCHAR_ML_STAR:  MOP_IN(OP_ANYCHAR_ML_STAR);
 
1812
      while (DATA_ENSURE_CHECK1) {
 
1813
        STACK_PUSH_ALT(p, s, sprev);
 
1814
        n = enc_len(encode, s);
 
1815
        if (n > 1) {
 
1816
          DATA_ENSURE(n);
 
1817
          sprev = s;
 
1818
          s += n;
 
1819
        }
 
1820
        else {
 
1821
          sprev = s;
 
1822
          s++;
 
1823
        }
 
1824
      }
 
1825
      MOP_OUT;
 
1826
      break;
 
1827
 
 
1828
    case OP_ANYCHAR_STAR_PEEK_NEXT:  MOP_IN(OP_ANYCHAR_STAR_PEEK_NEXT);
 
1829
      while (DATA_ENSURE_CHECK1) {
 
1830
        if (*p == *s) {
 
1831
          STACK_PUSH_ALT(p + 1, s, sprev);
 
1832
        }
 
1833
        n = enc_len(encode, s);
 
1834
        DATA_ENSURE(n);
 
1835
        if (ONIGENC_IS_MBC_NEWLINE(encode, s, end))  goto fail;
 
1836
        sprev = s;
 
1837
        s += n;
 
1838
      }
 
1839
      p++;
 
1840
      MOP_OUT;
 
1841
      break;
 
1842
 
 
1843
    case OP_ANYCHAR_ML_STAR_PEEK_NEXT:MOP_IN(OP_ANYCHAR_ML_STAR_PEEK_NEXT);
 
1844
      while (DATA_ENSURE_CHECK1) {
 
1845
        if (*p == *s) {
 
1846
          STACK_PUSH_ALT(p + 1, s, sprev);
 
1847
        }
 
1848
        n = enc_len(encode, s);
 
1849
        if (n > 1) {
 
1850
          DATA_ENSURE(n);
 
1851
          sprev = s;
 
1852
          s += n;
 
1853
        }
 
1854
        else {
 
1855
          sprev = s;
 
1856
          s++;
 
1857
        }
 
1858
      }
 
1859
      p++;
 
1860
      MOP_OUT;
1925
1861
      break;
1926
1862
 
1927
1863
#ifdef USE_COMBINATION_EXPLOSION_CHECK
1928
 
    case OP_STATE_CHECK_ANYCHAR_STAR:  STAT_OP_IN(OP_STATE_CHECK_ANYCHAR_STAR);
 
1864
    case OP_STATE_CHECK_ANYCHAR_STAR:  MOP_IN(OP_STATE_CHECK_ANYCHAR_STAR);
1929
1865
      GET_STATE_CHECK_NUM_INC(mem, p);
1930
1866
      while (DATA_ENSURE_CHECK1) {
1931
1867
        STATE_CHECK_VAL(scv, mem);
1938
1874
        sprev = s;
1939
1875
        s += n;
1940
1876
      }
1941
 
      STAT_OP_OUT;
 
1877
      MOP_OUT;
1942
1878
      break;
1943
1879
 
1944
1880
    case OP_STATE_CHECK_ANYCHAR_ML_STAR:
1945
 
      STAT_OP_IN(OP_STATE_CHECK_ANYCHAR_ML_STAR);
 
1881
      MOP_IN(OP_STATE_CHECK_ANYCHAR_ML_STAR);
1946
1882
 
1947
1883
      GET_STATE_CHECK_NUM_INC(mem, p);
1948
1884
      while (DATA_ENSURE_CHECK1) {
1961
1897
          s++;
1962
1898
        }
1963
1899
      }
1964
 
      STAT_OP_OUT;
 
1900
      MOP_OUT;
1965
1901
      break;
1966
1902
#endif /* USE_COMBINATION_EXPLOSION_CHECK */
1967
1903
 
1968
 
    case OP_WORD:  STAT_OP_IN(OP_WORD);
 
1904
    case OP_WORD:  MOP_IN(OP_WORD);
1969
1905
      DATA_ENSURE(1);
1970
1906
      if (! ONIGENC_IS_MBC_WORD(encode, s, end))
1971
1907
        goto fail;
1972
1908
 
1973
1909
      s += enc_len(encode, s);
1974
 
      STAT_OP_OUT;
 
1910
      MOP_OUT;
1975
1911
      break;
1976
1912
 
1977
 
    case OP_NOT_WORD:  STAT_OP_IN(OP_NOT_WORD);
 
1913
    case OP_NOT_WORD:  MOP_IN(OP_NOT_WORD);
1978
1914
      DATA_ENSURE(1);
1979
1915
      if (ONIGENC_IS_MBC_WORD(encode, s, end))
1980
1916
        goto fail;
1981
1917
 
1982
1918
      s += enc_len(encode, s);
1983
 
      STAT_OP_OUT;
 
1919
      MOP_OUT;
1984
1920
      break;
1985
1921
 
1986
 
    case OP_WORD_BOUND:  STAT_OP_IN(OP_WORD_BOUND);
 
1922
    case OP_WORD_BOUND:  MOP_IN(OP_WORD_BOUND);
1987
1923
      if (ON_STR_BEGIN(s)) {
1988
1924
        DATA_ENSURE(1);
1989
1925
        if (! ONIGENC_IS_MBC_WORD(encode, s, end))
1998
1934
            == ONIGENC_IS_MBC_WORD(encode, sprev, end))
1999
1935
          goto fail;
2000
1936
      }
2001
 
      STAT_OP_OUT;
 
1937
      MOP_OUT;
2002
1938
      continue;
2003
1939
      break;
2004
1940
 
2005
 
    case OP_NOT_WORD_BOUND:  STAT_OP_IN(OP_NOT_WORD_BOUND);
 
1941
    case OP_NOT_WORD_BOUND:  MOP_IN(OP_NOT_WORD_BOUND);
2006
1942
      if (ON_STR_BEGIN(s)) {
2007
1943
        if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end))
2008
1944
          goto fail;
2016
1952
            != ONIGENC_IS_MBC_WORD(encode, sprev, end))
2017
1953
          goto fail;
2018
1954
      }
2019
 
      STAT_OP_OUT;
 
1955
      MOP_OUT;
2020
1956
      continue;
2021
1957
      break;
2022
1958
 
2023
1959
#ifdef USE_WORD_BEGIN_END
2024
 
    case OP_WORD_BEGIN:  STAT_OP_IN(OP_WORD_BEGIN);
 
1960
    case OP_WORD_BEGIN:  MOP_IN(OP_WORD_BEGIN);
2025
1961
      if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) {
2026
1962
        if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
2027
 
          STAT_OP_OUT;
 
1963
          MOP_OUT;
2028
1964
          continue;
2029
1965
        }
2030
1966
      }
2031
1967
      goto fail;
2032
1968
      break;
2033
1969
 
2034
 
    case OP_WORD_END:  STAT_OP_IN(OP_WORD_END);
 
1970
    case OP_WORD_END:  MOP_IN(OP_WORD_END);
2035
1971
      if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
2036
1972
        if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) {
2037
 
          STAT_OP_OUT;
 
1973
          MOP_OUT;
2038
1974
          continue;
2039
1975
        }
2040
1976
      }
2042
1978
      break;
2043
1979
#endif
2044
1980
 
2045
 
    case OP_BEGIN_BUF:  STAT_OP_IN(OP_BEGIN_BUF);
 
1981
    case OP_BEGIN_BUF:  MOP_IN(OP_BEGIN_BUF);
2046
1982
      if (! ON_STR_BEGIN(s)) goto fail;
2047
1983
 
2048
 
      STAT_OP_OUT;
 
1984
      MOP_OUT;
2049
1985
      continue;
2050
1986
      break;
2051
1987
 
2052
 
    case OP_END_BUF:  STAT_OP_IN(OP_END_BUF);
 
1988
    case OP_END_BUF:  MOP_IN(OP_END_BUF);
2053
1989
      if (! ON_STR_END(s)) goto fail;
2054
1990
 
2055
 
      STAT_OP_OUT;
 
1991
      MOP_OUT;
2056
1992
      continue;
2057
1993
      break;
2058
1994
 
2059
 
    case OP_BEGIN_LINE:  STAT_OP_IN(OP_BEGIN_LINE);
 
1995
    case OP_BEGIN_LINE:  MOP_IN(OP_BEGIN_LINE);
2060
1996
      if (ON_STR_BEGIN(s)) {
2061
1997
        if (IS_NOTBOL(msa->options)) goto fail;
2062
 
        STAT_OP_OUT;
 
1998
        MOP_OUT;
2063
1999
        continue;
2064
2000
      }
2065
2001
      else if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end) && !ON_STR_END(s)) {
2066
 
        STAT_OP_OUT;
 
2002
        MOP_OUT;
2067
2003
        continue;
2068
2004
      }
2069
2005
      goto fail;
2070
2006
      break;
2071
2007
 
2072
 
    case OP_END_LINE:  STAT_OP_IN(OP_END_LINE);
 
2008
    case OP_END_LINE:  MOP_IN(OP_END_LINE);
2073
2009
      if (ON_STR_END(s)) {
2074
2010
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2075
2011
        if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
2076
2012
#endif
2077
2013
          if (IS_NOTEOL(msa->options)) goto fail;
2078
 
          STAT_OP_OUT;
 
2014
          MOP_OUT;
2079
2015
          continue;
2080
2016
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2081
2017
        }
2082
2018
#endif
2083
2019
      }
2084
2020
      else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) {
2085
 
        STAT_OP_OUT;
 
2021
        MOP_OUT;
2086
2022
        continue;
2087
2023
      }
2088
2024
#ifdef USE_CRNL_AS_LINE_TERMINATOR
2089
2025
      else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {
2090
 
        STAT_OP_OUT;
 
2026
        MOP_OUT;
2091
2027
        continue;
2092
2028
      }
2093
2029
#endif
2094
2030
      goto fail;
2095
2031
      break;
2096
2032
 
2097
 
    case OP_SEMI_END_BUF:  STAT_OP_IN(OP_SEMI_END_BUF);
 
2033
    case OP_SEMI_END_BUF:  MOP_IN(OP_SEMI_END_BUF);
2098
2034
      if (ON_STR_END(s)) {
2099
2035
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2100
2036
        if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
2101
2037
#endif
2102
 
          if (IS_NOTEOL(msa->options)) goto fail;   /* Is it needed? */
2103
 
          STAT_OP_OUT;
 
2038
          if (IS_NOTEOL(msa->options)) goto fail;
 
2039
          MOP_OUT;
2104
2040
          continue;
2105
2041
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2106
2042
        }
2108
2044
      }
2109
2045
      else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end) &&
2110
2046
               ON_STR_END(s + enc_len(encode, s))) {
2111
 
        STAT_OP_OUT;
 
2047
        MOP_OUT;
2112
2048
        continue;
2113
2049
      }
2114
2050
#ifdef USE_CRNL_AS_LINE_TERMINATOR
2115
2051
      else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {
2116
2052
        UChar* ss = s + enc_len(encode, s);
2117
 
        if (ON_STR_END(ss + enc_len(encode, ss))) {
2118
 
          STAT_OP_OUT;
 
2053
        ss += enc_len(encode, ss);
 
2054
        if (ON_STR_END(ss)) {
 
2055
          MOP_OUT;
2119
2056
          continue;
2120
2057
        }
2121
2058
      }
2123
2060
      goto fail;
2124
2061
      break;
2125
2062
 
2126
 
    case OP_BEGIN_POSITION:  STAT_OP_IN(OP_BEGIN_POSITION);
 
2063
    case OP_BEGIN_POSITION:  MOP_IN(OP_BEGIN_POSITION);
2127
2064
      if (s != msa->start)
2128
2065
        goto fail;
2129
2066
 
2130
 
      STAT_OP_OUT;
 
2067
      MOP_OUT;
2131
2068
      continue;
2132
2069
      break;
2133
2070
 
2134
 
    case OP_MEMORY_START_PUSH:  STAT_OP_IN(OP_MEMORY_START_PUSH);
 
2071
    case OP_MEMORY_START_PUSH:  MOP_IN(OP_MEMORY_START_PUSH);
2135
2072
      GET_MEMNUM_INC(mem, p);
2136
2073
      STACK_PUSH_MEM_START(mem, s);
2137
 
      STAT_OP_OUT;
 
2074
      MOP_OUT;
2138
2075
      continue;
2139
2076
      break;
2140
2077
 
2141
 
    case OP_MEMORY_START:  STAT_OP_IN(OP_MEMORY_START);
 
2078
    case OP_MEMORY_START:  MOP_IN(OP_MEMORY_START);
2142
2079
      GET_MEMNUM_INC(mem, p);
2143
2080
      mem_start_stk[mem] = (OnigStackIndex )((void* )s);
2144
 
      STAT_OP_OUT;
 
2081
      MOP_OUT;
2145
2082
      continue;
2146
2083
      break;
2147
2084
 
2148
 
    case OP_MEMORY_END_PUSH:  STAT_OP_IN(OP_MEMORY_END_PUSH);
 
2085
    case OP_MEMORY_END_PUSH:  MOP_IN(OP_MEMORY_END_PUSH);
2149
2086
      GET_MEMNUM_INC(mem, p);
2150
2087
      STACK_PUSH_MEM_END(mem, s);
2151
 
      STAT_OP_OUT;
 
2088
      MOP_OUT;
2152
2089
      continue;
2153
2090
      break;
2154
2091
 
2155
 
    case OP_MEMORY_END:  STAT_OP_IN(OP_MEMORY_END);
 
2092
    case OP_MEMORY_END:  MOP_IN(OP_MEMORY_END);
2156
2093
      GET_MEMNUM_INC(mem, p);
2157
2094
      mem_end_stk[mem] = (OnigStackIndex )((void* )s);
2158
 
      STAT_OP_OUT;
 
2095
      MOP_OUT;
2159
2096
      continue;
2160
2097
      break;
2161
2098
 
2162
2099
#ifdef USE_SUBEXP_CALL
2163
 
    case OP_MEMORY_END_PUSH_REC:  STAT_OP_IN(OP_MEMORY_END_PUSH_REC);
 
2100
    case OP_MEMORY_END_PUSH_REC:  MOP_IN(OP_MEMORY_END_PUSH_REC);
2164
2101
      GET_MEMNUM_INC(mem, p);
2165
2102
      STACK_GET_MEM_START(mem, stkp); /* should be before push mem-end. */
2166
2103
      STACK_PUSH_MEM_END(mem, s);
2167
2104
      mem_start_stk[mem] = GET_STACK_INDEX(stkp);
2168
 
      STAT_OP_OUT;
 
2105
      MOP_OUT;
2169
2106
      continue;
2170
2107
      break;
2171
2108
 
2172
 
    case OP_MEMORY_END_REC:  STAT_OP_IN(OP_MEMORY_END_REC);
 
2109
    case OP_MEMORY_END_REC:  MOP_IN(OP_MEMORY_END_REC);
2173
2110
      GET_MEMNUM_INC(mem, p);
2174
2111
      mem_end_stk[mem] = (OnigStackIndex )((void* )s);
2175
2112
      STACK_GET_MEM_START(mem, stkp);
2180
2117
        mem_start_stk[mem] = (OnigStackIndex )((void* )stkp->u.mem.pstr);
2181
2118
 
2182
2119
      STACK_PUSH_MEM_END_MARK(mem);
2183
 
      STAT_OP_OUT;
 
2120
      MOP_OUT;
2184
2121
      continue;
2185
2122
      break;
2186
2123
#endif
2187
2124
 
2188
 
    case OP_BACKREF1:  STAT_OP_IN(OP_BACKREF1);
 
2125
    case OP_BACKREF1:  MOP_IN(OP_BACKREF1);
2189
2126
      mem = 1;
2190
2127
      goto backref;
2191
2128
      break;
2192
2129
 
2193
 
    case OP_BACKREF2:  STAT_OP_IN(OP_BACKREF2);
 
2130
    case OP_BACKREF2:  MOP_IN(OP_BACKREF2);
2194
2131
      mem = 2;
2195
2132
      goto backref;
2196
2133
      break;
2197
2134
 
2198
 
    case OP_BACKREFN:  STAT_OP_IN(OP_BACKREFN);
 
2135
    case OP_BACKREFN:  MOP_IN(OP_BACKREFN);
2199
2136
      GET_MEMNUM_INC(mem, p);
2200
2137
    backref:
2201
2138
      {
2223
2160
        while (sprev + (len = enc_len(encode, sprev)) < s)
2224
2161
          sprev += len;
2225
2162
 
2226
 
        STAT_OP_OUT;
 
2163
        MOP_OUT;
2227
2164
        continue;
2228
2165
      }
2229
2166
      break;
2230
2167
 
2231
 
    case OP_BACKREFN_IC:  STAT_OP_IN(OP_BACKREFN_IC);
 
2168
    case OP_BACKREFN_IC:  MOP_IN(OP_BACKREFN_IC);
2232
2169
      GET_MEMNUM_INC(mem, p);
2233
2170
      {
2234
2171
        int len;
2255
2192
        while (sprev + (len = enc_len(encode, sprev)) < s)
2256
2193
          sprev += len;
2257
2194
 
2258
 
        STAT_OP_OUT;
 
2195
        MOP_OUT;
2259
2196
        continue;
2260
2197
      }
2261
2198
      break;
2262
2199
 
2263
 
    case OP_BACKREF_MULTI:  STAT_OP_IN(OP_BACKREF_MULTI);
 
2200
    case OP_BACKREF_MULTI:  MOP_IN(OP_BACKREF_MULTI);
2264
2201
      {
2265
2202
        int len, is_fail;
2266
2203
        UChar *pstart, *pend, *swork;
2294
2231
          break; /* success */
2295
2232
        }
2296
2233
        if (i == tlen) goto fail;
2297
 
        STAT_OP_OUT;
 
2234
        MOP_OUT;
2298
2235
        continue;
2299
2236
      }
2300
2237
      break;
2301
2238
 
2302
 
    case OP_BACKREF_MULTI_IC:  STAT_OP_IN(OP_BACKREF_MULTI_IC);
 
2239
    case OP_BACKREF_MULTI_IC:  MOP_IN(OP_BACKREF_MULTI_IC);
2303
2240
      {
2304
2241
        int len, is_fail;
2305
2242
        UChar *pstart, *pend, *swork;
2333
2270
          break; /* success */
2334
2271
        }
2335
2272
        if (i == tlen) goto fail;
2336
 
        STAT_OP_OUT;
 
2273
        MOP_OUT;
2337
2274
        continue;
2338
2275
      }
2339
2276
      break;
2360
2297
        else
2361
2298
          goto fail;
2362
2299
 
2363
 
        STAT_OP_OUT;
 
2300
        MOP_OUT;
2364
2301
        continue;
2365
2302
      }
2366
2303
      
2367
2304
      break;
2368
2305
#endif
2369
 
    
2370
 
    case OP_SET_OPTION_PUSH:  STAT_OP_IN(OP_SET_OPTION_PUSH);
 
2306
 
 
2307
#if 0   /* no need: IS_DYNAMIC_OPTION() == 0 */
 
2308
    case OP_SET_OPTION_PUSH:  MOP_IN(OP_SET_OPTION_PUSH);
2371
2309
      GET_OPTION_INC(option, p);
2372
2310
      STACK_PUSH_ALT(p, s, sprev);
2373
2311
      p += SIZE_OP_SET_OPTION + SIZE_OP_FAIL;
2374
 
      STAT_OP_OUT;
 
2312
      MOP_OUT;
2375
2313
      continue;
2376
2314
      break;
2377
2315
 
2378
 
    case OP_SET_OPTION:  STAT_OP_IN(OP_SET_OPTION);
 
2316
    case OP_SET_OPTION:  MOP_IN(OP_SET_OPTION);
2379
2317
      GET_OPTION_INC(option, p);
2380
 
      STAT_OP_OUT;
 
2318
      MOP_OUT;
2381
2319
      continue;
2382
2320
      break;
 
2321
#endif
2383
2322
 
2384
 
    case OP_NULL_CHECK_START:  STAT_OP_IN(OP_NULL_CHECK_START);
 
2323
    case OP_NULL_CHECK_START:  MOP_IN(OP_NULL_CHECK_START);
2385
2324
      GET_MEMNUM_INC(mem, p);    /* mem: null check id */
2386
2325
      STACK_PUSH_NULL_CHECK_START(mem, s);
2387
 
      STAT_OP_OUT;
 
2326
      MOP_OUT;
2388
2327
      continue;
2389
2328
      break;
2390
2329
 
2391
 
    case OP_NULL_CHECK_END:  STAT_OP_IN(OP_NULL_CHECK_END);
 
2330
    case OP_NULL_CHECK_END:  MOP_IN(OP_NULL_CHECK_END);
2392
2331
      {
2393
2332
        int isnull;
2394
2333
 
2418
2357
          }
2419
2358
        }
2420
2359
      }
2421
 
      STAT_OP_OUT;
 
2360
      MOP_OUT;
2422
2361
      continue;
2423
2362
      break;
2424
2363
 
2425
2364
#ifdef USE_INFINITE_REPEAT_MONOMANIAC_MEM_STATUS_CHECK
2426
 
    case OP_NULL_CHECK_END_MEMST:  STAT_OP_IN(OP_NULL_CHECK_END_MEMST);
 
2365
    case OP_NULL_CHECK_END_MEMST:  MOP_IN(OP_NULL_CHECK_END_MEMST);
2427
2366
      {
2428
2367
        int isnull;
2429
2368
 
2438
2377
          goto  null_check_found;
2439
2378
        }
2440
2379
      }
2441
 
      STAT_OP_OUT;
 
2380
      MOP_OUT;
2442
2381
      continue;
2443
2382
      break;
2444
2383
#endif
2445
2384
 
2446
2385
#ifdef USE_SUBEXP_CALL
2447
2386
    case OP_NULL_CHECK_END_MEMST_PUSH:
2448
 
      STAT_OP_IN(OP_NULL_CHECK_END_MEMST_PUSH);
 
2387
      MOP_IN(OP_NULL_CHECK_END_MEMST_PUSH);
2449
2388
      {
2450
2389
        int isnull;
2451
2390
 
2467
2406
          STACK_PUSH_NULL_CHECK_END(mem);
2468
2407
        }
2469
2408
      }
2470
 
      STAT_OP_OUT;
 
2409
      MOP_OUT;
2471
2410
      continue;
2472
2411
      break;
2473
2412
#endif
2474
2413
 
2475
 
    case OP_JUMP:  STAT_OP_IN(OP_JUMP);
 
2414
    case OP_JUMP:  MOP_IN(OP_JUMP);
2476
2415
      GET_RELADDR_INC(addr, p);
2477
2416
      p += addr;
2478
 
      STAT_OP_OUT;
 
2417
      MOP_OUT;
2479
2418
      CHECK_INTERRUPT_IN_MATCH_AT;
2480
2419
      continue;
2481
2420
      break;
2482
2421
 
2483
 
    case OP_PUSH:  STAT_OP_IN(OP_PUSH);
 
2422
    case OP_PUSH:  MOP_IN(OP_PUSH);
2484
2423
      GET_RELADDR_INC(addr, p);
2485
2424
      STACK_PUSH_ALT(p + addr, s, sprev);
2486
 
      STAT_OP_OUT;
 
2425
      MOP_OUT;
2487
2426
      continue;
2488
2427
      break;
2489
2428
 
2490
2429
#ifdef USE_COMBINATION_EXPLOSION_CHECK
2491
 
    case OP_STATE_CHECK_PUSH:  STAT_OP_IN(OP_STATE_CHECK_PUSH);
 
2430
    case OP_STATE_CHECK_PUSH:  MOP_IN(OP_STATE_CHECK_PUSH);
2492
2431
      GET_STATE_CHECK_NUM_INC(mem, p);
2493
2432
      STATE_CHECK_VAL(scv, mem);
2494
2433
      if (scv) goto fail;
2495
2434
 
2496
2435
      GET_RELADDR_INC(addr, p);
2497
2436
      STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem);
2498
 
      STAT_OP_OUT;
 
2437
      MOP_OUT;
2499
2438
      continue;
2500
2439
      break;
2501
2440
 
2502
 
    case OP_STATE_CHECK_PUSH_OR_JUMP:  STAT_OP_IN(OP_STATE_CHECK_PUSH_OR_JUMP);
 
2441
    case OP_STATE_CHECK_PUSH_OR_JUMP:  MOP_IN(OP_STATE_CHECK_PUSH_OR_JUMP);
2503
2442
      GET_STATE_CHECK_NUM_INC(mem, p);
2504
2443
      GET_RELADDR_INC(addr, p);
2505
2444
      STATE_CHECK_VAL(scv, mem);
2509
2448
      else {
2510
2449
        STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem);
2511
2450
      }
2512
 
      STAT_OP_OUT;
 
2451
      MOP_OUT;
2513
2452
      continue;
2514
2453
      break;
2515
2454
 
2516
 
    case OP_STATE_CHECK:  STAT_OP_IN(OP_STATE_CHECK);
 
2455
    case OP_STATE_CHECK:  MOP_IN(OP_STATE_CHECK);
2517
2456
      GET_STATE_CHECK_NUM_INC(mem, p);
2518
2457
      STATE_CHECK_VAL(scv, mem);
2519
2458
      if (scv) goto fail;
2520
2459
 
2521
2460
      STACK_PUSH_STATE_CHECK(s, mem);
2522
 
      STAT_OP_OUT;
 
2461
      MOP_OUT;
2523
2462
      continue;
2524
2463
      break;
2525
2464
#endif /* USE_COMBINATION_EXPLOSION_CHECK */
2526
2465
 
2527
 
    case OP_POP:  STAT_OP_IN(OP_POP);
 
2466
    case OP_POP:  MOP_IN(OP_POP);
2528
2467
      STACK_POP_ONE;
2529
 
      STAT_OP_OUT;
 
2468
      MOP_OUT;
2530
2469
      continue;
2531
2470
      break;
2532
2471
 
2533
 
    case OP_PUSH_OR_JUMP_EXACT1:  STAT_OP_IN(OP_PUSH_OR_JUMP_EXACT1);
 
2472
    case OP_PUSH_OR_JUMP_EXACT1:  MOP_IN(OP_PUSH_OR_JUMP_EXACT1);
2534
2473
      GET_RELADDR_INC(addr, p);
2535
2474
      if (*p == *s && DATA_ENSURE_CHECK1) {
2536
2475
        p++;
2537
2476
        STACK_PUSH_ALT(p + addr, s, sprev);
2538
 
        STAT_OP_OUT;
 
2477
        MOP_OUT;
2539
2478
        continue;
2540
2479
      }
2541
2480
      p += (addr + 1);
2542
 
      STAT_OP_OUT;
 
2481
      MOP_OUT;
2543
2482
      continue;
2544
2483
      break;
2545
2484
 
2546
 
    case OP_PUSH_IF_PEEK_NEXT:  STAT_OP_IN(OP_PUSH_IF_PEEK_NEXT);
 
2485
    case OP_PUSH_IF_PEEK_NEXT:  MOP_IN(OP_PUSH_IF_PEEK_NEXT);
2547
2486
      GET_RELADDR_INC(addr, p);
2548
2487
      if (*p == *s) {
2549
2488
        p++;
2550
2489
        STACK_PUSH_ALT(p + addr, s, sprev);
2551
 
        STAT_OP_OUT;
 
2490
        MOP_OUT;
2552
2491
        continue;
2553
2492
      }
2554
2493
      p++;
2555
 
      STAT_OP_OUT;
 
2494
      MOP_OUT;
2556
2495
      continue;
2557
2496
      break;
2558
2497
 
2559
 
    case OP_REPEAT:  STAT_OP_IN(OP_REPEAT);
 
2498
    case OP_REPEAT:  MOP_IN(OP_REPEAT);
2560
2499
      {
2561
2500
        GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
2562
2501
        GET_RELADDR_INC(addr, p);
2569
2508
          STACK_PUSH_ALT(p + addr, s, sprev);
2570
2509
        }
2571
2510
      }
2572
 
      STAT_OP_OUT;
 
2511
      MOP_OUT;
2573
2512
      continue;
2574
2513
      break;
2575
2514
 
2576
 
    case OP_REPEAT_NG:  STAT_OP_IN(OP_REPEAT_NG);
 
2515
    case OP_REPEAT_NG:  MOP_IN(OP_REPEAT_NG);
2577
2516
      {
2578
2517
        GET_MEMNUM_INC(mem, p);    /* mem: OP_REPEAT ID */
2579
2518
        GET_RELADDR_INC(addr, p);
2587
2526
          p += addr;
2588
2527
        }
2589
2528
      }
2590
 
      STAT_OP_OUT;
 
2529
      MOP_OUT;
2591
2530
      continue;
2592
2531
      break;
2593
2532
 
2594
 
    case OP_REPEAT_INC:  STAT_OP_IN(OP_REPEAT_INC);
 
2533
    case OP_REPEAT_INC:  MOP_IN(OP_REPEAT_INC);
2595
2534
      GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */
2596
2535
      si = repeat_stk[mem];
2597
2536
      stkp = STACK_AT(si);
2609
2548
        p = stkp->u.repeat.pcode;
2610
2549
      }
2611
2550
      STACK_PUSH_REPEAT_INC(si);
2612
 
      STAT_OP_OUT;
 
2551
      MOP_OUT;
2613
2552
      CHECK_INTERRUPT_IN_MATCH_AT;
2614
2553
      continue;
2615
2554
      break;
2616
2555
 
2617
 
    case OP_REPEAT_INC_SG:  STAT_OP_IN(OP_REPEAT_INC_SG);
 
2556
    case OP_REPEAT_INC_SG:  MOP_IN(OP_REPEAT_INC_SG);
2618
2557
      GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */
2619
2558
      STACK_GET_REPEAT(mem, stkp);
2620
2559
      si = GET_STACK_INDEX(stkp);
2621
2560
      goto repeat_inc;
2622
2561
      break;
2623
2562
 
2624
 
    case OP_REPEAT_INC_NG:  STAT_OP_IN(OP_REPEAT_INC_NG);
 
2563
    case OP_REPEAT_INC_NG:  MOP_IN(OP_REPEAT_INC_NG);
2625
2564
      GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */
2626
2565
      si = repeat_stk[mem];
2627
2566
      stkp = STACK_AT(si);
2643
2582
      else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) {
2644
2583
        STACK_PUSH_REPEAT_INC(si);
2645
2584
      }
2646
 
      STAT_OP_OUT;
 
2585
      MOP_OUT;
2647
2586
      CHECK_INTERRUPT_IN_MATCH_AT;
2648
2587
      continue;
2649
2588
      break;
2650
2589
 
2651
 
    case OP_REPEAT_INC_NG_SG:  STAT_OP_IN(OP_REPEAT_INC_NG_SG);
 
2590
    case OP_REPEAT_INC_NG_SG:  MOP_IN(OP_REPEAT_INC_NG_SG);
2652
2591
      GET_MEMNUM_INC(mem, p); /* mem: OP_REPEAT ID */
2653
2592
      STACK_GET_REPEAT(mem, stkp);
2654
2593
      si = GET_STACK_INDEX(stkp);
2655
2594
      goto repeat_inc_ng;
2656
2595
      break;
2657
2596
 
2658
 
    case OP_PUSH_POS:  STAT_OP_IN(OP_PUSH_POS);
 
2597
    case OP_PUSH_POS:  MOP_IN(OP_PUSH_POS);
2659
2598
      STACK_PUSH_POS(s, sprev);
2660
 
      STAT_OP_OUT;
 
2599
      MOP_OUT;
2661
2600
      continue;
2662
2601
      break;
2663
2602
 
2664
 
    case OP_POP_POS:  STAT_OP_IN(OP_POP_POS);
 
2603
    case OP_POP_POS:  MOP_IN(OP_POP_POS);
2665
2604
      {
2666
2605
        STACK_POS_END(stkp);
2667
2606
        s     = stkp->u.state.pstr;
2668
2607
        sprev = stkp->u.state.pstr_prev;
2669
2608
      }
2670
 
      STAT_OP_OUT;
 
2609
      MOP_OUT;
2671
2610
      continue;
2672
2611
      break;
2673
2612
 
2674
 
    case OP_PUSH_POS_NOT:  STAT_OP_IN(OP_PUSH_POS_NOT);
 
2613
    case OP_PUSH_POS_NOT:  MOP_IN(OP_PUSH_POS_NOT);
2675
2614
      GET_RELADDR_INC(addr, p);
2676
2615
      STACK_PUSH_POS_NOT(p + addr, s, sprev);
2677
 
      STAT_OP_OUT;
 
2616
      MOP_OUT;
2678
2617
      continue;
2679
2618
      break;
2680
2619
 
2681
 
    case OP_FAIL_POS:  STAT_OP_IN(OP_FAIL_POS);
 
2620
    case OP_FAIL_POS:  MOP_IN(OP_FAIL_POS);
2682
2621
      STACK_POP_TIL_POS_NOT;
2683
2622
      goto fail;
2684
2623
      break;
2685
2624
 
2686
 
    case OP_PUSH_STOP_BT:  STAT_OP_IN(OP_PUSH_STOP_BT);
 
2625
    case OP_PUSH_STOP_BT:  MOP_IN(OP_PUSH_STOP_BT);
2687
2626
      STACK_PUSH_STOP_BT;
2688
 
      STAT_OP_OUT;
 
2627
      MOP_OUT;
2689
2628
      continue;
2690
2629
      break;
2691
2630
 
2692
 
    case OP_POP_STOP_BT:  STAT_OP_IN(OP_POP_STOP_BT);
 
2631
    case OP_POP_STOP_BT:  MOP_IN(OP_POP_STOP_BT);
2693
2632
      STACK_STOP_BT_END;
2694
 
      STAT_OP_OUT;
 
2633
      MOP_OUT;
2695
2634
      continue;
2696
2635
      break;
2697
2636
 
2698
 
    case OP_LOOK_BEHIND:  STAT_OP_IN(OP_LOOK_BEHIND);
 
2637
    case OP_LOOK_BEHIND:  MOP_IN(OP_LOOK_BEHIND);
2699
2638
      GET_LENGTH_INC(tlen, p);
2700
2639
      s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);
2701
2640
      if (IS_NULL(s)) goto fail;
2702
2641
      sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
2703
 
      STAT_OP_OUT;
 
2642
      MOP_OUT;
2704
2643
      continue;
2705
2644
      break;
2706
2645
 
2707
 
    case OP_PUSH_LOOK_BEHIND_NOT:  STAT_OP_IN(OP_PUSH_LOOK_BEHIND_NOT);
 
2646
    case OP_PUSH_LOOK_BEHIND_NOT:  MOP_IN(OP_PUSH_LOOK_BEHIND_NOT);
2708
2647
      GET_RELADDR_INC(addr, p);
2709
2648
      GET_LENGTH_INC(tlen, p);
2710
2649
      q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);
2719
2658
        s = q;
2720
2659
        sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
2721
2660
      }
2722
 
      STAT_OP_OUT;
 
2661
      MOP_OUT;
2723
2662
      continue;
2724
2663
      break;
2725
2664
 
2726
 
    case OP_FAIL_LOOK_BEHIND_NOT:  STAT_OP_IN(OP_FAIL_LOOK_BEHIND_NOT);
 
2665
    case OP_FAIL_LOOK_BEHIND_NOT:  MOP_IN(OP_FAIL_LOOK_BEHIND_NOT);
2727
2666
      STACK_POP_TIL_LOOK_BEHIND_NOT;
2728
2667
      goto fail;
2729
2668
      break;
2730
2669
 
2731
2670
#ifdef USE_SUBEXP_CALL
2732
 
    case OP_CALL:  STAT_OP_IN(OP_CALL);
 
2671
    case OP_CALL:  MOP_IN(OP_CALL);
2733
2672
      GET_ABSADDR_INC(addr, p);
2734
2673
      STACK_PUSH_CALL_FRAME(p);
2735
2674
      p = reg->p + addr;
2736
 
      STAT_OP_OUT;
 
2675
      MOP_OUT;
2737
2676
      continue;
2738
2677
      break;
2739
2678
 
2740
 
    case OP_RETURN:  STAT_OP_IN(OP_RETURN);
 
2679
    case OP_RETURN:  MOP_IN(OP_RETURN);
2741
2680
      STACK_RETURN(p);
2742
2681
      STACK_PUSH_RETURN;
2743
 
      STAT_OP_OUT;
 
2682
      MOP_OUT;
2744
2683
      continue;
2745
2684
      break;
2746
2685
#endif
2750
2689
      break;
2751
2690
 
2752
2691
    fail:
2753
 
      STAT_OP_OUT;
 
2692
      MOP_OUT;
2754
2693
      /* fall */
2755
 
    case OP_FAIL:  STAT_OP_IN(OP_FAIL);
 
2694
    case OP_FAIL:  MOP_IN(OP_FAIL);
2756
2695
      STACK_POP;
2757
2696
      p     = stk->u.state.pcode;
2758
2697
      s     = stk->u.state.pstr;
2765
2704
      }
2766
2705
#endif
2767
2706
 
2768
 
      STAT_OP_OUT;
 
2707
      MOP_OUT;
2769
2708
      continue;
2770
2709
      break;
2771
2710
 
3238
3177
 
3239
3178
      case ANCHOR_END_LINE:
3240
3179
        if (ON_STR_END(p)) {
 
3180
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3241
3181
          prev = (UChar* )onigenc_get_prev_char_head(reg->enc,
3242
3182
                                            (pprev ? pprev : str), p);
3243
3183
          if (prev && ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))
3244
3184
            goto retry_gate;
 
3185
#endif
3245
3186
        }
3246
3187
        else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
3247
3188
#ifdef USE_CRNL_AS_LINE_TERMINATOR
3360
3301
 
3361
3302
      case ANCHOR_END_LINE:
3362
3303
        if (ON_STR_END(p)) {
 
3304
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3363
3305
          prev = onigenc_get_prev_char_head(reg->enc, adjrange, p);
3364
3306
          if (IS_NULL(prev)) goto fail;
3365
3307
          if (ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {
3366
3308
            p = prev;
3367
3309
            goto retry;
3368
3310
          }
 
3311
#endif
3369
3312
        }
3370
3313
        else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)
3371
3314
#ifdef USE_CRNL_AS_LINE_TERMINATOR
3570
3513
      max_semi_end = (UChar* )end;
3571
3514
      if (ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) {
3572
3515
        min_semi_end = pre_end;
 
3516
 
 
3517
#ifdef USE_CRNL_AS_LINE_TERMINATOR
 
3518
        pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, 1);
 
3519
        if (IS_NOT_NULL(pre_end) &&
 
3520
            ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) {
 
3521
          min_semi_end = pre_end;
 
3522
        }
 
3523
#endif
3573
3524
        if (min_semi_end > str && start <= min_semi_end) {
3574
3525
          goto end_buf;
3575
3526
        }