home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / patches / 7.3 / 7.3.1137 < prev    next >
Encoding:
Internet Message Format  |  2013-06-06  |  26.3 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1137
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. Mime-Version: 1.0
  6. Content-Type: text/plain; charset=UTF-8
  7. Content-Transfer-Encoding: 8bit
  8. ------------
  9.  
  10. Patch 7.3.1137
  11. Problem:    New regexp engine: collections are slow.
  12. Solution:   Handle all characters in one go.
  13. Files:        src/regexp_nfa.c
  14.  
  15.  
  16. *** ../vim-7.3.1136/src/regexp_nfa.c    2013-06-06 18:46:00.000000000 +0200
  17. --- src/regexp_nfa.c    2013-06-07 13:40:58.000000000 +0200
  18. ***************
  19. *** 34,48 ****
  20.       NFA_SPLIT = -1024,
  21.       NFA_MATCH,
  22.       NFA_SKIP_CHAR,            /* matches a 0-length char */
  23. -     NFA_END_NEG_RANGE,            /* Used when expanding [^ab] */
  24.   
  25. !     NFA_CONCAT,
  26.       NFA_OR,
  27.       NFA_STAR,                /* greedy * */
  28.       NFA_STAR_NONGREEDY,            /* non-greedy * */
  29.       NFA_QUEST,                /* greedy \? */
  30.       NFA_QUEST_NONGREEDY,        /* non-greedy \? */
  31. -     NFA_NOT,                /* used for [^ab] negated char ranges */
  32.   
  33.       NFA_BOL,                /* ^    Begin line */
  34.       NFA_EOL,                /* $    End line */
  35. --- 34,56 ----
  36.       NFA_SPLIT = -1024,
  37.       NFA_MATCH,
  38.       NFA_SKIP_CHAR,            /* matches a 0-length char */
  39.   
  40. !     NFA_START_COLL,            /* [abc] start */
  41. !     NFA_END_COLL,            /* [abc] end */
  42. !     NFA_START_NEG_COLL,            /* [^abc] start */
  43. !     NFA_END_NEG_COLL,            /* [^abc] end (only used in postfix) */
  44. !     NFA_RANGE,                /* range of the two previous items (only
  45. !                      * used in postfix) */
  46. !     NFA_RANGE_MIN,            /* low end of a range  */
  47. !     NFA_RANGE_MAX,            /* high end of a range  */
  48. ! 
  49. !     NFA_CONCAT,                /* concatenate two previous items (only
  50. !                      * used in postfix) */
  51.       NFA_OR,
  52.       NFA_STAR,                /* greedy * */
  53.       NFA_STAR_NONGREEDY,            /* non-greedy * */
  54.       NFA_QUEST,                /* greedy \? */
  55.       NFA_QUEST_NONGREEDY,        /* non-greedy \? */
  56.   
  57.       NFA_BOL,                /* ^    Begin line */
  58.       NFA_EOL,                /* $    End line */
  59. ***************
  60. *** 260,266 ****
  61.   static int nfa_get_reganch __ARGS((nfa_state_T *start, int depth));
  62.   static int nfa_get_regstart __ARGS((nfa_state_T *start, int depth));
  63.   static int nfa_recognize_char_class __ARGS((char_u *start, char_u *end, int extra_newl));
  64. ! static int nfa_emit_equi_class __ARGS((int c, int neg));
  65.   static int nfa_regatom __ARGS((void));
  66.   static int nfa_regpiece __ARGS((void));
  67.   static int nfa_regconcat __ARGS((void));
  68. --- 268,274 ----
  69.   static int nfa_get_reganch __ARGS((nfa_state_T *start, int depth));
  70.   static int nfa_get_regstart __ARGS((nfa_state_T *start, int depth));
  71.   static int nfa_recognize_char_class __ARGS((char_u *start, char_u *end, int extra_newl));
  72. ! static int nfa_emit_equi_class __ARGS((int c));
  73.   static int nfa_regatom __ARGS((void));
  74.   static int nfa_regpiece __ARGS((void));
  75.   static int nfa_regconcat __ARGS((void));
  76. ***************
  77. *** 664,684 ****
  78.    * NOTE! When changing this function, also update reg_equi_class()
  79.    */
  80.       static int
  81. ! nfa_emit_equi_class(c, neg)
  82.       int        c;
  83. -     int        neg;
  84.   {
  85. !     int    first = TRUE;
  86. !     int    glue = neg == TRUE ? NFA_CONCAT : NFA_OR;
  87. ! #define EMIT2(c)        \
  88. !     EMIT(c);        \
  89. !     if (neg == TRUE) {    \
  90. !         EMIT(NFA_NOT);    \
  91. !     }            \
  92. !     if (first == FALSE)    \
  93. !         EMIT(glue);        \
  94. !     else            \
  95. !         first = FALSE;    \
  96.   
  97.   #ifdef FEAT_MBYTE
  98.       if (enc_utf8 || STRCMP(p_enc, "latin1") == 0
  99. --- 672,681 ----
  100.    * NOTE! When changing this function, also update reg_equi_class()
  101.    */
  102.       static int
  103. ! nfa_emit_equi_class(c)
  104.       int        c;
  105.   {
  106. ! #define EMIT2(c)   EMIT(c); EMIT(NFA_CONCAT);
  107.   
  108.   #ifdef FEAT_MBYTE
  109.       if (enc_utf8 || STRCMP(p_enc, "latin1") == 0
  110. ***************
  111. *** 687,770 ****
  112.       {
  113.       switch (c)
  114.       {
  115. !         case 'A': case '\300': case '\301': case '\302':
  116. !         case '\303': case '\304': case '\305':
  117. !             EMIT2('A');        EMIT2('\300');  EMIT2('\301');
  118. !             EMIT2('\302');  EMIT2('\303');  EMIT2('\304');
  119. !             EMIT2('\305');
  120.               return OK;
  121.   
  122. !         case 'C': case '\307':
  123. !             EMIT2('C');        EMIT2('\307');
  124.               return OK;
  125.   
  126. !         case 'E': case '\310': case '\311': case '\312': case '\313':
  127. !             EMIT2('E');        EMIT2('\310');  EMIT2('\311');
  128. !             EMIT2('\312');  EMIT2('\313');
  129.               return OK;
  130.   
  131. !         case 'I': case '\314': case '\315': case '\316': case '\317':
  132. !             EMIT2('I');        EMIT2('\314');  EMIT2('\315');
  133. !             EMIT2('\316');  EMIT2('\317');
  134.               return OK;
  135.   
  136. !         case 'N': case '\321':
  137. !             EMIT2('N');        EMIT2('\321');
  138.               return OK;
  139.   
  140. !         case 'O': case '\322': case '\323': case '\324': case '\325':
  141. !         case '\326':
  142. !             EMIT2('O');        EMIT2('\322');  EMIT2('\323');
  143. !             EMIT2('\324');  EMIT2('\325');  EMIT2('\326');
  144.               return OK;
  145.   
  146. !         case 'U': case '\331': case '\332': case '\333': case '\334':
  147. !             EMIT2('U');        EMIT2('\331');  EMIT2('\332');
  148. !             EMIT2('\333');  EMIT2('\334');
  149.               return OK;
  150.   
  151. !         case 'Y': case '\335':
  152. !             EMIT2('Y');        EMIT2('\335');
  153.               return OK;
  154.   
  155. !         case 'a': case '\340': case '\341': case '\342':
  156. !         case '\343': case '\344': case '\345':
  157. !             EMIT2('a');        EMIT2('\340');  EMIT2('\341');
  158. !             EMIT2('\342');  EMIT2('\343');  EMIT2('\344');
  159. !             EMIT2('\345');
  160.               return OK;
  161.   
  162. !         case 'c': case '\347':
  163. !             EMIT2('c');        EMIT2('\347');
  164.               return OK;
  165.   
  166. !         case 'e': case '\350': case '\351': case '\352': case '\353':
  167. !             EMIT2('e');        EMIT2('\350');  EMIT2('\351');
  168. !             EMIT2('\352');  EMIT2('\353');
  169.               return OK;
  170.   
  171. !         case 'i': case '\354': case '\355': case '\356': case '\357':
  172. !             EMIT2('i');        EMIT2('\354');  EMIT2('\355');
  173. !             EMIT2('\356');  EMIT2('\357');
  174.               return OK;
  175.   
  176. !         case 'n': case '\361':
  177. !             EMIT2('n');        EMIT2('\361');
  178.               return OK;
  179.   
  180. !         case 'o': case '\362': case '\363': case '\364': case '\365':
  181. !         case '\366':
  182. !             EMIT2('o');        EMIT2('\362');  EMIT2('\363');
  183. !             EMIT2('\364');  EMIT2('\365');  EMIT2('\366');
  184.               return OK;
  185.   
  186. !         case 'u': case '\371': case '\372': case '\373': case '\374':
  187. !             EMIT2('u');        EMIT2('\371');  EMIT2('\372');
  188. !             EMIT2('\373');  EMIT2('\374');
  189.               return OK;
  190.   
  191. !         case 'y': case '\375': case '\377':
  192. !             EMIT2('y');        EMIT2('\375');  EMIT2('\377');
  193.               return OK;
  194.   
  195.           default:
  196. --- 684,767 ----
  197.       {
  198.       switch (c)
  199.       {
  200. !         case 'A': case 0300: case 0301: case 0302:
  201. !         case 0303: case 0304: case 0305:
  202. !             EMIT2('A');        EMIT2(0300);  EMIT2(0301);
  203. !             EMIT2(0302);  EMIT2(0303);  EMIT2(0304);
  204. !             EMIT2(0305);
  205.               return OK;
  206.   
  207. !         case 'C': case 0307:
  208. !             EMIT2('C');        EMIT2(0307);
  209.               return OK;
  210.   
  211. !         case 'E': case 0310: case 0311: case 0312: case 0313:
  212. !             EMIT2('E');        EMIT2(0310);  EMIT2(0311);
  213. !             EMIT2(0312);  EMIT2(0313);
  214.               return OK;
  215.   
  216. !         case 'I': case 0314: case 0315: case 0316: case 0317:
  217. !             EMIT2('I');        EMIT2(0314);  EMIT2(0315);
  218. !             EMIT2(0316);  EMIT2(0317);
  219.               return OK;
  220.   
  221. !         case 'N': case 0321:
  222. !             EMIT2('N');        EMIT2(0321);
  223.               return OK;
  224.   
  225. !         case 'O': case 0322: case 0323: case 0324: case 0325:
  226. !         case 0326:
  227. !             EMIT2('O');        EMIT2(0322);  EMIT2(0323);
  228. !             EMIT2(0324);  EMIT2(0325);  EMIT2(0326);
  229.               return OK;
  230.   
  231. !         case 'U': case 0331: case 0332: case 0333: case 0334:
  232. !             EMIT2('U');        EMIT2(0331);  EMIT2(0332);
  233. !             EMIT2(0333);  EMIT2(0334);
  234.               return OK;
  235.   
  236. !         case 'Y': case 0335:
  237. !             EMIT2('Y');        EMIT2(0335);
  238.               return OK;
  239.   
  240. !         case 'a': case 0340: case 0341: case 0342:
  241. !         case 0343: case 0344: case 0345:
  242. !             EMIT2('a');        EMIT2(0340);  EMIT2(0341);
  243. !             EMIT2(0342);  EMIT2(0343);  EMIT2(0344);
  244. !             EMIT2(0345);
  245.               return OK;
  246.   
  247. !         case 'c': case 0347:
  248. !             EMIT2('c');        EMIT2(0347);
  249.               return OK;
  250.   
  251. !         case 'e': case 0350: case 0351: case 0352: case 0353:
  252. !             EMIT2('e');        EMIT2(0350);  EMIT2(0351);
  253. !             EMIT2(0352);  EMIT2(0353);
  254.               return OK;
  255.   
  256. !         case 'i': case 0354: case 0355: case 0356: case 0357:
  257. !             EMIT2('i');        EMIT2(0354);  EMIT2(0355);
  258. !             EMIT2(0356);  EMIT2(0357);
  259.               return OK;
  260.   
  261. !         case 'n': case 0361:
  262. !             EMIT2('n');        EMIT2(0361);
  263.               return OK;
  264.   
  265. !         case 'o': case 0362: case 0363: case 0364: case 0365:
  266. !         case 0366:
  267. !             EMIT2('o');        EMIT2(0362);  EMIT2(0363);
  268. !             EMIT2(0364);  EMIT2(0365);  EMIT2(0366);
  269.               return OK;
  270.   
  271. !         case 'u': case 0371: case 0372: case 0373: case 0374:
  272. !             EMIT2('u');        EMIT2(0371);  EMIT2(0372);
  273. !             EMIT2(0373);  EMIT2(0374);
  274.               return OK;
  275.   
  276. !         case 'y': case 0375: case 0377:
  277. !             EMIT2('y');        EMIT2(0375);  EMIT2(0377);
  278.               return OK;
  279.   
  280.           default:
  281. ***************
  282. *** 811,824 ****
  283.       char_u    *old_regparse = regparse;
  284.   #endif
  285.       int        extra = 0;
  286. -     int        first;
  287.       int        emit_range;
  288.       int        negated;
  289.       int        result;
  290.       int        startc = -1;
  291.       int        endc = -1;
  292.       int        oldstartc = -1;
  293. -     int        glue;        /* ID that will "glue" nodes together */
  294.   
  295.       c = getchr();
  296.       switch (c)
  297. --- 808,819 ----
  298. ***************
  299. *** 927,934 ****
  300.   
  301.       case Magic('n'):
  302.           if (reg_string)
  303. !         /* In a string "\n" matches a newline character. */
  304. !         EMIT(NL);
  305.           else
  306.           {
  307.           /* In buffer text "\n" matches the end of a line. */
  308. --- 922,929 ----
  309.   
  310.       case Magic('n'):
  311.           if (reg_string)
  312. !         /* In a string "\n" matches a newline character. */
  313. !         EMIT(NL);
  314.           else
  315.           {
  316.           /* In buffer text "\n" matches the end of a line. */
  317. ***************
  318. *** 1160,1191 ****
  319.       case Magic('['):
  320.   collection:
  321.           /*
  322. !          * Glue is emitted between several atoms from the [].
  323. !          * It is either NFA_OR, or NFA_CONCAT.
  324. !          *
  325. !          * [abc] expands to 'a b NFA_OR c NFA_OR' (in postfix notation)
  326. !          * [^abc] expands to 'a NFA_NOT b NFA_NOT NFA_CONCAT c NFA_NOT
  327. !          *        NFA_CONCAT NFA_END_NEG_RANGE NFA_CONCAT' (in postfix
  328. !          *        notation)
  329. !          *
  330.            */
  331.   
  332. - 
  333. - /* Emit negation atoms, if needed.
  334. -  * The CONCAT below merges the NOT with the previous node. */
  335. - #define TRY_NEG()            \
  336. -         if (negated == TRUE)    \
  337. -         {                \
  338. -         EMIT(NFA_NOT);        \
  339. -         }
  340. - 
  341. - /* Emit glue between important nodes : CONCAT or OR. */
  342. - #define EMIT_GLUE()            \
  343. -         if (first == FALSE)        \
  344. -         EMIT(glue);        \
  345. -         else            \
  346. -         first = FALSE;
  347. - 
  348.           p = regparse;
  349.           endp = skip_anyof(p);
  350.           if (*endp == ']')
  351. --- 1155,1169 ----
  352.       case Magic('['):
  353.   collection:
  354.           /*
  355. !          * [abc]  uses NFA_START_COLL - NFA_END_COLL
  356. !          * [^abc] uses NFA_START_NEG_COLL - NFA_END_NEG_COLL
  357. !          * Each character is produced as a regular state, using
  358. !          * NFA_CONCAT to bind them together.
  359. !          * Besides normal characters there can be:
  360. !          * - character classes  NFA_CLASS_*
  361. !          * - ranges, two characters followed by NFA_RANGE.
  362.            */
  363.   
  364.           p = regparse;
  365.           endp = skip_anyof(p);
  366.           if (*endp == ']')
  367. ***************
  368. *** 1216,1236 ****
  369.            * version that turns [abc] into 'a' OR 'b' OR 'c'
  370.            */
  371.           startc = endc = oldstartc = -1;
  372. -         first = TRUE;        /* Emitting first atom in this sequence? */
  373.           negated = FALSE;
  374. -         glue = NFA_OR;
  375.           if (*regparse == '^')            /* negated range */
  376.           {
  377.               negated = TRUE;
  378. -             glue = NFA_CONCAT;
  379.               mb_ptr_adv(regparse);
  380.           }
  381.           if (*regparse == '-')
  382.           {
  383.               startc = '-';
  384.               EMIT(startc);
  385. !             TRY_NEG();
  386. !             EMIT_GLUE();
  387.               mb_ptr_adv(regparse);
  388.           }
  389.           /* Emit the OR branches for each character in the [] */
  390. --- 1194,1213 ----
  391.            * version that turns [abc] into 'a' OR 'b' OR 'c'
  392.            */
  393.           startc = endc = oldstartc = -1;
  394.           negated = FALSE;
  395.           if (*regparse == '^')            /* negated range */
  396.           {
  397.               negated = TRUE;
  398.               mb_ptr_adv(regparse);
  399. +             EMIT(NFA_START_NEG_COLL);
  400.           }
  401. +         else
  402. +             EMIT(NFA_START_COLL);
  403.           if (*regparse == '-')
  404.           {
  405.               startc = '-';
  406.               EMIT(startc);
  407. !             EMIT(NFA_CONCAT);
  408.               mb_ptr_adv(regparse);
  409.           }
  410.           /* Emit the OR branches for each character in the [] */
  411. ***************
  412. *** 1306,1325 ****
  413.                       EMIT(NFA_CLASS_ESCAPE);
  414.                       break;
  415.                   }
  416. !                 TRY_NEG();
  417. !                 EMIT_GLUE();
  418.                   continue;
  419.               }
  420.               /* Try equivalence class [=a=] and the like */
  421.               if (equiclass != 0)
  422.               {
  423. !                 result = nfa_emit_equi_class(equiclass, negated);
  424.                   if (result == FAIL)
  425.                   {
  426.                   /* should never happen */
  427.                   EMSG_RET_FAIL(_("E868: Error building NFA with equivalence class!"));
  428.                   }
  429. -                 EMIT_GLUE();
  430.                   continue;
  431.               }
  432.               /* Try collating class like [. .]  */
  433. --- 1283,1300 ----
  434.                       EMIT(NFA_CLASS_ESCAPE);
  435.                       break;
  436.                   }
  437. !                 EMIT(NFA_CONCAT);
  438.                   continue;
  439.               }
  440.               /* Try equivalence class [=a=] and the like */
  441.               if (equiclass != 0)
  442.               {
  443. !                 result = nfa_emit_equi_class(equiclass);
  444.                   if (result == FAIL)
  445.                   {
  446.                   /* should never happen */
  447.                   EMSG_RET_FAIL(_("E868: Error building NFA with equivalence class!"));
  448.                   }
  449.                   continue;
  450.               }
  451.               /* Try collating class like [. .]  */
  452. ***************
  453. *** 1391,1409 ****
  454.               startc = oldstartc;
  455.               if (startc > endc)
  456.                   EMSG_RET_FAIL(_(e_invrange));
  457.   #ifdef FEAT_MBYTE
  458. !             if (has_mbyte && ((*mb_char2len)(startc) > 1
  459.                       || (*mb_char2len)(endc) > 1))
  460.               {
  461. !                 if (endc > startc + 256)
  462. !                 EMSG_RET_FAIL(_(e_invrange));
  463. !                 /* Emit the range. "startc" was already emitted, so
  464. !                  * skip it. */
  465.                   for (c = startc + 1; c <= endc; c++)
  466.                   {
  467.                   EMIT(c);
  468. !                 TRY_NEG();
  469. !                 EMIT_GLUE();
  470.                   }
  471.               }
  472.               else
  473. --- 1366,1397 ----
  474.               startc = oldstartc;
  475.               if (startc > endc)
  476.                   EMSG_RET_FAIL(_(e_invrange));
  477. + 
  478. +             if (endc > startc + 2)
  479. +             {
  480. +                 /* Emit a range instead of the sequence of
  481. +                  * individual characters. */
  482. +                 if (startc == 0)
  483. +                 /* \x00 is translated to \x0a, start at \x01. */
  484. +                 EMIT(1);
  485. +                 else
  486. +                 --post_ptr; /* remove NFA_CONCAT */
  487. +                 EMIT(endc);
  488. +                 EMIT(NFA_RANGE);
  489. +                 EMIT(NFA_CONCAT);
  490. +             }
  491. +             else
  492.   #ifdef FEAT_MBYTE
  493. !                  if (has_mbyte && ((*mb_char2len)(startc) > 1
  494.                       || (*mb_char2len)(endc) > 1))
  495.               {
  496. !                 /* Emit the characters in the range.
  497. !                  * "startc" was already emitted, so skip it.
  498. !                  * */
  499.                   for (c = startc + 1; c <= endc; c++)
  500.                   {
  501.                   EMIT(c);
  502. !                 EMIT(NFA_CONCAT);
  503.                   }
  504.               }
  505.               else
  506. ***************
  507. *** 1425,1432 ****
  508.   #endif
  509.                   {
  510.                       EMIT(c);
  511. !                     TRY_NEG();
  512. !                     EMIT_GLUE();
  513.                   }
  514.               }
  515.               emit_range = FALSE;
  516. --- 1413,1419 ----
  517.   #endif
  518.                   {
  519.                       EMIT(c);
  520. !                     EMIT(NFA_CONCAT);
  521.                   }
  522.               }
  523.               emit_range = FALSE;
  524. ***************
  525. *** 1434,1456 ****
  526.               }
  527.               else
  528.               {
  529. !             /*
  530. !              * This char (startc) is not part of a range. Just
  531.                * emit it.
  532. -              *
  533.                * Normally, simply emit startc. But if we get char
  534.                * code=0 from a collating char, then replace it with
  535.                * 0x0a.
  536. -              *
  537.                * This is needed to completely mimic the behaviour of
  538. !              * the backtracking engine.
  539. !              */
  540. !             if (got_coll_char == TRUE && startc == 0)
  541. !                 EMIT(0x0a);
  542.               else
  543. !                 EMIT(startc);
  544. !             TRY_NEG();
  545. !             EMIT_GLUE();
  546.               }
  547.   
  548.               mb_ptr_adv(regparse);
  549. --- 1421,1449 ----
  550.               }
  551.               else
  552.               {
  553. !             /* This char (startc) is not part of a range. Just
  554.                * emit it.
  555.                * Normally, simply emit startc. But if we get char
  556.                * code=0 from a collating char, then replace it with
  557.                * 0x0a.
  558.                * This is needed to completely mimic the behaviour of
  559. !              * the backtracking engine. */
  560. !             if (startc == NFA_NEWL)
  561. !             {
  562. !                 /* Line break can't be matched as part of the
  563. !                  * collection, add an OR below. But not for negated
  564. !                  * range. */
  565. !                 if (!negated)
  566. !                 extra = ADD_NL;
  567. !             }
  568.               else
  569. !             {
  570. !                 if (got_coll_char == TRUE && startc == 0)
  571. !                 EMIT(0x0a);
  572. !                 else
  573. !                 EMIT(startc);
  574. !                 EMIT(NFA_CONCAT);
  575. !             }
  576.               }
  577.   
  578.               mb_ptr_adv(regparse);
  579. ***************
  580. *** 1460,1479 ****
  581.           if (*regparse == '-')        /* if last, '-' is just a char */
  582.           {
  583.               EMIT('-');
  584. !             TRY_NEG();
  585. !             EMIT_GLUE();
  586.           }
  587.           mb_ptr_adv(regparse);
  588.   
  589.           /* skip the trailing ] */
  590.           regparse = endp;
  591.           mb_ptr_adv(regparse);
  592.           if (negated == TRUE)
  593. !         {
  594. !             /* Mark end of negated char range */
  595. !             EMIT(NFA_END_NEG_RANGE);
  596. !             EMIT(NFA_CONCAT);
  597. !         }
  598.   
  599.           /* \_[] also matches \n but it's not negated */
  600.           if (extra == ADD_NL)
  601. --- 1453,1471 ----
  602.           if (*regparse == '-')        /* if last, '-' is just a char */
  603.           {
  604.               EMIT('-');
  605. !             EMIT(NFA_CONCAT);
  606.           }
  607.           mb_ptr_adv(regparse);
  608.   
  609.           /* skip the trailing ] */
  610.           regparse = endp;
  611.           mb_ptr_adv(regparse);
  612. + 
  613. +         /* Mark end of the collection. */
  614.           if (negated == TRUE)
  615. !             EMIT(NFA_END_NEG_COLL);
  616. !         else
  617. !             EMIT(NFA_END_COLL);
  618.   
  619.           /* \_[] also matches \n but it's not negated */
  620.           if (extra == ADD_NL)
  621. ***************
  622. *** 1532,1540 ****
  623.           }
  624.       }
  625.   
  626. - #undef TRY_NEG
  627. - #undef EMIT_GLUE
  628. - 
  629.       return OK;
  630.   }
  631.   
  632. --- 1524,1529 ----
  633. ***************
  634. *** 2091,2100 ****
  635.       case NFA_STAR_NONGREEDY: STRCPY(code, "NFA_STAR_NONGREEDY "); break;
  636.       case NFA_QUEST:        STRCPY(code, "NFA_QUEST"); break;
  637.       case NFA_QUEST_NONGREEDY: STRCPY(code, "NFA_QUEST_NON_GREEDY"); break;
  638. -     case NFA_NOT:        STRCPY(code, "NFA_NOT "); break;
  639.       case NFA_SKIP_CHAR:    STRCPY(code, "NFA_SKIP_CHAR"); break;
  640.       case NFA_OR:        STRCPY(code, "NFA_OR"); break;
  641. !     case NFA_END_NEG_RANGE:    STRCPY(code, "NFA_END_NEG_RANGE"); break;
  642.       case NFA_CLASS_ALNUM:    STRCPY(code, "NFA_CLASS_ALNUM"); break;
  643.       case NFA_CLASS_ALPHA:    STRCPY(code, "NFA_CLASS_ALPHA"); break;
  644.       case NFA_CLASS_BLANK:    STRCPY(code, "NFA_CLASS_BLANK"); break;
  645. --- 2080,2096 ----
  646.       case NFA_STAR_NONGREEDY: STRCPY(code, "NFA_STAR_NONGREEDY "); break;
  647.       case NFA_QUEST:        STRCPY(code, "NFA_QUEST"); break;
  648.       case NFA_QUEST_NONGREEDY: STRCPY(code, "NFA_QUEST_NON_GREEDY"); break;
  649.       case NFA_SKIP_CHAR:    STRCPY(code, "NFA_SKIP_CHAR"); break;
  650.       case NFA_OR:        STRCPY(code, "NFA_OR"); break;
  651. ! 
  652. !     case NFA_START_COLL:    STRCPY(code, "NFA_START_COLL"); break;
  653. !     case NFA_END_COLL:    STRCPY(code, "NFA_END_COLL"); break;
  654. !     case NFA_START_NEG_COLL: STRCPY(code, "NFA_START_NEG_COLL"); break;
  655. !     case NFA_END_NEG_COLL:    STRCPY(code, "NFA_END_NEG_COLL"); break;
  656. !     case NFA_RANGE:        STRCPY(code, "NFA_RANGE"); break;
  657. !     case NFA_RANGE_MIN:    STRCPY(code, "NFA_RANGE_MIN"); break;
  658. !     case NFA_RANGE_MAX:    STRCPY(code, "NFA_RANGE_MAX"); break;
  659. ! 
  660.       case NFA_CLASS_ALNUM:    STRCPY(code, "NFA_CLASS_ALNUM"); break;
  661.       case NFA_CLASS_ALPHA:    STRCPY(code, "NFA_CLASS_ALPHA"); break;
  662.       case NFA_CLASS_BLANK:    STRCPY(code, "NFA_CLASS_BLANK"); break;
  663. ***************
  664. *** 2231,2238 ****
  665.       fprintf(debugf, " %s", p);
  666.   
  667.       nfa_set_code(state->c);
  668. !     fprintf(debugf, "%s%s (%d) (id=%d)\n",
  669. !          state->negated ? "NOT " : "", code, state->c, abs(state->id));
  670.       if (state->id < 0)
  671.       return;
  672.   
  673. --- 2227,2238 ----
  674.       fprintf(debugf, " %s", p);
  675.   
  676.       nfa_set_code(state->c);
  677. !     fprintf(debugf, "%s%s (%d) (id=%d) val=%d\n",
  678. !          state->negated ? "NOT " : "",
  679. !          code,
  680. !          state->c,
  681. !          abs(state->id),
  682. !          state->val);
  683.       if (state->id < 0)
  684.       return;
  685.   
  686. ***************
  687. *** 2325,2330 ****
  688. --- 2325,2331 ----
  689.       s->c    = c;
  690.       s->out  = out;
  691.       s->out1 = out1;
  692. +     s->val  = 0;
  693.   
  694.       s->id   = istate;
  695.       s->lastlist[0] = 0;
  696. ***************
  697. *** 2565,2577 ****
  698.       switch (*p)
  699.       {
  700.       case NFA_CONCAT:
  701. !         /* Catenation.
  702. !          * Pay attention: this operator does not exist
  703. !          * in the r.e. itself (it is implicit, really).
  704. !          * It is added when r.e. is translated to postfix
  705. !          * form in re2post().
  706. !          *
  707. !          * No new state added here. */
  708.           if (nfa_calc_size == TRUE)
  709.           {
  710.           /* nstate += 0; */
  711. --- 2566,2575 ----
  712.       switch (*p)
  713.       {
  714.       case NFA_CONCAT:
  715. !         /* Concatenation.
  716. !          * Pay attention: this operator does not exist in the r.e. itself
  717. !          * (it is implicit, really).  It is added when r.e. is translated
  718. !          * to postfix form in re2post(). */
  719.           if (nfa_calc_size == TRUE)
  720.           {
  721.           /* nstate += 0; */
  722. ***************
  723. *** 2583,2604 ****
  724.           PUSH(frag(e1.start, e2.out));
  725.           break;
  726.   
  727. -     case NFA_NOT:
  728. -         /* Negation of a character */
  729. -         if (nfa_calc_size == TRUE)
  730. -         {
  731. -         /* nstate += 0; */
  732. -         break;
  733. -         }
  734. -         e1 = POP();
  735. -         e1.start->negated = TRUE;
  736. - #ifdef FEAT_MBYTE
  737. -         if (e1.start->c == NFA_COMPOSING)
  738. -         e1.start->out1->negated = TRUE;
  739. - #endif
  740. -         PUSH(e1);
  741. -         break;
  742. - 
  743.       case NFA_OR:
  744.           /* Alternation */
  745.           if (nfa_calc_size == TRUE)
  746. --- 2581,2586 ----
  747. ***************
  748. *** 2672,2677 ****
  749. --- 2654,2696 ----
  750.           PUSH(frag(s, append(e.out, list1(&s->out))));
  751.           break;
  752.   
  753. +     case NFA_END_COLL:
  754. +     case NFA_END_NEG_COLL:
  755. +         /* On the stack is the sequence starting with NFA_START_COLL or
  756. +          * NFA_START_NEG_COLL and all possible characters. Patch it to
  757. +          * add the output to the start. */
  758. +         if (nfa_calc_size == TRUE)
  759. +         {
  760. +         nstate++;
  761. +         break;
  762. +         }
  763. +         e = POP();
  764. +         s = alloc_state(NFA_END_COLL, NULL, NULL);
  765. +         if (s == NULL)
  766. +         goto theend;
  767. +         patch(e.out, s);
  768. +         e.start->out1 = s;
  769. +         PUSH(frag(e.start, list1(&s->out)));
  770. +         break;
  771. + 
  772. +     case NFA_RANGE:
  773. +         /* Before this are two characters, the low and high end of a
  774. +          * range.  Turn them into two states with MIN and MAX. */
  775. +         if (nfa_calc_size == TRUE)
  776. +         {
  777. +         /* nstate += 0; */
  778. +         break;
  779. +         }
  780. +         e2 = POP();
  781. +         e1 = POP();
  782. +         e2.start->val = e2.start->c;
  783. +         e2.start->c = NFA_RANGE_MAX;
  784. +         e1.start->val = e1.start->c;
  785. +         e1.start->c = NFA_RANGE_MIN;
  786. +         patch(e1.out, e2.start);
  787. +         PUSH(frag(e1.start, e2.out));
  788. +         break;
  789. + 
  790.       case NFA_SKIP_CHAR:
  791.           /* Symbol of 0-length, Used in a repetition
  792.            * with max/min count of 0 */
  793. ***************
  794. *** 2990,2995 ****
  795. --- 3009,3016 ----
  796.       matchstate = &state_ptr[istate++]; /* the match state */
  797.       matchstate->c = NFA_MATCH;
  798.       matchstate->out = matchstate->out1 = NULL;
  799. +     matchstate->negated = FALSE;
  800. +     matchstate->id = 0;
  801.   
  802.       patch(e.out, matchstate);
  803.       ret = e.start;
  804. ***************
  805. *** 3308,3314 ****
  806.       switch (state->c)
  807.       {
  808.       case NFA_SPLIT:
  809. -     case NFA_NOT:
  810.       case NFA_NOPEN:
  811.       case NFA_SKIP_CHAR:
  812.       case NFA_NCLOSE:
  813. --- 3329,3334 ----
  814. ***************
  815. *** 3782,3788 ****
  816.   
  817.       default:
  818.           /* should not be here :P */
  819. !         EMSG_RET_FAIL(_("E877: (NFA regexp) Invalid character class "));
  820.       }
  821.       return FAIL;
  822.   }
  823. --- 3802,3809 ----
  824.   
  825.       default:
  826.           /* should not be here :P */
  827. !         EMSGN("E877: (NFA regexp) Invalid character class: %ld", class);
  828. !         return FAIL;
  829.       }
  830.       return FAIL;
  831.   }
  832. ***************
  833. *** 4320,4327 ****
  834.       addstate(thislist, start, m, 0);
  835.   
  836.       /* There are two cases when the NFA advances: 1. input char matches the
  837. !      * NFA node and 2. input char does not match the NFA node, but the next
  838. !      * node is NFA_NOT. The following macro calls addstate() according to
  839.        * these rules. It is used A LOT, so use the "listtbl" table for speed */
  840.       listtbl[0][0] = NULL;
  841.       listtbl[0][1] = neglist;
  842. --- 4341,4348 ----
  843.       addstate(thislist, start, m, 0);
  844.   
  845.       /* There are two cases when the NFA advances: 1. input char matches the
  846. !      * NFA node and 2. input char does not match the NFA node and the state
  847. !      * has the negated flag. The following macro calls addstate() according to
  848.        * these rules. It is used A LOT, so use the "listtbl" table for speed */
  849.       listtbl[0][0] = NULL;
  850.       listtbl[0][1] = neglist;
  851. ***************
  852. *** 4845,4860 ****
  853.           ADD_POS_NEG_STATE(t->state);
  854.           break;
  855.   
  856. !         case NFA_END_NEG_RANGE:
  857. !         /* This follows a series of negated nodes, like:
  858. !          * NOT CHAR(x), NOT CHAR(y), etc. */
  859. !         if (curc > 0)
  860.           {
  861.               ll = nextlist;
  862. !             add_state = t->state->out;
  863.               add_off = clen;
  864.           }
  865.           break;
  866.   
  867.           case NFA_ANY:
  868.           /* Any char except '\0', (end of input) does not match. */
  869. --- 4866,4944 ----
  870.           ADD_POS_NEG_STATE(t->state);
  871.           break;
  872.   
  873. !         case NFA_START_COLL:
  874. !         case NFA_START_NEG_COLL:
  875. !           {
  876. !         /* What follows is a list of characters, until NFA_END_COLL.
  877. !          * One of them must match or none of them must match. */
  878. !         nfa_state_T    *state;
  879. !         int        result_if_matched;
  880. !         int        c1, c2;
  881. ! 
  882. !         /* Never match EOL. If it's part of the collection it is added
  883. !          * as a separate state with an OR. */
  884. !         if (curc == NUL)
  885. !             break;
  886. ! 
  887. !         state = t->state->out;
  888. !         result_if_matched = (t->state->c == NFA_START_COLL);
  889. !         for (;;)
  890.           {
  891. +             if (state->c == NFA_END_COLL)
  892. +             {
  893. +             result = !result_if_matched;
  894. +             break;
  895. +             }
  896. +             if (state->c == NFA_RANGE_MIN)
  897. +             {
  898. +             c1 = state->val;
  899. +             state = state->out; /* advance to NFA_RANGE_MAX */
  900. +             c2 = state->val;
  901. + #ifdef ENABLE_LOG
  902. +             fprintf(log_fd, "NFA_RANGE_MIN curc=%d c1=%d c2=%d\n",
  903. +                 curc, c1, c2);
  904. + #endif
  905. +             if (curc >= c1 && curc <= c2)
  906. +             {
  907. +                 result = result_if_matched;
  908. +                 break;
  909. +             }
  910. +             if (ireg_ic)
  911. +             {
  912. +                 int curc_low = MB_TOLOWER(curc);
  913. +                 int done = FALSE;
  914. + 
  915. +                 for ( ; c1 <= c2; ++c1)
  916. +                 if (MB_TOLOWER(c1) == curc_low)
  917. +                 {
  918. +                     result = result_if_matched;
  919. +                     done = TRUE;
  920. +                     break;
  921. +                 }
  922. +                 if (done)
  923. +                 break;
  924. +             }
  925. +             }
  926. +             else if (state->c < 0 ? check_char_class(state->c, curc)
  927. +                     : (curc == state->c
  928. +                    || (ireg_ic && MB_TOLOWER(curc)
  929. +                             == MB_TOLOWER(state->c))))
  930. +             {
  931. +             result = result_if_matched;
  932. +             break;
  933. +             }
  934. +             state = state->out;
  935. +         }
  936. +         if (result)
  937. +         {
  938. +             /* next state is in out of the NFA_END_COLL, out1 of
  939. +              * START points to the END state */
  940.               ll = nextlist;
  941. !             add_state = t->state->out1->out;
  942.               add_off = clen;
  943.           }
  944.           break;
  945. +           }
  946.   
  947.           case NFA_ANY:
  948.           /* Any char except '\0', (end of input) does not match. */
  949. *** ../vim-7.3.1136/src/version.c    2013-06-06 21:31:02.000000000 +0200
  950. --- src/version.c    2013-06-07 13:21:57.000000000 +0200
  951. ***************
  952. *** 730,731 ****
  953. --- 730,733 ----
  954.   {   /* Add new patch number below this line */
  955. + /**/
  956. +     1137,
  957.   /**/
  958.  
  959. -- 
  960. From "know your smileys":
  961.  :.-(    Crying
  962.  
  963.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  964. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  965. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  966.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  967.