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.1022 < prev    next >
Encoding:
Internet Message Format  |  2013-05-25  |  21.5 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1022
  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.1022
  11. Problem:    Compiler warning for shadowed variable. (John Little)
  12. Solution:   Move declaration, rename variables.
  13. Files:        src/regexp_nfa.c
  14.  
  15.  
  16. *** ../vim-7.3.1021/src/regexp_nfa.c    2013-05-26 14:32:01.000000000 +0200
  17. --- src/regexp_nfa.c    2013-05-26 14:50:27.000000000 +0200
  18. ***************
  19. *** 604,610 ****
  20.       char_u    *endp;
  21.   #ifdef FEAT_MBYTE
  22.       char_u    *old_regparse = regparse;
  23. -     int        i;
  24.   #endif
  25.       int        extra = 0;
  26.       int        first;
  27. --- 604,609 ----
  28. ***************
  29. *** 827,850 ****
  30.           case 'u':   /* %uabcd hex 4 */
  31.           case 'U':   /* %U1234abcd hex 8 */
  32.               {
  33. !             int i;
  34.   
  35.               switch (c)
  36.               {
  37. !                 case 'd': i = getdecchrs(); break;
  38. !                 case 'o': i = getoctchrs(); break;
  39. !                 case 'x': i = gethexchrs(2); break;
  40. !                 case 'u': i = gethexchrs(4); break;
  41. !                 case 'U': i = gethexchrs(8); break;
  42. !                 default:  i = -1; break;
  43.               }
  44.   
  45. !             if (i < 0)
  46.                   EMSG2_RET_FAIL(
  47.                      _("E678: Invalid character after %s%%[dxouU]"),
  48.                       reg_magic == MAGIC_ALL);
  49.               /* TODO: what if a composing character follows? */
  50. !             EMIT(i);
  51.               }
  52.               break;
  53.   
  54. --- 826,849 ----
  55.           case 'u':   /* %uabcd hex 4 */
  56.           case 'U':   /* %U1234abcd hex 8 */
  57.               {
  58. !             int nr;
  59.   
  60.               switch (c)
  61.               {
  62. !                 case 'd': nr = getdecchrs(); break;
  63. !                 case 'o': nr = getoctchrs(); break;
  64. !                 case 'x': nr = gethexchrs(2); break;
  65. !                 case 'u': nr = gethexchrs(4); break;
  66. !                 case 'U': nr = gethexchrs(8); break;
  67. !                 default:  nr = -1; break;
  68.               }
  69.   
  70. !             if (nr < 0)
  71.                   EMSG2_RET_FAIL(
  72.                      _("E678: Invalid character after %s%%[dxouU]"),
  73.                       reg_magic == MAGIC_ALL);
  74.               /* TODO: what if a composing character follows? */
  75. !             EMIT(nr);
  76.               }
  77.               break;
  78.   
  79. ***************
  80. *** 1229,1234 ****
  81. --- 1228,1235 ----
  82.                   != (plen = (*mb_ptr2len)(old_regparse))
  83.                                  || utf_iscomposing(c)))
  84.           {
  85. +             int i = 0;
  86. + 
  87.               /* A base character plus composing characters, or just one
  88.                * or more composing characters.
  89.                * This requires creating a separate atom as if enclosing
  90. ***************
  91. *** 1237,1243 ****
  92.                * building the postfix form, not the NFA itself;
  93.                * a composing char could be: a, b, c, NFA_COMPOSING
  94.                * where 'b' and 'c' are chars with codes > 256. */
  95. -             i = 0;
  96.               for (;;)
  97.               {
  98.               EMIT(c);
  99. --- 1238,1243 ----
  100. ***************
  101. *** 2923,2931 ****
  102.       regsub_T        *submatch;
  103.       regsub_T        *m;
  104.   {
  105. -     int        c;
  106. -     int        n;
  107. -     int        i = 0;
  108.       int        result;
  109.       int        size = 0;
  110.       int        match = FALSE;
  111. --- 2923,2928 ----
  112. ***************
  113. *** 2939,2944 ****
  114. --- 2936,2942 ----
  115.       nfa_list_T    *listtbl[2][2];
  116.       nfa_list_T    *ll;
  117.       int        listid = 1;
  118. +     int        listidx;
  119.       nfa_list_T    *thislist;
  120.       nfa_list_T    *nextlist;
  121.       nfa_list_T    *neglist;
  122. ***************
  123. *** 3004,3010 ****
  124.   #define    ADD_POS_NEG_STATE(node)                            \
  125.       ll = listtbl[result ? 1 : 0][node->negated];                \
  126.       if (ll != NULL)                                \
  127. !     addstate(ll, node->out , &t->sub, n, listid + 1, &match);
  128.   
  129.   
  130.       /*
  131. --- 3002,3008 ----
  132.   #define    ADD_POS_NEG_STATE(node)                            \
  133.       ll = listtbl[result ? 1 : 0][node->negated];                \
  134.       if (ll != NULL)                                \
  135. !     addstate(ll, node->out , &t->sub, clen, listid + 1, &match);
  136.   
  137.   
  138.       /*
  139. ***************
  140. *** 3012,3032 ****
  141.        */
  142.       for (;;)
  143.       {
  144.   #ifdef FEAT_MBYTE
  145.       if (has_mbyte)
  146.       {
  147. !         c = (*mb_ptr2char)(reginput);
  148. !         n = (*mb_ptr2len)(reginput);
  149.       }
  150.       else
  151.   #endif
  152.       {
  153. !         c = *reginput;
  154. !         n = 1;
  155.       }
  156. !     if (c == NUL)
  157.       {
  158. !         n = 0;
  159.           go_to_nextline = FALSE;
  160.       }
  161.   
  162. --- 3010,3033 ----
  163.        */
  164.       for (;;)
  165.       {
  166. +     int    curc;
  167. +     int    clen;
  168. + 
  169.   #ifdef FEAT_MBYTE
  170.       if (has_mbyte)
  171.       {
  172. !         curc = (*mb_ptr2char)(reginput);
  173. !         clen = (*mb_ptr2len)(reginput);
  174.       }
  175.       else
  176.   #endif
  177.       {
  178. !         curc = *reginput;
  179. !         clen = 1;
  180.       }
  181. !     if (curc == NUL)
  182.       {
  183. !         clen = 0;
  184.           go_to_nextline = FALSE;
  185.       }
  186.   
  187. ***************
  188. *** 3040,3049 ****
  189.   #ifdef ENABLE_LOG
  190.       fprintf(log_fd, "------------------------------------------\n");
  191.       fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput);
  192. !     fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", c, (int)c);
  193.       fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n);
  194. !     for (i = 0; i < thislist->n; i++)
  195. !         fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
  196.       fprintf(log_fd, "\n");
  197.   #endif
  198.   
  199. --- 3041,3054 ----
  200.   #ifdef ENABLE_LOG
  201.       fprintf(log_fd, "------------------------------------------\n");
  202.       fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput);
  203. !     fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", curc, (int)curc);
  204.       fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n);
  205. !     {
  206. !         int i;
  207. ! 
  208. !         for (i = 0; i < thislist->n; i++)
  209. !         fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
  210. !     }
  211.       fprintf(log_fd, "\n");
  212.   #endif
  213.   
  214. ***************
  215. *** 3057,3072 ****
  216.           break;
  217.   
  218.       /* compute nextlist */
  219. !     for (i = 0; i < thislist->n || neglist->n > 0; ++i)
  220.       {
  221.           if (neglist->n > 0)
  222.           {
  223.           t = &neglist->t[0];
  224.           neglist->n--;
  225. !         i--;
  226.           }
  227.           else
  228. !         t = &thislist->t[i];
  229.   
  230.   #ifdef NFA_REGEXP_DEBUG_LOG
  231.           nfa_set_code(t->state->c);
  232. --- 3062,3077 ----
  233.           break;
  234.   
  235.       /* compute nextlist */
  236. !     for (listidx = 0; listidx < thislist->n || neglist->n > 0; ++listidx)
  237.       {
  238.           if (neglist->n > 0)
  239.           {
  240.           t = &neglist->t[0];
  241.           neglist->n--;
  242. !         listidx--;
  243.           }
  244.           else
  245. !         t = &thislist->t[listidx];
  246.   
  247.   #ifdef NFA_REGEXP_DEBUG_LOG
  248.           nfa_set_code(t->state->c);
  249. ***************
  250. *** 3116,3122 ****
  251.            * the parent call. */
  252.           if (start->c == NFA_MOPEN + 0)
  253.               addstate_here(thislist, t->state->out, &t->sub, listid,
  254. !                                   &match, &i);
  255.           else
  256.           {
  257.               *m = t->sub;
  258. --- 3121,3127 ----
  259.            * the parent call. */
  260.           if (start->c == NFA_MOPEN + 0)
  261.               addstate_here(thislist, t->state->out, &t->sub, listid,
  262. !                                 &match, &listidx);
  263.           else
  264.           {
  265.               *m = t->sub;
  266. ***************
  267. *** 3190,3196 ****
  268.               }
  269.               /* t->state->out1 is the corresponding END_INVISIBLE node */
  270.               addstate_here(thislist, t->state->out1->out, &t->sub,
  271. !                               listid, &match, &i);
  272.           }
  273.           else
  274.           {
  275. --- 3195,3201 ----
  276.               }
  277.               /* t->state->out1 is the corresponding END_INVISIBLE node */
  278.               addstate_here(thislist, t->state->out1->out, &t->sub,
  279. !                             listid, &match, &listidx);
  280.           }
  281.           else
  282.           {
  283. ***************
  284. *** 3202,3221 ****
  285.           case NFA_BOL:
  286.           if (reginput == regline)
  287.               addstate_here(thislist, t->state->out, &t->sub, listid,
  288. !                                   &match, &i);
  289.           break;
  290.   
  291.           case NFA_EOL:
  292. !         if (c == NUL)
  293.               addstate_here(thislist, t->state->out, &t->sub, listid,
  294. !                                   &match, &i);
  295.           break;
  296.   
  297.           case NFA_BOW:
  298.           {
  299.           int bow = TRUE;
  300.   
  301. !         if (c == NUL)
  302.               bow = FALSE;
  303.   #ifdef FEAT_MBYTE
  304.           else if (has_mbyte)
  305. --- 3207,3226 ----
  306.           case NFA_BOL:
  307.           if (reginput == regline)
  308.               addstate_here(thislist, t->state->out, &t->sub, listid,
  309. !                                 &match, &listidx);
  310.           break;
  311.   
  312.           case NFA_EOL:
  313. !         if (curc == NUL)
  314.               addstate_here(thislist, t->state->out, &t->sub, listid,
  315. !                                 &match, &listidx);
  316.           break;
  317.   
  318.           case NFA_BOW:
  319.           {
  320.           int bow = TRUE;
  321.   
  322. !         if (curc == NUL)
  323.               bow = FALSE;
  324.   #ifdef FEAT_MBYTE
  325.           else if (has_mbyte)
  326. ***************
  327. *** 3230,3242 ****
  328.               bow = FALSE;
  329.           }
  330.   #endif
  331. !         else if (!vim_iswordc_buf(c, reg_buf)
  332.                  || (reginput > regline
  333.                      && vim_iswordc_buf(reginput[-1], reg_buf)))
  334.               bow = FALSE;
  335.           if (bow)
  336.               addstate_here(thislist, t->state->out, &t->sub, listid,
  337. !                                   &match, &i);
  338.           break;
  339.           }
  340.   
  341. --- 3235,3247 ----
  342.               bow = FALSE;
  343.           }
  344.   #endif
  345. !         else if (!vim_iswordc_buf(curc, reg_buf)
  346.                  || (reginput > regline
  347.                      && vim_iswordc_buf(reginput[-1], reg_buf)))
  348.               bow = FALSE;
  349.           if (bow)
  350.               addstate_here(thislist, t->state->out, &t->sub, listid,
  351. !                                 &match, &listidx);
  352.           break;
  353.           }
  354.   
  355. ***************
  356. *** 3260,3277 ****
  357.           }
  358.   #endif
  359.           else if (!vim_iswordc_buf(reginput[-1], reg_buf)
  360. !             || (reginput[0] != NUL && vim_iswordc_buf(c, reg_buf)))
  361.               eow = FALSE;
  362.           if (eow)
  363.               addstate_here(thislist, t->state->out, &t->sub, listid,
  364. !                                   &match, &i);
  365.           break;
  366.           }
  367.   
  368.   #ifdef FEAT_MBYTE
  369.           case NFA_COMPOSING:
  370.           {
  371. !         int        mc = c;
  372.           int        len = 0;
  373.           nfa_state_T *end;
  374.           nfa_state_T *sta;
  375. --- 3265,3283 ----
  376.           }
  377.   #endif
  378.           else if (!vim_iswordc_buf(reginput[-1], reg_buf)
  379. !             || (reginput[0] != NUL
  380. !                        && vim_iswordc_buf(curc, reg_buf)))
  381.               eow = FALSE;
  382.           if (eow)
  383.               addstate_here(thislist, t->state->out, &t->sub, listid,
  384. !                                 &match, &listidx);
  385.           break;
  386.           }
  387.   
  388.   #ifdef FEAT_MBYTE
  389.           case NFA_COMPOSING:
  390.           {
  391. !         int        mc = curc;
  392.           int        len = 0;
  393.           nfa_state_T *end;
  394.           nfa_state_T *sta;
  395. ***************
  396. *** 3286,3299 ****
  397.               /* Only match composing character(s), ignore base
  398.                * character.  Used for ".{composing}" and "{composing}"
  399.                * (no preceding character). */
  400. !             len += mb_char2len(c);
  401.           }
  402.           if (ireg_icombine)
  403.           {
  404.               /* If \Z was present, then ignore composing characters.
  405.                * When ignoring the base character this always matches. */
  406.               /* TODO: How about negated? */
  407. !             if (len == 0 && sta->c != c)
  408.               result = FAIL;
  409.               else
  410.               result = OK;
  411. --- 3292,3305 ----
  412.               /* Only match composing character(s), ignore base
  413.                * character.  Used for ".{composing}" and "{composing}"
  414.                * (no preceding character). */
  415. !             len += mb_char2len(mc);
  416.           }
  417.           if (ireg_icombine)
  418.           {
  419.               /* If \Z was present, then ignore composing characters.
  420.                * When ignoring the base character this always matches. */
  421.               /* TODO: How about negated? */
  422. !             if (len == 0 && sta->c != curc)
  423.               result = FAIL;
  424.               else
  425.               result = OK;
  426. ***************
  427. *** 3312,3318 ****
  428.   
  429.               /* We don't care about the order of composing characters.
  430.                * Get them into cchars[] first. */
  431. !             while (len < n)
  432.               {
  433.               mc = mb_ptr2char(reginput + len);
  434.               cchars[ccount++] = mc;
  435. --- 3318,3324 ----
  436.   
  437.               /* We don't care about the order of composing characters.
  438.                * Get them into cchars[] first. */
  439. !             while (len < clen)
  440.               {
  441.               mc = mb_ptr2char(reginput + len);
  442.               cchars[ccount++] = mc;
  443. ***************
  444. *** 3349,3355 ****
  445.   
  446.           case NFA_NEWL:
  447.           if (!reg_line_lbr && REG_MULTI
  448. !                     && c == NUL && reglnum <= reg_maxline)
  449.           {
  450.               go_to_nextline = TRUE;
  451.               /* Pass -1 for the offset, which means taking the position
  452. --- 3355,3361 ----
  453.   
  454.           case NFA_NEWL:
  455.           if (!reg_line_lbr && REG_MULTI
  456. !                      && curc == NUL && reglnum <= reg_maxline)
  457.           {
  458.               go_to_nextline = TRUE;
  459.               /* Pass -1 for the offset, which means taking the position
  460. ***************
  461. *** 3375,3409 ****
  462.           case NFA_CLASS_RETURN:
  463.           case NFA_CLASS_BACKSPACE:
  464.           case NFA_CLASS_ESCAPE:
  465. !         result = check_char_class(t->state->c, c);
  466.           ADD_POS_NEG_STATE(t->state);
  467.           break;
  468.   
  469.           case NFA_END_NEG_RANGE:
  470.           /* This follows a series of negated nodes, like:
  471.            * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
  472. !         if (c > 0)
  473. !             addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
  474. !                                     &match);
  475.           break;
  476.   
  477.           case NFA_ANY:
  478.           /* Any char except '\0', (end of input) does not match. */
  479. !         if (c > 0)
  480. !             addstate(nextlist, t->state->out, &t->sub, n, listid + 1,
  481. !                                     &match);
  482.           break;
  483.   
  484.           /*
  485.            * Character classes like \a for alpha, \d for digit etc.
  486.            */
  487.           case NFA_IDENT:    /*  \i    */
  488. !         result = vim_isIDc(c);
  489.           ADD_POS_NEG_STATE(t->state);
  490.           break;
  491.   
  492.           case NFA_SIDENT:    /*  \I    */
  493. !         result = !VIM_ISDIGIT(c) && vim_isIDc(c);
  494.           ADD_POS_NEG_STATE(t->state);
  495.           break;
  496.   
  497. --- 3381,3415 ----
  498.           case NFA_CLASS_RETURN:
  499.           case NFA_CLASS_BACKSPACE:
  500.           case NFA_CLASS_ESCAPE:
  501. !         result = check_char_class(t->state->c, curc);
  502.           ADD_POS_NEG_STATE(t->state);
  503.           break;
  504.   
  505.           case NFA_END_NEG_RANGE:
  506.           /* This follows a series of negated nodes, like:
  507.            * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
  508. !         if (curc > 0)
  509. !             addstate(nextlist, t->state->out, &t->sub, clen,
  510. !                               listid + 1, &match);
  511.           break;
  512.   
  513.           case NFA_ANY:
  514.           /* Any char except '\0', (end of input) does not match. */
  515. !         if (curc > 0)
  516. !             addstate(nextlist, t->state->out, &t->sub, clen,
  517. !                               listid + 1, &match);
  518.           break;
  519.   
  520.           /*
  521.            * Character classes like \a for alpha, \d for digit etc.
  522.            */
  523.           case NFA_IDENT:    /*  \i    */
  524. !         result = vim_isIDc(curc);
  525.           ADD_POS_NEG_STATE(t->state);
  526.           break;
  527.   
  528.           case NFA_SIDENT:    /*  \I    */
  529. !         result = !VIM_ISDIGIT(curc) && vim_isIDc(curc);
  530.           ADD_POS_NEG_STATE(t->state);
  531.           break;
  532.   
  533. ***************
  534. *** 3413,3429 ****
  535.           break;
  536.   
  537.           case NFA_SKWORD:    /*  \K    */
  538. !         result = !VIM_ISDIGIT(c) && vim_iswordp_buf(reginput, reg_buf);
  539.           ADD_POS_NEG_STATE(t->state);
  540.           break;
  541.   
  542.           case NFA_FNAME:    /*  \f    */
  543. !         result = vim_isfilec(c);
  544.           ADD_POS_NEG_STATE(t->state);
  545.           break;
  546.   
  547.           case NFA_SFNAME:    /*  \F    */
  548. !         result = !VIM_ISDIGIT(c) && vim_isfilec(c);
  549.           ADD_POS_NEG_STATE(t->state);
  550.           break;
  551.   
  552. --- 3419,3436 ----
  553.           break;
  554.   
  555.           case NFA_SKWORD:    /*  \K    */
  556. !         result = !VIM_ISDIGIT(curc)
  557. !                     && vim_iswordp_buf(reginput, reg_buf);
  558.           ADD_POS_NEG_STATE(t->state);
  559.           break;
  560.   
  561.           case NFA_FNAME:    /*  \f    */
  562. !         result = vim_isfilec(curc);
  563.           ADD_POS_NEG_STATE(t->state);
  564.           break;
  565.   
  566.           case NFA_SFNAME:    /*  \F    */
  567. !         result = !VIM_ISDIGIT(curc) && vim_isfilec(curc);
  568.           ADD_POS_NEG_STATE(t->state);
  569.           break;
  570.   
  571. ***************
  572. *** 3433,3529 ****
  573.           break;
  574.   
  575.           case NFA_SPRINT:    /*  \P    */
  576. !         result = !VIM_ISDIGIT(c) && ptr2cells(reginput) == 1;
  577.           ADD_POS_NEG_STATE(t->state);
  578.           break;
  579.   
  580.           case NFA_WHITE:    /*  \s    */
  581. !         result = vim_iswhite(c);
  582.           ADD_POS_NEG_STATE(t->state);
  583.           break;
  584.   
  585.           case NFA_NWHITE:    /*  \S    */
  586. !         result = c != NUL && !vim_iswhite(c);
  587.           ADD_POS_NEG_STATE(t->state);
  588.           break;
  589.   
  590.           case NFA_DIGIT:    /*  \d    */
  591. !         result = ri_digit(c);
  592.           ADD_POS_NEG_STATE(t->state);
  593.           break;
  594.   
  595.           case NFA_NDIGIT:    /*  \D    */
  596. !         result = c != NUL && !ri_digit(c);
  597.           ADD_POS_NEG_STATE(t->state);
  598.           break;
  599.   
  600.           case NFA_HEX:    /*  \x    */
  601. !         result = ri_hex(c);
  602.           ADD_POS_NEG_STATE(t->state);
  603.           break;
  604.   
  605.           case NFA_NHEX:    /*  \X    */
  606. !         result = c != NUL && !ri_hex(c);
  607.           ADD_POS_NEG_STATE(t->state);
  608.           break;
  609.   
  610.           case NFA_OCTAL:    /*  \o    */
  611. !         result = ri_octal(c);
  612.           ADD_POS_NEG_STATE(t->state);
  613.           break;
  614.   
  615.           case NFA_NOCTAL:    /*  \O    */
  616. !         result = c != NUL && !ri_octal(c);
  617.           ADD_POS_NEG_STATE(t->state);
  618.           break;
  619.   
  620.           case NFA_WORD:    /*  \w    */
  621. !         result = ri_word(c);
  622.           ADD_POS_NEG_STATE(t->state);
  623.           break;
  624.   
  625.           case NFA_NWORD:    /*  \W    */
  626. !         result = c != NUL && !ri_word(c);
  627.           ADD_POS_NEG_STATE(t->state);
  628.           break;
  629.   
  630.           case NFA_HEAD:    /*  \h    */
  631. !         result = ri_head(c);
  632.           ADD_POS_NEG_STATE(t->state);
  633.           break;
  634.   
  635.           case NFA_NHEAD:    /*  \H    */
  636. !         result = c != NUL && !ri_head(c);
  637.           ADD_POS_NEG_STATE(t->state);
  638.           break;
  639.   
  640.           case NFA_ALPHA:    /*  \a    */
  641. !         result = ri_alpha(c);
  642.           ADD_POS_NEG_STATE(t->state);
  643.           break;
  644.   
  645.           case NFA_NALPHA:    /*  \A    */
  646. !         result = c != NUL && !ri_alpha(c);
  647.           ADD_POS_NEG_STATE(t->state);
  648.           break;
  649.   
  650.           case NFA_LOWER:    /*  \l    */
  651. !         result = ri_lower(c);
  652.           ADD_POS_NEG_STATE(t->state);
  653.           break;
  654.   
  655.           case NFA_NLOWER:    /*  \L    */
  656. !         result = c != NUL && !ri_lower(c);
  657.           ADD_POS_NEG_STATE(t->state);
  658.           break;
  659.   
  660.           case NFA_UPPER:    /*  \u    */
  661. !         result = ri_upper(c);
  662.           ADD_POS_NEG_STATE(t->state);
  663.           break;
  664.   
  665.           case NFA_NUPPER:    /* \U    */
  666. !         result = c != NUL && !ri_upper(c);
  667.           ADD_POS_NEG_STATE(t->state);
  668.           break;
  669.   
  670. --- 3440,3536 ----
  671.           break;
  672.   
  673.           case NFA_SPRINT:    /*  \P    */
  674. !         result = !VIM_ISDIGIT(curc) && ptr2cells(reginput) == 1;
  675.           ADD_POS_NEG_STATE(t->state);
  676.           break;
  677.   
  678.           case NFA_WHITE:    /*  \s    */
  679. !         result = vim_iswhite(curc);
  680.           ADD_POS_NEG_STATE(t->state);
  681.           break;
  682.   
  683.           case NFA_NWHITE:    /*  \S    */
  684. !         result = curc != NUL && !vim_iswhite(curc);
  685.           ADD_POS_NEG_STATE(t->state);
  686.           break;
  687.   
  688.           case NFA_DIGIT:    /*  \d    */
  689. !         result = ri_digit(curc);
  690.           ADD_POS_NEG_STATE(t->state);
  691.           break;
  692.   
  693.           case NFA_NDIGIT:    /*  \D    */
  694. !         result = curc != NUL && !ri_digit(curc);
  695.           ADD_POS_NEG_STATE(t->state);
  696.           break;
  697.   
  698.           case NFA_HEX:    /*  \x    */
  699. !         result = ri_hex(curc);
  700.           ADD_POS_NEG_STATE(t->state);
  701.           break;
  702.   
  703.           case NFA_NHEX:    /*  \X    */
  704. !         result = curc != NUL && !ri_hex(curc);
  705.           ADD_POS_NEG_STATE(t->state);
  706.           break;
  707.   
  708.           case NFA_OCTAL:    /*  \o    */
  709. !         result = ri_octal(curc);
  710.           ADD_POS_NEG_STATE(t->state);
  711.           break;
  712.   
  713.           case NFA_NOCTAL:    /*  \O    */
  714. !         result = curc != NUL && !ri_octal(curc);
  715.           ADD_POS_NEG_STATE(t->state);
  716.           break;
  717.   
  718.           case NFA_WORD:    /*  \w    */
  719. !         result = ri_word(curc);
  720.           ADD_POS_NEG_STATE(t->state);
  721.           break;
  722.   
  723.           case NFA_NWORD:    /*  \W    */
  724. !         result = curc != NUL && !ri_word(curc);
  725.           ADD_POS_NEG_STATE(t->state);
  726.           break;
  727.   
  728.           case NFA_HEAD:    /*  \h    */
  729. !         result = ri_head(curc);
  730.           ADD_POS_NEG_STATE(t->state);
  731.           break;
  732.   
  733.           case NFA_NHEAD:    /*  \H    */
  734. !         result = curc != NUL && !ri_head(curc);
  735.           ADD_POS_NEG_STATE(t->state);
  736.           break;
  737.   
  738.           case NFA_ALPHA:    /*  \a    */
  739. !         result = ri_alpha(curc);
  740.           ADD_POS_NEG_STATE(t->state);
  741.           break;
  742.   
  743.           case NFA_NALPHA:    /*  \A    */
  744. !         result = curc != NUL && !ri_alpha(curc);
  745.           ADD_POS_NEG_STATE(t->state);
  746.           break;
  747.   
  748.           case NFA_LOWER:    /*  \l    */
  749. !         result = ri_lower(curc);
  750.           ADD_POS_NEG_STATE(t->state);
  751.           break;
  752.   
  753.           case NFA_NLOWER:    /*  \L    */
  754. !         result = curc != NUL && !ri_lower(curc);
  755.           ADD_POS_NEG_STATE(t->state);
  756.           break;
  757.   
  758.           case NFA_UPPER:    /*  \u    */
  759. !         result = ri_upper(curc);
  760.           ADD_POS_NEG_STATE(t->state);
  761.           break;
  762.   
  763.           case NFA_NUPPER:    /* \U    */
  764. !         result = curc != NUL && !ri_upper(curc);
  765.           ADD_POS_NEG_STATE(t->state);
  766.           break;
  767.   
  768. ***************
  769. *** 3549,3565 ****
  770.           /* TODO: put this in #ifdef later */
  771.           if (t->state->c < -256)
  772.               EMSGN("INTERNAL: Negative state char: %ld", t->state->c);
  773. !         result = (no_Magic(t->state->c) == c);
  774.   
  775.           if (!result)
  776.               result = ireg_ic == TRUE
  777. !                 && MB_TOLOWER(t->state->c) == MB_TOLOWER(c);
  778.   #ifdef FEAT_MBYTE
  779.           /* If there is a composing character which is not being
  780.            * ignored there can be no match. Match with composing
  781.            * character uses NFA_COMPOSING above. */
  782.           if (result && enc_utf8 && !ireg_icombine
  783. !                               && n != utf_char2len(c))
  784.               result = FALSE;
  785.   #endif
  786.           ADD_POS_NEG_STATE(t->state);
  787. --- 3556,3572 ----
  788.           /* TODO: put this in #ifdef later */
  789.           if (t->state->c < -256)
  790.               EMSGN("INTERNAL: Negative state char: %ld", t->state->c);
  791. !         result = (no_Magic(t->state->c) == curc);
  792.   
  793.           if (!result)
  794.               result = ireg_ic == TRUE
  795. !                    && MB_TOLOWER(t->state->c) == MB_TOLOWER(curc);
  796.   #ifdef FEAT_MBYTE
  797.           /* If there is a composing character which is not being
  798.            * ignored there can be no match. Match with composing
  799.            * character uses NFA_COMPOSING above. */
  800.           if (result && enc_utf8 && !ireg_icombine
  801. !                         && clen != utf_char2len(curc))
  802.               result = FALSE;
  803.   #endif
  804.           ADD_POS_NEG_STATE(t->state);
  805. ***************
  806. *** 3578,3598 ****
  807.   #ifdef ENABLE_LOG
  808.           fprintf(log_fd, "(---) STARTSTATE\n");
  809.   #endif
  810. !         addstate(nextlist, start, m, n, listid + 1, &match);
  811.       }
  812.   
  813.   #ifdef ENABLE_LOG
  814.       fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n);
  815. !     for (i = 0; i< thislist->n; i++)
  816. !         fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
  817.       fprintf(log_fd, "\n");
  818.   #endif
  819.   
  820.   nextchar:
  821.       /* Advance to the next character, or advance to the next line, or
  822.        * finish. */
  823. !     if (n != 0)
  824. !         reginput += n;
  825.       else if (go_to_nextline)
  826.           reg_nextline();
  827.       else
  828. --- 3585,3609 ----
  829.   #ifdef ENABLE_LOG
  830.           fprintf(log_fd, "(---) STARTSTATE\n");
  831.   #endif
  832. !         addstate(nextlist, start, m, clen, listid + 1, &match);
  833.       }
  834.   
  835.   #ifdef ENABLE_LOG
  836.       fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n);
  837. !     {
  838. !         int i;
  839. ! 
  840. !         for (i = 0; i < thislist->n; i++)
  841. !         fprintf(log_fd, "%d  ", abs(thislist->t[i].state->id));
  842. !     }
  843.       fprintf(log_fd, "\n");
  844.   #endif
  845.   
  846.   nextchar:
  847.       /* Advance to the next character, or advance to the next line, or
  848.        * finish. */
  849. !     if (clen != 0)
  850. !         reginput += clen;
  851.       else if (go_to_nextline)
  852.           reg_nextline();
  853.       else
  854. *** ../vim-7.3.1021/src/version.c    2013-05-26 14:32:01.000000000 +0200
  855. --- src/version.c    2013-05-26 14:39:12.000000000 +0200
  856. ***************
  857. *** 730,731 ****
  858. --- 730,733 ----
  859.   {   /* Add new patch number below this line */
  860. + /**/
  861. +     1022,
  862.   /**/
  863.  
  864. -- 
  865. Female engineers become irresistible at the age of consent and remain that
  866. way until about thirty minutes after their clinical death.  Longer if it's a
  867. warm day.
  868.                 (Scott Adams - The Dilbert principle)
  869.  
  870.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  871. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  872. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  873.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  874.