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.1139 < prev    next >
Encoding:
Internet Message Format  |  2013-06-06  |  14.5 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1139
  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.1139
  11. Problem:    New regexp engine: negated flag is hardly used.
  12. Solution:   Add separate _NEG states, remove negated flag.
  13. Files:        src/regexp_nfa.c, src/regexp.h
  14.  
  15.  
  16. *** ../vim-7.3.1138/src/regexp_nfa.c    2013-06-07 14:59:14.000000000 +0200
  17. --- src/regexp_nfa.c    2013-06-07 16:31:29.000000000 +0200
  18. ***************
  19. *** 64,72 ****
  20. --- 64,75 ----
  21.       NFA_NOPEN,                /* Start of subexpression marked with \%( */
  22.       NFA_NCLOSE,                /* End of subexpr. marked with \%( ... \) */
  23.       NFA_START_INVISIBLE,
  24. +     NFA_START_INVISIBLE_NEG,
  25.       NFA_START_INVISIBLE_BEFORE,
  26. +     NFA_START_INVISIBLE_BEFORE_NEG,
  27.       NFA_START_PATTERN,
  28.       NFA_END_INVISIBLE,
  29. +     NFA_END_INVISIBLE_NEG,
  30.       NFA_END_PATTERN,
  31.       NFA_COMPOSING,            /* Next nodes in NFA are part of the
  32.                          composing multibyte char */
  33. ***************
  34. *** 481,487 ****
  35.           }
  36.   
  37.           default:
  38. !         if (p->c > 0 && !p->negated)
  39.               return p->c; /* yes! */
  40.           return 0;
  41.       }
  42. --- 484,490 ----
  43.           }
  44.   
  45.           default:
  46. !         if (p->c > 0)
  47.               return p->c; /* yes! */
  48.           return 0;
  49.       }
  50. ***************
  51. *** 1991,2000 ****
  52. --- 1994,2008 ----
  53.       case NFA_NOPEN:            STRCPY(code, "NFA_NOPEN"); break;
  54.       case NFA_NCLOSE:        STRCPY(code, "NFA_NCLOSE"); break;
  55.       case NFA_START_INVISIBLE:   STRCPY(code, "NFA_START_INVISIBLE"); break;
  56. +     case NFA_START_INVISIBLE_NEG:
  57. +                    STRCPY(code, "NFA_START_INVISIBLE_NEG"); break;
  58.       case NFA_START_INVISIBLE_BEFORE:
  59.                   STRCPY(code, "NFA_START_INVISIBLE_BEFORE"); break;
  60. +     case NFA_START_INVISIBLE_BEFORE_NEG:
  61. +             STRCPY(code, "NFA_START_INVISIBLE_BEFORE_NEG"); break;
  62.       case NFA_START_PATTERN:   STRCPY(code, "NFA_START_PATTERN"); break;
  63.       case NFA_END_INVISIBLE:        STRCPY(code, "NFA_END_INVISIBLE"); break;
  64. +     case NFA_END_INVISIBLE_NEG: STRCPY(code, "NFA_END_INVISIBLE_NEG"); break;
  65.       case NFA_END_PATTERN:        STRCPY(code, "NFA_END_PATTERN"); break;
  66.   
  67.       case NFA_COMPOSING:        STRCPY(code, "NFA_COMPOSING"); break;
  68. ***************
  69. *** 2227,2234 ****
  70.       fprintf(debugf, " %s", p);
  71.   
  72.       nfa_set_code(state->c);
  73. !     fprintf(debugf, "%s%s (%d) (id=%d) val=%d\n",
  74. !          state->negated ? "NOT " : "",
  75.            code,
  76.            state->c,
  77.            abs(state->id),
  78. --- 2235,2241 ----
  79.       fprintf(debugf, " %s", p);
  80.   
  81.       nfa_set_code(state->c);
  82. !     fprintf(debugf, "%s (%d) (id=%d) val=%d\n",
  83.            code,
  84.            state->c,
  85.            abs(state->id),
  86. ***************
  87. *** 2330,2336 ****
  88.       s->id   = istate;
  89.       s->lastlist[0] = 0;
  90.       s->lastlist[1] = 0;
  91. -     s->negated = FALSE;
  92.   
  93.       return s;
  94.   }
  95. --- 2337,2342 ----
  96. ***************
  97. *** 2741,2763 ****
  98.       case NFA_PREV_ATOM_JUST_BEFORE_NEG:
  99.       case NFA_PREV_ATOM_LIKE_PATTERN:
  100.         {
  101. -         int neg = (*p == NFA_PREV_ATOM_NO_WIDTH_NEG
  102. -                       || *p == NFA_PREV_ATOM_JUST_BEFORE_NEG);
  103.           int before = (*p == NFA_PREV_ATOM_JUST_BEFORE
  104.                         || *p == NFA_PREV_ATOM_JUST_BEFORE_NEG);
  105.           int pattern = (*p == NFA_PREV_ATOM_LIKE_PATTERN);
  106. !         int start_state = NFA_START_INVISIBLE;
  107. !         int end_state = NFA_END_INVISIBLE;
  108.           int n = 0;
  109.           nfa_state_T *zend;
  110.           nfa_state_T *skip;
  111.   
  112. !         if (before)
  113. !         start_state = NFA_START_INVISIBLE_BEFORE;
  114. !         else if (pattern)
  115.           {
  116. !         start_state = NFA_START_PATTERN;
  117. !         end_state = NFA_END_PATTERN;
  118.           }
  119.   
  120.           if (before)
  121. --- 2747,2783 ----
  122.       case NFA_PREV_ATOM_JUST_BEFORE_NEG:
  123.       case NFA_PREV_ATOM_LIKE_PATTERN:
  124.         {
  125.           int before = (*p == NFA_PREV_ATOM_JUST_BEFORE
  126.                         || *p == NFA_PREV_ATOM_JUST_BEFORE_NEG);
  127.           int pattern = (*p == NFA_PREV_ATOM_LIKE_PATTERN);
  128. !         int start_state;
  129. !         int end_state;
  130.           int n = 0;
  131.           nfa_state_T *zend;
  132.           nfa_state_T *skip;
  133.   
  134. !         switch (*p)
  135.           {
  136. !         case NFA_PREV_ATOM_NO_WIDTH:
  137. !             start_state = NFA_START_INVISIBLE;
  138. !             end_state = NFA_END_INVISIBLE;
  139. !             break;
  140. !         case NFA_PREV_ATOM_NO_WIDTH_NEG:
  141. !             start_state = NFA_START_INVISIBLE_NEG;
  142. !             end_state = NFA_END_INVISIBLE_NEG;
  143. !             break;
  144. !         case NFA_PREV_ATOM_JUST_BEFORE:
  145. !             start_state = NFA_START_INVISIBLE_BEFORE;
  146. !             end_state = NFA_END_INVISIBLE;
  147. !             break;
  148. !         case NFA_PREV_ATOM_JUST_BEFORE_NEG:
  149. !             start_state = NFA_START_INVISIBLE_BEFORE_NEG;
  150. !             end_state = NFA_END_INVISIBLE_NEG;
  151. !             break;
  152. !         case NFA_PREV_ATOM_LIKE_PATTERN:
  153. !             start_state = NFA_START_PATTERN;
  154. !             end_state = NFA_END_PATTERN;
  155. !             break;
  156.           }
  157.   
  158.           if (before)
  159. ***************
  160. *** 2783,2793 ****
  161.           s = alloc_state(start_state, e.start, s1);
  162.           if (s == NULL)
  163.           goto theend;
  164. -         if (neg)
  165. -         {
  166. -         s->negated = TRUE;
  167. -         s1->negated = TRUE;
  168. -         }
  169.           if (before)
  170.           s->val = n; /* store the count */
  171.           if (pattern)
  172. --- 2803,2808 ----
  173. ***************
  174. *** 3009,3015 ****
  175.       matchstate = &state_ptr[istate++]; /* the match state */
  176.       matchstate->c = NFA_MATCH;
  177.       matchstate->out = matchstate->out1 = NULL;
  178. -     matchstate->negated = FALSE;
  179.       matchstate->id = 0;
  180.   
  181.       patch(e.out, matchstate);
  182. --- 3024,3029 ----
  183. ***************
  184. *** 3772,3778 ****
  185.           return OK;
  186.           break;
  187.       case NFA_CLASS_SPACE:
  188. !         if ((c >=9 && c <= 13) || (c == ' '))
  189.           return OK;
  190.           break;
  191.       case NFA_CLASS_UPPER:
  192. --- 3786,3792 ----
  193.           return OK;
  194.           break;
  195.       case NFA_CLASS_SPACE:
  196. !         if ((c >= 9 && c <= 13) || (c == ' '))
  197.           return OK;
  198.           break;
  199.       case NFA_CLASS_UPPER:
  200. ***************
  201. *** 3971,3977 ****
  202.       int        result;
  203.       int        need_restore = FALSE;
  204.   
  205. !     if (state->c == NFA_START_INVISIBLE_BEFORE)
  206.       {
  207.       /* The recursive match must end at the current position. */
  208.       endposp = &endpos;
  209. --- 3985,3992 ----
  210.       int        result;
  211.       int        need_restore = FALSE;
  212.   
  213. !     if (state->c == NFA_START_INVISIBLE_BEFORE
  214. !         || state->c == NFA_START_INVISIBLE_BEFORE_NEG)
  215.       {
  216.       /* The recursive match must end at the current position. */
  217.       endposp = &endpos;
  218. ***************
  219. *** 4452,4457 ****
  220. --- 4467,4473 ----
  221.             }
  222.   
  223.           case NFA_END_INVISIBLE:
  224. +         case NFA_END_INVISIBLE_NEG:
  225.           case NFA_END_PATTERN:
  226.           /*
  227.            * This is only encountered after a NFA_START_INVISIBLE or
  228. ***************
  229. *** 4489,4495 ****
  230.               break;
  231.   
  232.           /* do not set submatches for \@! */
  233. !         if (!t->state->negated)
  234.           {
  235.               copy_sub(&m->norm, &t->subs.norm);
  236.   #ifdef FEAT_SYN_HL
  237. --- 4505,4511 ----
  238.               break;
  239.   
  240.           /* do not set submatches for \@! */
  241. !         if (t->state->c != NFA_END_INVISIBLE_NEG)
  242.           {
  243.               copy_sub(&m->norm, &t->subs.norm);
  244.   #ifdef FEAT_SYN_HL
  245. ***************
  246. *** 4505,4511 ****
  247. --- 4521,4529 ----
  248.           break;
  249.   
  250.           case NFA_START_INVISIBLE:
  251. +         case NFA_START_INVISIBLE_NEG:
  252.           case NFA_START_INVISIBLE_BEFORE:
  253. +         case NFA_START_INVISIBLE_BEFORE_NEG:
  254.           {
  255.               nfa_pim_T *pim;
  256.               int cout = t->state->out1->out->c;
  257. ***************
  258. *** 4524,4529 ****
  259. --- 4542,4548 ----
  260.                   || cout == NFA_NCLOSE
  261.                   || t->pim != NULL
  262.                   || (t->state->c != NFA_START_INVISIBLE_BEFORE
  263. +                     && t->state->c != NFA_START_INVISIBLE_BEFORE_NEG
  264.                   && failure_chance(t->state->out1->out, 0)
  265.                         < failure_chance(t->state->out, 0)))
  266.               {
  267. ***************
  268. *** 4534,4541 ****
  269.               result = recursive_regmatch(t->state, prog,
  270.                                  submatch, m, &listids);
  271.   
  272. !             /* for \@! it is a match when result is FALSE */
  273. !             if (result != t->state->negated)
  274.               {
  275.                   /* Copy submatch info from the recursive call */
  276.                   copy_sub_off(&t->subs.norm, &m->norm);
  277. --- 4553,4563 ----
  278.               result = recursive_regmatch(t->state, prog,
  279.                                  submatch, m, &listids);
  280.   
  281. !             /* for \@! and \@<! it is a match when the result is
  282. !              * FALSE */
  283. !             if (result != (t->state->c == NFA_START_INVISIBLE_NEG
  284. !                         || t->state->c
  285. !                        == NFA_START_INVISIBLE_BEFORE_NEG))
  286.               {
  287.                   /* Copy submatch info from the recursive call */
  288.                   copy_sub_off(&t->subs.norm, &m->norm);
  289. ***************
  290. *** 4646,4656 ****
  291.           break;
  292.   
  293.           case NFA_BOW:
  294. !         {
  295. !         int bow = TRUE;
  296.   
  297.           if (curc == NUL)
  298. !             bow = FALSE;
  299.   #ifdef FEAT_MBYTE
  300.           else if (has_mbyte)
  301.           {
  302. --- 4668,4677 ----
  303.           break;
  304.   
  305.           case NFA_BOW:
  306. !         result = TRUE;
  307.   
  308.           if (curc == NUL)
  309. !             result = FALSE;
  310.   #ifdef FEAT_MBYTE
  311.           else if (has_mbyte)
  312.           {
  313. ***************
  314. *** 4659,4685 ****
  315.               /* Get class of current and previous char (if it exists). */
  316.               this_class = mb_get_class_buf(reginput, reg_buf);
  317.               if (this_class <= 1)
  318. !             bow = FALSE;
  319.               else if (reg_prev_class() == this_class)
  320. !             bow = FALSE;
  321.           }
  322.   #endif
  323.           else if (!vim_iswordc_buf(curc, reg_buf)
  324.                  || (reginput > regline
  325.                      && vim_iswordc_buf(reginput[-1], reg_buf)))
  326. !             bow = FALSE;
  327. !         if (bow)
  328.               addstate_here(thislist, t->state->out, &t->subs,
  329.                                   t->pim, &listidx);
  330.           break;
  331. -         }
  332.   
  333.           case NFA_EOW:
  334. !         {
  335. !         int eow = TRUE;
  336. ! 
  337.           if (reginput == regline)
  338. !             eow = FALSE;
  339.   #ifdef FEAT_MBYTE
  340.           else if (has_mbyte)
  341.           {
  342. --- 4680,4703 ----
  343.               /* Get class of current and previous char (if it exists). */
  344.               this_class = mb_get_class_buf(reginput, reg_buf);
  345.               if (this_class <= 1)
  346. !             result = FALSE;
  347.               else if (reg_prev_class() == this_class)
  348. !             result = FALSE;
  349.           }
  350.   #endif
  351.           else if (!vim_iswordc_buf(curc, reg_buf)
  352.                  || (reginput > regline
  353.                      && vim_iswordc_buf(reginput[-1], reg_buf)))
  354. !             result = FALSE;
  355. !         if (result)
  356.               addstate_here(thislist, t->state->out, &t->subs,
  357.                                   t->pim, &listidx);
  358.           break;
  359.   
  360.           case NFA_EOW:
  361. !         result = TRUE;
  362.           if (reginput == regline)
  363. !             result = FALSE;
  364.   #ifdef FEAT_MBYTE
  365.           else if (has_mbyte)
  366.           {
  367. ***************
  368. *** 4690,4707 ****
  369.               prev_class = reg_prev_class();
  370.               if (this_class == prev_class
  371.                       || prev_class == 0 || prev_class == 1)
  372. !             eow = FALSE;
  373.           }
  374.   #endif
  375.           else if (!vim_iswordc_buf(reginput[-1], reg_buf)
  376.               || (reginput[0] != NUL
  377.                          && vim_iswordc_buf(curc, reg_buf)))
  378. !             eow = FALSE;
  379. !         if (eow)
  380.               addstate_here(thislist, t->state->out, &t->subs,
  381.                                   t->pim, &listidx);
  382.           break;
  383. -         }
  384.   
  385.           case NFA_BOF:
  386.           if (reglnum == 0 && reginput == regline
  387. --- 4708,4724 ----
  388.               prev_class = reg_prev_class();
  389.               if (this_class == prev_class
  390.                       || prev_class == 0 || prev_class == 1)
  391. !             result = FALSE;
  392.           }
  393.   #endif
  394.           else if (!vim_iswordc_buf(reginput[-1], reg_buf)
  395.               || (reginput[0] != NUL
  396.                          && vim_iswordc_buf(curc, reg_buf)))
  397. !             result = FALSE;
  398. !         if (result)
  399.               addstate_here(thislist, t->state->out, &t->subs,
  400.                                   t->pim, &listidx);
  401.           break;
  402.   
  403.           case NFA_BOF:
  404.           if (reglnum == 0 && reginput == regline
  405. ***************
  406. *** 4740,4746 ****
  407.           {
  408.               /* If \Z was present, then ignore composing characters.
  409.                * When ignoring the base character this always matches. */
  410. -             /* TODO: How about negated? */
  411.               if (len == 0 && sta->c != curc)
  412.               result = FAIL;
  413.               else
  414. --- 4757,4762 ----
  415. ***************
  416. *** 4813,4838 ****
  417.           }
  418.           break;
  419.   
  420. -         case NFA_CLASS_ALNUM:
  421. -         case NFA_CLASS_ALPHA:
  422. -         case NFA_CLASS_BLANK:
  423. -         case NFA_CLASS_CNTRL:
  424. -         case NFA_CLASS_DIGIT:
  425. -         case NFA_CLASS_GRAPH:
  426. -         case NFA_CLASS_LOWER:
  427. -         case NFA_CLASS_PRINT:
  428. -         case NFA_CLASS_PUNCT:
  429. -         case NFA_CLASS_SPACE:
  430. -         case NFA_CLASS_UPPER:
  431. -         case NFA_CLASS_XDIGIT:
  432. -         case NFA_CLASS_TAB:
  433. -         case NFA_CLASS_RETURN:
  434. -         case NFA_CLASS_BACKSPACE:
  435. -         case NFA_CLASS_ESCAPE:
  436. -         result = check_char_class(t->state->c, curc);
  437. -         ADD_STATE_IF_MATCH(t->state);
  438. -         break;
  439. - 
  440.           case NFA_START_COLL:
  441.           case NFA_START_NEG_COLL:
  442.             {
  443. --- 4829,4834 ----
  444. ***************
  445. *** 5212,5221 ****
  446.           int c = t->state->c;
  447.   
  448.           /* TODO: put this in #ifdef later */
  449. !         if (c < -256)
  450.               EMSGN("INTERNAL: Negative state char: %ld", c);
  451. -         if (is_Magic(c))
  452. -             c = un_Magic(c);
  453.           result = (c == curc);
  454.   
  455.           if (!result && ireg_ic)
  456. --- 5208,5215 ----
  457.           int c = t->state->c;
  458.   
  459.           /* TODO: put this in #ifdef later */
  460. !         if (c < 0)
  461.               EMSGN("INTERNAL: Negative state char: %ld", c);
  462.           result = (c == curc);
  463.   
  464.           if (!result && ireg_ic)
  465. ***************
  466. *** 5252,5259 ****
  467.                            prog, submatch, m, &listids);
  468.               t->pim->result = result ? NFA_PIM_MATCH
  469.                                   : NFA_PIM_NOMATCH;
  470. !             /* for \@! it is a match when result is FALSE */
  471. !             if (result != t->pim->state->negated)
  472.               {
  473.                   /* Copy submatch info from the recursive call */
  474.                   copy_sub_off(&t->pim->subs.norm, &m->norm);
  475. --- 5246,5257 ----
  476.                            prog, submatch, m, &listids);
  477.               t->pim->result = result ? NFA_PIM_MATCH
  478.                                   : NFA_PIM_NOMATCH;
  479. !             /* for \@! and \@<! it is a match when the result is
  480. !              * FALSE */
  481. !             if (result != (t->pim->state->c
  482. !                             == NFA_START_INVISIBLE_NEG
  483. !                         || t->pim->state->c
  484. !                        == NFA_START_INVISIBLE_BEFORE_NEG))
  485.               {
  486.                   /* Copy submatch info from the recursive call */
  487.                   copy_sub_off(&t->pim->subs.norm, &m->norm);
  488. ***************
  489. *** 5274,5281 ****
  490.   #endif
  491.               }
  492.   
  493. !             /* for \@! it is a match when result is FALSE */
  494. !             if (result != t->pim->state->negated)
  495.               {
  496.               /* Copy submatch info from the recursive call */
  497.               copy_sub_off(&t->subs.norm, &t->pim->subs.norm);
  498. --- 5272,5281 ----
  499.   #endif
  500.               }
  501.   
  502. !             /* for \@! and \@<! it is a match when result is FALSE */
  503. !             if (result != (t->pim->state->c == NFA_START_INVISIBLE_NEG
  504. !                     || t->pim->state->c
  505. !                        == NFA_START_INVISIBLE_BEFORE_NEG))
  506.               {
  507.               /* Copy submatch info from the recursive call */
  508.               copy_sub_off(&t->subs.norm, &t->pim->subs.norm);
  509. *** ../vim-7.3.1138/src/regexp.h    2013-06-06 18:46:00.000000000 +0200
  510. --- src/regexp.h    2013-06-07 16:11:12.000000000 +0200
  511. ***************
  512. *** 73,79 ****
  513.       nfa_state_T        *out1;
  514.       int            id;
  515.       int            lastlist[2]; /* 0: normal, 1: recursive */
  516. -     int            negated;
  517.       int            val;
  518.   };
  519.   
  520. --- 73,78 ----
  521. *** ../vim-7.3.1138/src/version.c    2013-06-07 14:59:14.000000000 +0200
  522. --- src/version.c    2013-06-07 16:11:59.000000000 +0200
  523. ***************
  524. *** 730,731 ****
  525. --- 730,733 ----
  526.   {   /* Add new patch number below this line */
  527. + /**/
  528. +     1139,
  529.   /**/
  530.  
  531. -- 
  532. Common sense is what tells you that the world is flat.
  533.  
  534.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  535. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  536. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  537.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  538.