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.1149 < prev    next >
Encoding:
Internet Message Format  |  2013-06-07  |  40.3 KB
  1. To: vim_dev@googlegroups.com
  2. Subject: Patch 7.3.1149
  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.1149
  11. Problem:    New regexp engine: Matching plain text could be faster.
  12. Solution:   Detect a plain text match and handle it specifically.  Add
  13.         vim_regfree().
  14. Files:        src/regexp.c, src/regexp.h, src/regexp_nfa.c,
  15.         src/proto/regexp.pro, src/buffer.c, src/edit.c, src/eval.c,
  16.         src/ex_cmds.c, src/ex_cmds2.c, src/ex_docmd.c, src/ex_eval.c,
  17.         src/ex_getln.c, src/fileio.c, src/gui.c, src/misc1.c, src/misc2.c,
  18.         src/option.c, src/syntax.c, src/quickfix.c, src/search.c,
  19.         src/spell.c, src/tag.c, src/window.c, src/screen.c, src/macros.h,
  20.         src/testdir/test64.in, src/testdir/test64.ok
  21.  
  22.  
  23. *** ../vim-7.3.1148/src/regexp.c    2013-06-06 18:04:47.000000000 +0200
  24. --- src/regexp.c    2013-06-08 17:13:06.000000000 +0200
  25. ***************
  26. *** 1297,1303 ****
  27.       return p;
  28.   }
  29.   
  30. ! static regprog_T    *bt_regcomp __ARGS((char_u *expr, int re_flags));
  31.   
  32.   /*
  33.    * bt_regcomp() - compile a regular expression into internal code for the
  34. --- 1297,1304 ----
  35.       return p;
  36.   }
  37.   
  38. ! static regprog_T  *bt_regcomp __ARGS((char_u *expr, int re_flags));
  39. ! static void bt_regfree __ARGS((regprog_T *prog));
  40.   
  41.   /*
  42.    * bt_regcomp() - compile a regular expression into internal code for the
  43. ***************
  44. *** 1455,1460 ****
  45. --- 1456,1471 ----
  46.   }
  47.   
  48.   /*
  49. +  * Free a compiled regexp program, returned by bt_regcomp().
  50. +  */
  51. +     static void
  52. + bt_regfree(prog)
  53. +     regprog_T   *prog;
  54. + {
  55. +     vim_free(prog);
  56. + }
  57. + 
  58. + /*
  59.    * Setup to parse the regexp.  Used once to get the length and once to do it.
  60.    */
  61.       static void
  62. ***************
  63. *** 7876,7881 ****
  64. --- 7887,7893 ----
  65.   static regengine_T bt_regengine =
  66.   {
  67.       bt_regcomp,
  68. +     bt_regfree,
  69.       bt_regexec,
  70.   #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
  71.       || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
  72. ***************
  73. *** 7893,7898 ****
  74. --- 7905,7911 ----
  75.   static regengine_T nfa_regengine =
  76.   {
  77.       nfa_regcomp,
  78. +     nfa_regfree,
  79.       nfa_regexec,
  80.   #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
  81.       || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
  82. ***************
  83. *** 7920,7926 ****
  84.   
  85.   /*
  86.    * Compile a regular expression into internal code.
  87. !  * Returns the program in allocated memory.  Returns NULL for an error.
  88.    */
  89.       regprog_T *
  90.   vim_regcomp(expr_arg, re_flags)
  91. --- 7933,7941 ----
  92.   
  93.   /*
  94.    * Compile a regular expression into internal code.
  95. !  * Returns the program in allocated memory.
  96. !  * Use vim_regfree() to free the memory.
  97. !  * Returns NULL for an error.
  98.    */
  99.       regprog_T *
  100.   vim_regcomp(expr_arg, re_flags)
  101. ***************
  102. *** 7997,8002 ****
  103. --- 8012,8028 ----
  104.   }
  105.   
  106.   /*
  107. +  * Free a compiled regexp program, returned by vim_regcomp().
  108. +  */
  109. +     void
  110. + vim_regfree(prog)
  111. +     regprog_T   *prog;
  112. + {
  113. +     if (prog != NULL)
  114. +     prog->engine->regfree(prog);
  115. + }
  116. + 
  117. + /*
  118.    * Match a regexp against a string.
  119.    * "rmp->regprog" is a compiled regexp as returned by vim_regcomp().
  120.    * Uses curbuf for line count and 'iskeyword'.
  121. *** ../vim-7.3.1148/src/regexp.h    2013-06-07 16:31:45.000000000 +0200
  122. --- src/regexp.h    2013-06-08 15:43:33.000000000 +0200
  123. ***************
  124. *** 89,94 ****
  125. --- 89,95 ----
  126.   
  127.       int            reganch;    /* pattern starts with ^ */
  128.       int            regstart;    /* char at start of pattern */
  129. +     char_u        *match_text;    /* plain text to match with */
  130.   
  131.       int            has_zend;    /* pattern contains \ze */
  132.       int            has_backref;    /* pattern contains \1 .. \9 */
  133. ***************
  134. *** 147,152 ****
  135. --- 148,154 ----
  136.   struct regengine
  137.   {
  138.       regprog_T    *(*regcomp)(char_u*, int);
  139. +     void    (*regfree)(regprog_T *);
  140.       int        (*regexec)(regmatch_T*, char_u*, colnr_T);
  141.   #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
  142.       || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
  143. *** ../vim-7.3.1148/src/regexp_nfa.c    2013-06-08 14:38:23.000000000 +0200
  144. --- src/regexp_nfa.c    2013-06-08 18:04:40.000000000 +0200
  145. ***************
  146. *** 270,275 ****
  147. --- 270,276 ----
  148.   static int nfa_regcomp_start __ARGS((char_u *expr, int re_flags));
  149.   static int nfa_get_reganch __ARGS((nfa_state_T *start, int depth));
  150.   static int nfa_get_regstart __ARGS((nfa_state_T *start, int depth));
  151. + static char_u *nfa_get_match_text __ARGS((nfa_state_T *start));
  152.   static int nfa_recognize_char_class __ARGS((char_u *start, char_u *end, int extra_newl));
  153.   static int nfa_emit_equi_class __ARGS((int c));
  154.   static int nfa_regatom __ARGS((void));
  155. ***************
  156. *** 295,300 ****
  157. --- 296,302 ----
  158.   static long nfa_regtry __ARGS((nfa_regprog_T *prog, colnr_T col));
  159.   static long nfa_regexec_both __ARGS((char_u *line, colnr_T col));
  160.   static regprog_T *nfa_regcomp __ARGS((char_u *expr, int re_flags));
  161. + static void nfa_regfree __ARGS((regprog_T *prog));
  162.   static int nfa_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
  163.   static long nfa_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum, colnr_T col, proftime_T *tm));
  164.   
  165. ***************
  166. *** 493,498 ****
  167. --- 495,546 ----
  168.   }
  169.   
  170.   /*
  171. +  * Figure out if the NFA state list contains just literal text and nothing
  172. +  * else.  If so return a string with what must match after regstart.
  173. +  * Otherwise return NULL.
  174. +  */
  175. +     static char_u *
  176. + nfa_get_match_text(start)
  177. +     nfa_state_T *start;
  178. + {
  179. +     nfa_state_T *p = start;
  180. +     int        len = 0;
  181. +     char_u    *ret;
  182. +     char_u    *s;
  183. + 
  184. +     if (p->c != NFA_MOPEN)
  185. +     return NULL; /* just in case */
  186. +     p = p->out;
  187. +     while (p->c > 0)
  188. +     {
  189. +     len += MB_CHAR2LEN(p->c);
  190. +     p = p->out;
  191. +     }
  192. +     if (p->c != NFA_MCLOSE || p->out->c != NFA_MATCH)
  193. +     return NULL;
  194. + 
  195. +     ret = alloc(len);
  196. +     if (ret != NULL)
  197. +     {
  198. +     len = 0;
  199. +     p = start->out->out; /* skip first char, it goes into regstart */
  200. +     s = ret;
  201. +     while (p->c > 0)
  202. +     {
  203. + #ifdef FEAT_MBYTE
  204. +         if (has_mbyte)
  205. +         s += (*mb_char2bytes)(p->c, s);
  206. +         else
  207. + #endif
  208. +         *s++ = p->c;
  209. +         p = p->out;
  210. +     }
  211. +     *s = NUL;
  212. +     }
  213. +     return ret;
  214. + }
  215. + 
  216. + /*
  217.    * Allocate more space for post_start.  Called when
  218.    * running above the estimated number of states.
  219.    */
  220. ***************
  221. *** 2280,2287 ****
  222.       {
  223.       nfa_print_state(debugf, prog->start);
  224.   
  225. !     fprintf(debugf, "reganch: %d\n", prog->reganch);
  226. !     fprintf(debugf, "regstart: %d\n", prog->regstart);
  227.   
  228.       fclose(debugf);
  229.       }
  230. --- 2328,2340 ----
  231.       {
  232.       nfa_print_state(debugf, prog->start);
  233.   
  234. !     if (prog->reganch)
  235. !         fprintf(debugf, "reganch: %d\n", prog->reganch);
  236. !     if (prog->regstart != NUL)
  237. !         fprintf(debugf, "regstart: %c (decimal: %d)\n",
  238. !                           prog->regstart, prog->regstart);
  239. !     if (prog->match_text != NULL)
  240. !         fprintf(debugf, "match_text: \"%s\"\n", prog->match_text);
  241.   
  242.       fclose(debugf);
  243.       }
  244. ***************
  245. *** 4154,4159 ****
  246. --- 4207,4213 ----
  247.   
  248.   static int failure_chance __ARGS((nfa_state_T *state, int depth));
  249.   static int skip_to_start __ARGS((int c, colnr_T *colp));
  250. + static long find_match_text __ARGS((colnr_T startcol, int regstart, char_u *match_text));
  251.   
  252.   /*
  253.    * Estimate the chance of a match with "state" failing.
  254. ***************
  255. *** 4331,4336 ****
  256. --- 4385,4453 ----
  257.   }
  258.   
  259.   /*
  260. +  * Check for a match with match_text.
  261. +  * Called after skip_to_start() has find regstart.
  262. +  * Returns zero for no match, 1 for a match.
  263. +  */
  264. +     static long
  265. + find_match_text(startcol, regstart, match_text)
  266. +     colnr_T startcol;
  267. +     int        regstart;
  268. +     char_u  *match_text;
  269. + {
  270. +     colnr_T col = startcol;
  271. +     int        c1, c2;
  272. +     int        len1, len2;
  273. +     int        match;
  274. + 
  275. +     for (;;)
  276. +     {
  277. +     match = TRUE;
  278. +     len2 = MB_CHAR2LEN(regstart); /* skip regstart */
  279. +     for (len1 = 0; match_text[len1] != NUL; len1 += MB_CHAR2LEN(c1))
  280. +     {
  281. +         c1 = PTR2CHAR(match_text + len1);
  282. +         c2 = PTR2CHAR(regline + col + len2);
  283. +         if (c1 != c2 && (!ireg_ic || MB_TOLOWER(c1) != MB_TOLOWER(c2)))
  284. +         {
  285. +         match = FALSE;
  286. +         break;
  287. +         }
  288. +         len2 += MB_CHAR2LEN(c2);
  289. +     }
  290. +     if (match
  291. + #ifdef FEAT_MBYTE
  292. +         /* check that no composing char follows */
  293. +         && !(enc_utf8
  294. +                && utf_iscomposing(PTR2CHAR(regline + col + len2)))
  295. + #endif
  296. +         )
  297. +     {
  298. +         cleanup_subexpr();
  299. +         if (REG_MULTI)
  300. +         {
  301. +         reg_startpos[0].lnum = reglnum;
  302. +         reg_startpos[0].col = col;
  303. +         reg_endpos[0].lnum = reglnum;
  304. +         reg_endpos[0].col = col + len2;
  305. +         }
  306. +         else
  307. +         {
  308. +         reg_startp[0] = regline + col;
  309. +         reg_endp[0] = regline + col + len2;
  310. +         }
  311. +         return 1L;
  312. +     }
  313. + 
  314. +     /* Try finding regstart after the current match. */
  315. +     col += MB_CHAR2LEN(regstart); /* skip regstart */
  316. +     if (skip_to_start(regstart, &col) == FAIL)
  317. +         break;
  318. +     }
  319. +     return 0L;
  320. + }
  321. + 
  322. + /*
  323.    * Main matching routine.
  324.    *
  325.    * Run NFA to determine whether it matches reginput.
  326. ***************
  327. *** 5584,5600 ****
  328.   #endif
  329.   
  330.       reginput = regline + col;
  331. -     need_clear_subexpr = TRUE;
  332. - #ifdef FEAT_SYN_HL
  333. -     /* Clear the external match subpointers if necessary. */
  334. -     if (prog->reghasz == REX_SET)
  335. -     {
  336. -     nfa_has_zsubexpr = TRUE;
  337. -     need_clear_zsubexpr = TRUE;
  338. -     }
  339. -     else
  340. -     nfa_has_zsubexpr = FALSE;
  341. - #endif
  342.   
  343.   #ifdef ENABLE_LOG
  344.       f = fopen(NFA_REGEXP_RUN_LOG, "a");
  345. --- 5701,5706 ----
  346. ***************
  347. *** 5764,5775 ****
  348. --- 5870,5900 ----
  349.       if (prog->reganch && col > 0)
  350.       return 0L;
  351.   
  352. +     need_clear_subexpr = TRUE;
  353. + #ifdef FEAT_SYN_HL
  354. +     /* Clear the external match subpointers if necessary. */
  355. +     if (prog->reghasz == REX_SET)
  356. +     {
  357. +     nfa_has_zsubexpr = TRUE;
  358. +     need_clear_zsubexpr = TRUE;
  359. +     }
  360. +     else
  361. +     nfa_has_zsubexpr = FALSE;
  362. + #endif
  363. + 
  364.       if (prog->regstart != NUL)
  365. +     {
  366.       /* Skip ahead until a character we know the match must start with.
  367.        * When there is none there is no match. */
  368.       if (skip_to_start(prog->regstart, &col) == FAIL)
  369.           return 0L;
  370.   
  371. +     /* If match_text is set it contains the full text that must match.
  372. +      * Nothing else to try. Doesn't handle combining chars well. */
  373. +     if (prog->match_text != NULL && !ireg_icombine)
  374. +         return find_match_text(col, prog->regstart, prog->match_text);
  375. +     }
  376. + 
  377.       /* If the start column is past the maximum column: no need to try. */
  378.       if (ireg_maxcol > 0 && col >= ireg_maxcol)
  379.       goto theend;
  380. ***************
  381. *** 5876,5881 ****
  382. --- 6001,6008 ----
  383.       prog->reganch = nfa_get_reganch(prog->start, 0);
  384.       prog->regstart = nfa_get_regstart(prog->start, 0);
  385.   
  386. +     prog->match_text = nfa_get_match_text(prog->start);
  387. + 
  388.   #ifdef ENABLE_LOG
  389.       nfa_postfix_dump(expr, OK);
  390.       nfa_dump(prog);
  391. ***************
  392. *** 5885,5891 ****
  393.       prog->reghasz = re_has_z;
  394.   #endif
  395.   #ifdef DEBUG
  396. !     prog->pattern = vim_strsave(expr); /* memory will leak */
  397.       nfa_regengine.expr = NULL;
  398.   #endif
  399.   
  400. --- 6012,6018 ----
  401.       prog->reghasz = re_has_z;
  402.   #endif
  403.   #ifdef DEBUG
  404. !     prog->pattern = vim_strsave(expr);
  405.       nfa_regengine.expr = NULL;
  406.   #endif
  407.   
  408. ***************
  409. *** 5907,5912 ****
  410. --- 6034,6055 ----
  411.       goto out;
  412.   }
  413.   
  414. + /*
  415. +  * Free a compiled regexp program, returned by nfa_regcomp().
  416. +  */
  417. +     static void
  418. + nfa_regfree(prog)
  419. +     regprog_T   *prog;
  420. + {
  421. +     if (prog != NULL)
  422. +     {
  423. +     vim_free(((nfa_regprog_T *)prog)->match_text);
  424. + #ifdef DEBUG
  425. +     vim_free(((nfa_regprog_T *)prog)->pattern);
  426. + #endif
  427. +     vim_free(prog);
  428. +     }
  429. + }
  430.   
  431.   /*
  432.    * Match a regexp against a string.
  433. *** ../vim-7.3.1148/src/proto/regexp.pro    2010-08-15 21:57:28.000000000 +0200
  434. --- src/proto/regexp.pro    2013-06-08 15:41:49.000000000 +0200
  435. ***************
  436. *** 2,17 ****
  437.   int re_multiline __ARGS((regprog_T *prog));
  438.   int re_lookbehind __ARGS((regprog_T *prog));
  439.   char_u *skip_regexp __ARGS((char_u *startp, int dirc, int magic, char_u **newp));
  440. - regprog_T *vim_regcomp __ARGS((char_u *expr, int re_flags));
  441.   int vim_regcomp_had_eol __ARGS((void));
  442.   void free_regexp_stuff __ARGS((void));
  443. - int vim_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
  444. - int vim_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
  445. - long vim_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum, colnr_T col, proftime_T *tm));
  446.   reg_extmatch_T *ref_extmatch __ARGS((reg_extmatch_T *em));
  447.   void unref_extmatch __ARGS((reg_extmatch_T *em));
  448.   char_u *regtilde __ARGS((char_u *source, int magic));
  449.   int vim_regsub __ARGS((regmatch_T *rmp, char_u *source, char_u *dest, int copy, int magic, int backslash));
  450.   int vim_regsub_multi __ARGS((regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int copy, int magic, int backslash));
  451.   char_u *reg_submatch __ARGS((int no));
  452.   /* vim: set ft=c : */
  453. --- 2,18 ----
  454.   int re_multiline __ARGS((regprog_T *prog));
  455.   int re_lookbehind __ARGS((regprog_T *prog));
  456.   char_u *skip_regexp __ARGS((char_u *startp, int dirc, int magic, char_u **newp));
  457.   int vim_regcomp_had_eol __ARGS((void));
  458.   void free_regexp_stuff __ARGS((void));
  459.   reg_extmatch_T *ref_extmatch __ARGS((reg_extmatch_T *em));
  460.   void unref_extmatch __ARGS((reg_extmatch_T *em));
  461.   char_u *regtilde __ARGS((char_u *source, int magic));
  462.   int vim_regsub __ARGS((regmatch_T *rmp, char_u *source, char_u *dest, int copy, int magic, int backslash));
  463.   int vim_regsub_multi __ARGS((regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int copy, int magic, int backslash));
  464.   char_u *reg_submatch __ARGS((int no));
  465. + regprog_T *vim_regcomp __ARGS((char_u *expr_arg, int re_flags));
  466. + void vim_regfree __ARGS((regprog_T *prog));
  467. + int vim_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
  468. + int vim_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));
  469. + long vim_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum, colnr_T col, proftime_T *tm));
  470.   /* vim: set ft=c : */
  471. *** ../vim-7.3.1148/src/buffer.c    2013-06-07 20:17:06.000000000 +0200
  472. --- src/buffer.c    2013-06-08 16:06:38.000000000 +0200
  473. ***************
  474. *** 1898,1904 ****
  475.   #ifdef FEAT_SPELL
  476.       clear_string_option(&buf->b_s.b_p_spc);
  477.       clear_string_option(&buf->b_s.b_p_spf);
  478. !     vim_free(buf->b_s.b_cap_prog);
  479.       buf->b_s.b_cap_prog = NULL;
  480.       clear_string_option(&buf->b_s.b_p_spl);
  481.   #endif
  482. --- 1898,1904 ----
  483.   #ifdef FEAT_SPELL
  484.       clear_string_option(&buf->b_s.b_p_spc);
  485.       clear_string_option(&buf->b_s.b_p_spf);
  486. !     vim_regfree(buf->b_s.b_cap_prog);
  487.       buf->b_s.b_cap_prog = NULL;
  488.       clear_string_option(&buf->b_s.b_p_spl);
  489.   #endif
  490. ***************
  491. *** 2246,2252 ****
  492.               match = buf->b_fnum;    /* remember first match */
  493.               }
  494.   
  495. !         vim_free(prog);
  496.           if (match >= 0)            /* found one match */
  497.               break;
  498.           }
  499. --- 2246,2252 ----
  500.               match = buf->b_fnum;    /* remember first match */
  501.               }
  502.   
  503. !         vim_regfree(prog);
  504.           if (match >= 0)            /* found one match */
  505.               break;
  506.           }
  507. ***************
  508. *** 2355,2368 ****
  509.           *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
  510.           if (*file == NULL)
  511.           {
  512. !             vim_free(prog);
  513.               if (patc != pat)
  514.               vim_free(patc);
  515.               return FAIL;
  516.           }
  517.           }
  518.       }
  519. !     vim_free(prog);
  520.       if (count)        /* match(es) found, break here */
  521.           break;
  522.       }
  523. --- 2355,2368 ----
  524.           *file = (char_u **)alloc((unsigned)(count * sizeof(char_u *)));
  525.           if (*file == NULL)
  526.           {
  527. !             vim_regfree(prog);
  528.               if (patc != pat)
  529.               vim_free(patc);
  530.               return FAIL;
  531.           }
  532.           }
  533.       }
  534. !     vim_regfree(prog);
  535.       if (count)        /* match(es) found, break here */
  536.           break;
  537.       }
  538. *** ../vim-7.3.1148/src/edit.c    2013-05-19 21:15:08.000000000 +0200
  539. --- src/edit.c    2013-06-08 15:46:43.000000000 +0200
  540. ***************
  541. *** 3134,3140 ****
  542.   
  543.   theend:
  544.       p_scs = save_p_scs;
  545. !     vim_free(regmatch.regprog);
  546.       vim_free(buf);
  547.   }
  548.   
  549. --- 3134,3140 ----
  550.   
  551.   theend:
  552.       p_scs = save_p_scs;
  553. !     vim_regfree(regmatch.regprog);
  554.       vim_free(buf);
  555.   }
  556.   
  557. *** ../vim-7.3.1148/src/eval.c    2013-06-06 21:31:02.000000000 +0200
  558. --- src/eval.c    2013-06-08 15:48:23.000000000 +0200
  559. ***************
  560. *** 4560,4566 ****
  561.                   if (regmatch.regprog != NULL)
  562.                   {
  563.                   n1 = vim_regexec_nl(®match, s1, (colnr_T)0);
  564. !                 vim_free(regmatch.regprog);
  565.                   if (type == TYPE_NOMATCH)
  566.                       n1 = !n1;
  567.                   }
  568. --- 4560,4566 ----
  569.                   if (regmatch.regprog != NULL)
  570.                   {
  571.                   n1 = vim_regexec_nl(®match, s1, (colnr_T)0);
  572. !                 vim_regfree(regmatch.regprog);
  573.                   if (type == TYPE_NOMATCH)
  574.                       n1 = !n1;
  575.                   }
  576. ***************
  577. *** 13981,13987 ****
  578.           rettv->vval.v_number += (varnumber_T)(str - expr);
  579.           }
  580.       }
  581. !     vim_free(regmatch.regprog);
  582.       }
  583.   
  584.   theend:
  585. --- 13981,13987 ----
  586.           rettv->vval.v_number += (varnumber_T)(str - expr);
  587.           }
  588.       }
  589. !     vim_regfree(regmatch.regprog);
  590.       }
  591.   
  592.   theend:
  593. ***************
  594. *** 17214,17220 ****
  595.           str = regmatch.endp[0];
  596.       }
  597.   
  598. !     vim_free(regmatch.regprog);
  599.       }
  600.   
  601.       p_cpo = save_cpo;
  602. --- 17214,17220 ----
  603.           str = regmatch.endp[0];
  604.       }
  605.   
  606. !     vim_regfree(regmatch.regprog);
  607.       }
  608.   
  609.       p_cpo = save_cpo;
  610. ***************
  611. *** 21066,21072 ****
  612.                   list_func_head(fp, FALSE);
  613.               }
  614.           }
  615. !         vim_free(regmatch.regprog);
  616.           }
  617.       }
  618.       if (*p == '/')
  619. --- 21066,21072 ----
  620.                   list_func_head(fp, FALSE);
  621.               }
  622.           }
  623. !         vim_regfree(regmatch.regprog);
  624.           }
  625.       }
  626.       if (*p == '/')
  627. ***************
  628. *** 24220,24226 ****
  629.       if (ga.ga_data != NULL)
  630.           STRCPY((char *)ga.ga_data + ga.ga_len, tail);
  631.   
  632. !     vim_free(regmatch.regprog);
  633.       }
  634.   
  635.       ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data);
  636. --- 24220,24226 ----
  637.       if (ga.ga_data != NULL)
  638.           STRCPY((char *)ga.ga_data + ga.ga_len, tail);
  639.   
  640. !     vim_regfree(regmatch.regprog);
  641.       }
  642.   
  643.       ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data);
  644. *** ../vim-7.3.1148/src/ex_cmds.c    2013-05-30 11:43:11.000000000 +0200
  645. --- src/ex_cmds.c    2013-06-08 16:07:02.000000000 +0200
  646. ***************
  647. *** 571,577 ****
  648.       vim_free(nrs);
  649.       vim_free(sortbuf1);
  650.       vim_free(sortbuf2);
  651. !     vim_free(regmatch.regprog);
  652.       if (got_int)
  653.       EMSG(_(e_interr));
  654.   }
  655. --- 571,577 ----
  656.       vim_free(nrs);
  657.       vim_free(sortbuf1);
  658.       vim_free(sortbuf2);
  659. !     vim_regfree(regmatch.regprog);
  660.       if (got_int)
  661.       EMSG(_(e_interr));
  662.   }
  663. ***************
  664. *** 5261,5267 ****
  665.       changed_window_setting();
  666.   #endif
  667.   
  668. !     vim_free(regmatch.regprog);
  669.   }
  670.   
  671.   /*
  672. --- 5261,5267 ----
  673.       changed_window_setting();
  674.   #endif
  675.   
  676. !     vim_regfree(regmatch.regprog);
  677.   }
  678.   
  679.   /*
  680. ***************
  681. *** 5436,5442 ****
  682.       global_exe(cmd);
  683.   
  684.       ml_clearmarked();       /* clear rest of the marks */
  685. !     vim_free(regmatch.regprog);
  686.   }
  687.   
  688.   /*
  689. --- 5436,5442 ----
  690.       global_exe(cmd);
  691.   
  692.       ml_clearmarked();       /* clear rest of the marks */
  693. !     vim_regfree(regmatch.regprog);
  694.   }
  695.   
  696.   /*
  697. *** ../vim-7.3.1148/src/ex_cmds2.c    2013-06-06 14:01:35.000000000 +0200
  698. --- src/ex_cmds2.c    2013-06-08 15:49:57.000000000 +0200
  699. ***************
  700. *** 652,658 ****
  701.       while (gap->ga_len > 0)
  702.       {
  703.           vim_free(DEBUGGY(gap, todel).dbg_name);
  704. !         vim_free(DEBUGGY(gap, todel).dbg_prog);
  705.           --gap->ga_len;
  706.           if (todel < gap->ga_len)
  707.           mch_memmove(&DEBUGGY(gap, todel), &DEBUGGY(gap, todel + 1),
  708. --- 652,658 ----
  709.       while (gap->ga_len > 0)
  710.       {
  711.           vim_free(DEBUGGY(gap, todel).dbg_name);
  712. !         vim_regfree(DEBUGGY(gap, todel).dbg_prog);
  713.           --gap->ga_len;
  714.           if (todel < gap->ga_len)
  715.           mch_memmove(&DEBUGGY(gap, todel), &DEBUGGY(gap, todel + 1),
  716. ***************
  717. *** 1985,1991 ****
  718.               --match;
  719.           }
  720.   
  721. !         vim_free(regmatch.regprog);
  722.           vim_free(p);
  723.           if (!didone)
  724.           EMSG2(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
  725. --- 1985,1991 ----
  726.               --match;
  727.           }
  728.   
  729. !         vim_regfree(regmatch.regprog);
  730.           vim_free(p);
  731.           if (!didone)
  732.           EMSG2(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
  733. *** ../vim-7.3.1148/src/ex_docmd.c    2013-06-08 15:24:41.000000000 +0200
  734. --- src/ex_docmd.c    2013-06-08 15:50:07.000000000 +0200
  735. ***************
  736. *** 7779,7785 ****
  737.           curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
  738.           else
  739.           EMSG(_(e_nomatch));
  740. !         vim_free(regmatch.regprog);
  741.       }
  742.       /* Move to the NUL, ignore any other arguments. */
  743.       eap->arg += STRLEN(eap->arg);
  744. --- 7779,7785 ----
  745.           curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
  746.           else
  747.           EMSG(_(e_nomatch));
  748. !         vim_regfree(regmatch.regprog);
  749.       }
  750.       /* Move to the NUL, ignore any other arguments. */
  751.       eap->arg += STRLEN(eap->arg);
  752. *** ../vim-7.3.1148/src/ex_eval.c    2013-05-06 04:21:35.000000000 +0200
  753. --- src/ex_eval.c    2013-06-08 15:50:28.000000000 +0200
  754. ***************
  755. *** 1576,1582 ****
  756.               caught = vim_regexec_nl(®match, current_exception->value,
  757.                   (colnr_T)0);
  758.               got_int |= prev_got_int;
  759. !             vim_free(regmatch.regprog);
  760.           }
  761.           }
  762.       }
  763. --- 1576,1582 ----
  764.               caught = vim_regexec_nl(®match, current_exception->value,
  765.                   (colnr_T)0);
  766.               got_int |= prev_got_int;
  767. !             vim_regfree(regmatch.regprog);
  768.           }
  769.           }
  770.       }
  771. *** ../vim-7.3.1148/src/ex_getln.c    2013-06-08 15:24:41.000000000 +0200
  772. --- src/ex_getln.c    2013-06-08 15:51:13.000000000 +0200
  773. ***************
  774. *** 4717,4723 ****
  775.           }
  776.       }
  777.   
  778. !     vim_free(regmatch.regprog);
  779.   
  780.       return ret;
  781.   #endif /* FEAT_CMDL_COMPL */
  782. --- 4717,4723 ----
  783.           }
  784.       }
  785.   
  786. !     vim_regfree(regmatch.regprog);
  787.   
  788.       return ret;
  789.   #endif /* FEAT_CMDL_COMPL */
  790. ***************
  791. *** 5785,5791 ****
  792.       if (history[histype][idx].hisstr == NULL)
  793.           hisidx[histype] = -1;
  794.       }
  795. !     vim_free(regmatch.regprog);
  796.       return found;
  797.   }
  798.   
  799. --- 5785,5791 ----
  800.       if (history[histype][idx].hisstr == NULL)
  801.           hisidx[histype] = -1;
  802.       }
  803. !     vim_regfree(regmatch.regprog);
  804.       return found;
  805.   }
  806.   
  807. *** ../vim-7.3.1148/src/fileio.c    2013-05-06 04:50:26.000000000 +0200
  808. --- src/fileio.c    2013-06-08 15:52:10.000000000 +0200
  809. ***************
  810. *** 7921,7927 ****
  811.           if (ap->pat == NULL)
  812.           {
  813.           *prev_ap = ap->next;
  814. !         vim_free(ap->reg_prog);
  815.           vim_free(ap);
  816.           }
  817.           else
  818. --- 7921,7927 ----
  819.           if (ap->pat == NULL)
  820.           {
  821.           *prev_ap = ap->next;
  822. !         vim_regfree(ap->reg_prog);
  823.           vim_free(ap);
  824.           }
  825.           else
  826. ***************
  827. *** 10070,10076 ****
  828.       result = TRUE;
  829.   
  830.       if (prog == NULL)
  831. !     vim_free(regmatch.regprog);
  832.       return result;
  833.   }
  834.   #endif
  835. --- 10070,10076 ----
  836.       result = TRUE;
  837.   
  838.       if (prog == NULL)
  839. !     vim_regfree(regmatch.regprog);
  840.       return result;
  841.   }
  842.   #endif
  843. *** ../vim-7.3.1148/src/gui.c    2013-05-06 04:21:35.000000000 +0200
  844. --- src/gui.c    2013-06-08 15:52:24.000000000 +0200
  845. ***************
  846. *** 5319,5325 ****
  847.           }
  848.           else
  849.           MSG(_("No match at cursor, finding next"));
  850. !         vim_free(regmatch.regprog);
  851.       }
  852.       }
  853.   
  854. --- 5319,5325 ----
  855.           }
  856.           else
  857.           MSG(_("No match at cursor, finding next"));
  858. !         vim_regfree(regmatch.regprog);
  859.       }
  860.       }
  861.   
  862. *** ../vim-7.3.1148/src/misc1.c    2013-06-05 19:35:31.000000000 +0200
  863. --- src/misc1.c    2013-06-08 15:53:36.000000000 +0200
  864. ***************
  865. *** 456,463 ****
  866.           pos.coladd = 0;
  867.   #endif
  868.       }
  869.       }
  870. -     vim_free(regmatch.regprog);
  871.   
  872.       if (pos.lnum == 0 || *ml_get_pos(&pos) == NUL)
  873.       return -1;
  874. --- 456,463 ----
  875.           pos.coladd = 0;
  876.   #endif
  877.       }
  878. +     vim_regfree(regmatch.regprog);
  879.       }
  880.   
  881.       if (pos.lnum == 0 || *ml_get_pos(&pos) == NUL)
  882.       return -1;
  883. ***************
  884. *** 9751,9757 ****
  885.   # endif
  886.   #endif
  887.       vim_free(buf);
  888. !     vim_free(regmatch.regprog);
  889.       vim_free(matchname);
  890.   
  891.       matches = gap->ga_len - start_len;
  892. --- 9751,9757 ----
  893.   # endif
  894.   #endif
  895.       vim_free(buf);
  896. !     vim_regfree(regmatch.regprog);
  897.       vim_free(matchname);
  898.   
  899.       matches = gap->ga_len - start_len;
  900. ***************
  901. *** 9993,9999 ****
  902.       }
  903.   
  904.       vim_free(buf);
  905. !     vim_free(regmatch.regprog);
  906.   
  907.       matches = gap->ga_len - start_len;
  908.       if (matches > 0)
  909. --- 9993,9999 ----
  910.       }
  911.   
  912.       vim_free(buf);
  913. !     vim_regfree(regmatch.regprog);
  914.   
  915.       matches = gap->ga_len - start_len;
  916.       if (matches > 0)
  917. ***************
  918. *** 10358,10364 ****
  919.       vim_free(in_curdir);
  920.       }
  921.       ga_clear_strings(&path_ga);
  922. !     vim_free(regmatch.regprog);
  923.   
  924.       if (sort_again)
  925.       remove_duplicates(gap);
  926. --- 10358,10364 ----
  927.       vim_free(in_curdir);
  928.       }
  929.       ga_clear_strings(&path_ga);
  930. !     vim_regfree(regmatch.regprog);
  931.   
  932.       if (sort_again)
  933.       remove_duplicates(gap);
  934. *** ../vim-7.3.1148/src/misc2.c    2013-05-06 04:21:35.000000000 +0200
  935. --- src/misc2.c    2013-06-08 16:07:33.000000000 +0200
  936. ***************
  937. *** 1134,1140 ****
  938.       /* Free some global vars. */
  939.       vim_free(username);
  940.   # ifdef FEAT_CLIPBOARD
  941. !     vim_free(clip_exclude_prog);
  942.   # endif
  943.       vim_free(last_cmdline);
  944.   # ifdef FEAT_CMDHIST
  945. --- 1134,1140 ----
  946.       /* Free some global vars. */
  947.       vim_free(username);
  948.   # ifdef FEAT_CLIPBOARD
  949. !     vim_regfree(clip_exclude_prog);
  950.   # endif
  951.       vim_free(last_cmdline);
  952.   # ifdef FEAT_CMDHIST
  953. ***************
  954. *** 5008,5015 ****
  955.   #endif
  956.           {
  957.               /*
  958. !              * we don't have further wildcards to expand, so we have to
  959. !              * check for the final file now
  960.                */
  961.               for (i = stackp->ffs_filearray_cur;
  962.                         i < stackp->ffs_filearray_size; ++i)
  963. --- 5008,5015 ----
  964.   #endif
  965.           {
  966.               /*
  967. !              * We don't have further wildcards to expand, so we have to
  968. !              * check for the final file now.
  969.                */
  970.               for (i = stackp->ffs_filearray_cur;
  971.                         i < stackp->ffs_filearray_size; ++i)
  972. *** ../vim-7.3.1148/src/option.c    2013-06-04 22:13:45.000000000 +0200
  973. --- src/option.c    2013-06-08 16:30:58.000000000 +0200
  974. ***************
  975. *** 7491,7497 ****
  976.       clip_autoselect_plus = new_autoselect_plus;
  977.       clip_autoselectml = new_autoselectml;
  978.       clip_html = new_html;
  979. !     vim_free(clip_exclude_prog);
  980.       clip_exclude_prog = new_exclude_prog;
  981.   #ifdef FEAT_GUI_GTK
  982.       if (gui.in_use)
  983. --- 7491,7497 ----
  984.       clip_autoselect_plus = new_autoselect_plus;
  985.       clip_autoselectml = new_autoselectml;
  986.       clip_html = new_html;
  987. !     vim_regfree(clip_exclude_prog);
  988.       clip_exclude_prog = new_exclude_prog;
  989.   #ifdef FEAT_GUI_GTK
  990.       if (gui.in_use)
  991. ***************
  992. *** 7502,7508 ****
  993.   #endif
  994.       }
  995.       else
  996. !     vim_free(new_exclude_prog);
  997.   
  998.       return errmsg;
  999.   }
  1000. --- 7502,7508 ----
  1001.   #endif
  1002.       }
  1003.       else
  1004. !     vim_regfree(new_exclude_prog);
  1005.   
  1006.       return errmsg;
  1007.   }
  1008. ***************
  1009. *** 7529,7544 ****
  1010.       if (re != NULL)
  1011.       {
  1012.           synblock->b_cap_prog = vim_regcomp(re, RE_MAGIC);
  1013.           if (synblock->b_cap_prog == NULL)
  1014.           {
  1015.           synblock->b_cap_prog = rp; /* restore the previous program */
  1016.           return e_invarg;
  1017.           }
  1018. -         vim_free(re);
  1019.       }
  1020.       }
  1021.   
  1022. !     vim_free(rp);
  1023.       return NULL;
  1024.   }
  1025.   #endif
  1026. --- 7529,7544 ----
  1027.       if (re != NULL)
  1028.       {
  1029.           synblock->b_cap_prog = vim_regcomp(re, RE_MAGIC);
  1030. +         vim_free(re);
  1031.           if (synblock->b_cap_prog == NULL)
  1032.           {
  1033.           synblock->b_cap_prog = rp; /* restore the previous program */
  1034.           return e_invarg;
  1035.           }
  1036.       }
  1037.       }
  1038.   
  1039. !     vim_regfree(rp);
  1040.       return NULL;
  1041.   }
  1042.   #endif
  1043. *** ../vim-7.3.1148/src/syntax.c    2013-06-08 15:24:41.000000000 +0200
  1044. --- src/syntax.c    2013-06-08 16:10:08.000000000 +0200
  1045. ***************
  1046. *** 3495,3501 ****
  1047.       block->b_syn_sync_maxlines = 0;
  1048.       block->b_syn_sync_linebreaks = 0;
  1049.   
  1050. !     vim_free(block->b_syn_linecont_prog);
  1051.       block->b_syn_linecont_prog = NULL;
  1052.       vim_free(block->b_syn_linecont_pat);
  1053.       block->b_syn_linecont_pat = NULL;
  1054. --- 3495,3501 ----
  1055.       block->b_syn_sync_maxlines = 0;
  1056.       block->b_syn_sync_linebreaks = 0;
  1057.   
  1058. !     vim_regfree(block->b_syn_linecont_prog);
  1059.       block->b_syn_linecont_prog = NULL;
  1060.       vim_free(block->b_syn_linecont_pat);
  1061.       block->b_syn_linecont_pat = NULL;
  1062. ***************
  1063. *** 3544,3550 ****
  1064.       curwin->w_s->b_syn_sync_maxlines = 0;
  1065.       curwin->w_s->b_syn_sync_linebreaks = 0;
  1066.   
  1067. !     vim_free(curwin->w_s->b_syn_linecont_prog);
  1068.       curwin->w_s->b_syn_linecont_prog = NULL;
  1069.       vim_free(curwin->w_s->b_syn_linecont_pat);
  1070.       curwin->w_s->b_syn_linecont_pat = NULL;
  1071. --- 3544,3550 ----
  1072.       curwin->w_s->b_syn_sync_maxlines = 0;
  1073.       curwin->w_s->b_syn_sync_linebreaks = 0;
  1074.   
  1075. !     vim_regfree(curwin->w_s->b_syn_linecont_prog);
  1076.       curwin->w_s->b_syn_linecont_prog = NULL;
  1077.       vim_free(curwin->w_s->b_syn_linecont_pat);
  1078.       curwin->w_s->b_syn_linecont_pat = NULL;
  1079. ***************
  1080. *** 3583,3589 ****
  1081.       int        i;
  1082.   {
  1083.       vim_free(SYN_ITEMS(block)[i].sp_pattern);
  1084. !     vim_free(SYN_ITEMS(block)[i].sp_prog);
  1085.       /* Only free sp_cont_list and sp_next_list of first start pattern */
  1086.       if (i == 0 || SYN_ITEMS(block)[i - 1].sp_type != SPTYPE_START)
  1087.       {
  1088. --- 3583,3589 ----
  1089.       int        i;
  1090.   {
  1091.       vim_free(SYN_ITEMS(block)[i].sp_pattern);
  1092. !     vim_regfree(SYN_ITEMS(block)[i].sp_prog);
  1093.       /* Only free sp_cont_list and sp_next_list of first start pattern */
  1094.       if (i == 0 || SYN_ITEMS(block)[i - 1].sp_type != SPTYPE_START)
  1095.       {
  1096. ***************
  1097. *** 4991,4997 ****
  1098.       /*
  1099.        * Something failed, free the allocated memory.
  1100.        */
  1101. !     vim_free(item.sp_prog);
  1102.       vim_free(item.sp_pattern);
  1103.       vim_free(syn_opt_arg.cont_list);
  1104.       vim_free(syn_opt_arg.cont_in_list);
  1105. --- 4991,4997 ----
  1106.       /*
  1107.        * Something failed, free the allocated memory.
  1108.        */
  1109. !     vim_regfree(item.sp_prog);
  1110.       vim_free(item.sp_pattern);
  1111.       vim_free(syn_opt_arg.cont_list);
  1112.       vim_free(syn_opt_arg.cont_in_list);
  1113. ***************
  1114. *** 5248,5254 ****
  1115.       {
  1116.           if (!success)
  1117.           {
  1118. !         vim_free(ppp->pp_synp->sp_prog);
  1119.           vim_free(ppp->pp_synp->sp_pattern);
  1120.           }
  1121.           vim_free(ppp->pp_synp);
  1122. --- 5248,5254 ----
  1123.       {
  1124.           if (!success)
  1125.           {
  1126. !         vim_regfree(ppp->pp_synp->sp_prog);
  1127.           vim_free(ppp->pp_synp->sp_pattern);
  1128.           }
  1129.           vim_free(ppp->pp_synp);
  1130. ***************
  1131. *** 6022,6028 ****
  1132.                   id = -1;        /* remember that we found one */
  1133.               }
  1134.               }
  1135. !             vim_free(regmatch.regprog);
  1136.           }
  1137.           }
  1138.           vim_free(name);
  1139. --- 6022,6028 ----
  1140.                   id = -1;        /* remember that we found one */
  1141.               }
  1142.               }
  1143. !             vim_regfree(regmatch.regprog);
  1144.           }
  1145.           }
  1146.           vim_free(name);
  1147. ***************
  1148. *** 6295,6301 ****
  1149.       curwin->w_p_spell = FALSE;    /* No spell checking */
  1150.       clear_string_option(&curwin->w_s->b_p_spc);
  1151.       clear_string_option(&curwin->w_s->b_p_spf);
  1152. !     vim_free(curwin->w_s->b_cap_prog);
  1153.       curwin->w_s->b_cap_prog = NULL;
  1154.       clear_string_option(&curwin->w_s->b_p_spl);
  1155.   #endif
  1156. --- 6295,6301 ----
  1157.       curwin->w_p_spell = FALSE;    /* No spell checking */
  1158.       clear_string_option(&curwin->w_s->b_p_spc);
  1159.       clear_string_option(&curwin->w_s->b_p_spf);
  1160. !     vim_regfree(curwin->w_s->b_cap_prog);
  1161.       curwin->w_s->b_cap_prog = NULL;
  1162.       clear_string_option(&curwin->w_s->b_p_spl);
  1163.   #endif
  1164. *** ../vim-7.3.1148/src/quickfix.c    2013-05-11 15:50:02.000000000 +0200
  1165. --- src/quickfix.c    2013-06-08 15:57:08.000000000 +0200
  1166. ***************
  1167. *** 863,869 ****
  1168.       for (fmt_ptr = fmt_first; fmt_ptr != NULL; fmt_ptr = fmt_first)
  1169.       {
  1170.       fmt_first = fmt_ptr->next;
  1171. !     vim_free(fmt_ptr->prog);
  1172.       vim_free(fmt_ptr);
  1173.       }
  1174.       qf_clean_dir_stack(&dir_stack);
  1175. --- 863,869 ----
  1176.       for (fmt_ptr = fmt_first; fmt_ptr != NULL; fmt_ptr = fmt_first)
  1177.       {
  1178.       fmt_first = fmt_ptr->next;
  1179. !     vim_regfree(fmt_ptr->prog);
  1180.       vim_free(fmt_ptr);
  1181.       }
  1182.       qf_clean_dir_stack(&dir_stack);
  1183. ***************
  1184. *** 3487,3493 ****
  1185.       vim_free(dirname_now);
  1186.       vim_free(dirname_start);
  1187.       vim_free(target_dir);
  1188. !     vim_free(regmatch.regprog);
  1189.   }
  1190.   
  1191.   /*
  1192. --- 3487,3493 ----
  1193.       vim_free(dirname_now);
  1194.       vim_free(dirname_start);
  1195.       vim_free(target_dir);
  1196. !     vim_regfree(regmatch.regprog);
  1197.   }
  1198.   
  1199.   /*
  1200. ***************
  1201. *** 4178,4184 ****
  1202.           }
  1203.       }
  1204.   
  1205. !     vim_free(regmatch.regprog);
  1206.   #ifdef FEAT_MBYTE
  1207.       if (vc.vc_type != CONV_NONE)
  1208.           convert_setup(&vc, NULL, NULL);
  1209. --- 4178,4184 ----
  1210.           }
  1211.       }
  1212.   
  1213. !     vim_regfree(regmatch.regprog);
  1214.   #ifdef FEAT_MBYTE
  1215.       if (vc.vc_type != CONV_NONE)
  1216.           convert_setup(&vc, NULL, NULL);
  1217. *** ../vim-7.3.1148/src/search.c    2013-05-06 04:21:35.000000000 +0200
  1218. --- src/search.c    2013-06-08 15:59:38.000000000 +0200
  1219. ***************
  1220. *** 972,978 ****
  1221.       }
  1222.       while (--count > 0 && found);   /* stop after count matches or no match */
  1223.   
  1224. !     vim_free(regmatch.regprog);
  1225.   
  1226.       called_emsg |= save_called_emsg;
  1227.   
  1228. --- 972,978 ----
  1229.       }
  1230.       while (--count > 0 && found);   /* stop after count matches or no match */
  1231.   
  1232. !     vim_regfree(regmatch.regprog);
  1233.   
  1234.       called_emsg |= save_called_emsg;
  1235.   
  1236. ***************
  1237. *** 4680,4686 ****
  1238.       }
  1239.   
  1240.       called_emsg |= save_called_emsg;
  1241. !     vim_free(regmatch.regprog);
  1242.       return result;
  1243.   }
  1244.   #endif /* FEAT_VISUAL */
  1245. --- 4680,4686 ----
  1246.       }
  1247.   
  1248.       called_emsg |= save_called_emsg;
  1249. !     vim_regfree(regmatch.regprog);
  1250.       return result;
  1251.   }
  1252.   #endif /* FEAT_VISUAL */
  1253. ***************
  1254. *** 5402,5410 ****
  1255.   
  1256.   fpip_end:
  1257.       vim_free(file_line);
  1258. !     vim_free(regmatch.regprog);
  1259. !     vim_free(incl_regmatch.regprog);
  1260. !     vim_free(def_regmatch.regprog);
  1261.   }
  1262.   
  1263.       static void
  1264. --- 5402,5410 ----
  1265.   
  1266.   fpip_end:
  1267.       vim_free(file_line);
  1268. !     vim_regfree(regmatch.regprog);
  1269. !     vim_regfree(incl_regmatch.regprog);
  1270. !     vim_regfree(def_regmatch.regprog);
  1271.   }
  1272.   
  1273.       static void
  1274. *** ../vim-7.3.1148/src/spell.c    2013-05-06 04:21:35.000000000 +0200
  1275. --- src/spell.c    2013-06-08 16:10:52.000000000 +0200
  1276. ***************
  1277. *** 2658,2664 ****
  1278.       ga_clear(gap);
  1279.   
  1280.       for (i = 0; i < lp->sl_prefixcnt; ++i)
  1281. !     vim_free(lp->sl_prefprog[i]);
  1282.       lp->sl_prefixcnt = 0;
  1283.       vim_free(lp->sl_prefprog);
  1284.       lp->sl_prefprog = NULL;
  1285. --- 2658,2664 ----
  1286.       ga_clear(gap);
  1287.   
  1288.       for (i = 0; i < lp->sl_prefixcnt; ++i)
  1289. !     vim_regfree(lp->sl_prefprog[i]);
  1290.       lp->sl_prefixcnt = 0;
  1291.       vim_free(lp->sl_prefprog);
  1292.       lp->sl_prefprog = NULL;
  1293. ***************
  1294. *** 2669,2675 ****
  1295.       vim_free(lp->sl_midword);
  1296.       lp->sl_midword = NULL;
  1297.   
  1298. !     vim_free(lp->sl_compprog);
  1299.       vim_free(lp->sl_comprules);
  1300.       vim_free(lp->sl_compstartflags);
  1301.       vim_free(lp->sl_compallflags);
  1302. --- 2669,2675 ----
  1303.       vim_free(lp->sl_midword);
  1304.       lp->sl_midword = NULL;
  1305.   
  1306. !     vim_regfree(lp->sl_compprog);
  1307.       vim_free(lp->sl_comprules);
  1308.       vim_free(lp->sl_compstartflags);
  1309.       vim_free(lp->sl_compallflags);
  1310. ***************
  1311. *** 5802,5808 ****
  1312.                       {
  1313.                           sprintf((char *)buf, "^%s",
  1314.                                 aff_entry->ae_cond);
  1315. !                         vim_free(aff_entry->ae_prog);
  1316.                           aff_entry->ae_prog = vim_regcomp(
  1317.                               buf, RE_MAGIC + RE_STRING);
  1318.                       }
  1319. --- 5802,5808 ----
  1320.                       {
  1321.                           sprintf((char *)buf, "^%s",
  1322.                                 aff_entry->ae_cond);
  1323. !                         vim_regfree(aff_entry->ae_prog);
  1324.                           aff_entry->ae_prog = vim_regcomp(
  1325.                               buf, RE_MAGIC + RE_STRING);
  1326.                       }
  1327. ***************
  1328. *** 6507,6513 ****
  1329.           --todo;
  1330.           ah = HI2AH(hi);
  1331.           for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next)
  1332. !             vim_free(ae->ae_prog);
  1333.           }
  1334.       }
  1335.       if (ht == &aff->af_suff)
  1336. --- 6507,6513 ----
  1337.           --todo;
  1338.           ah = HI2AH(hi);
  1339.           for (ae = ah->ah_first; ae != NULL; ae = ae->ae_next)
  1340. !             vim_regfree(ae->ae_prog);
  1341.           }
  1342.       }
  1343.       if (ht == &aff->af_suff)
  1344. *** ../vim-7.3.1148/src/tag.c    2012-09-12 18:19:39.000000000 +0200
  1345. --- src/tag.c    2013-06-08 16:03:31.000000000 +0200
  1346. ***************
  1347. *** 2491,2497 ****
  1348.   
  1349.   findtag_end:
  1350.       vim_free(lbuf);
  1351. !     vim_free(orgpat.regmatch.regprog);
  1352.       vim_free(tag_fname);
  1353.   #ifdef FEAT_EMACS_TAGS
  1354.       vim_free(ebuf);
  1355. --- 2491,2497 ----
  1356.   
  1357.   findtag_end:
  1358.       vim_free(lbuf);
  1359. !     vim_regfree(orgpat.regmatch.regprog);
  1360.       vim_free(tag_fname);
  1361.   #ifdef FEAT_EMACS_TAGS
  1362.       vim_free(ebuf);
  1363. *** ../vim-7.3.1148/src/window.c    2013-05-18 20:55:31.000000000 +0200
  1364. --- src/window.c    2013-06-08 16:03:54.000000000 +0200
  1365. ***************
  1366. *** 6818,6824 ****
  1367.       wp->w_match_head = cur->next;
  1368.       else
  1369.       prev->next = cur->next;
  1370. !     vim_free(cur->match.regprog);
  1371.       vim_free(cur->pattern);
  1372.       vim_free(cur);
  1373.       redraw_later(SOME_VALID);
  1374. --- 6818,6824 ----
  1375.       wp->w_match_head = cur->next;
  1376.       else
  1377.       prev->next = cur->next;
  1378. !     vim_regfree(cur->match.regprog);
  1379.       vim_free(cur->pattern);
  1380.       vim_free(cur);
  1381.       redraw_later(SOME_VALID);
  1382. ***************
  1383. *** 6837,6843 ****
  1384.       while (wp->w_match_head != NULL)
  1385.       {
  1386.       m = wp->w_match_head->next;
  1387. !     vim_free(wp->w_match_head->match.regprog);
  1388.       vim_free(wp->w_match_head->pattern);
  1389.       vim_free(wp->w_match_head);
  1390.       wp->w_match_head = m;
  1391. --- 6837,6843 ----
  1392.       while (wp->w_match_head != NULL)
  1393.       {
  1394.       m = wp->w_match_head->next;
  1395. !     vim_regfree(wp->w_match_head->match.regprog);
  1396.       vim_free(wp->w_match_head->pattern);
  1397.       vim_free(wp->w_match_head);
  1398.       wp->w_match_head = m;
  1399. *** ../vim-7.3.1148/src/screen.c    2013-06-07 20:17:06.000000000 +0200
  1400. --- src/screen.c    2013-06-08 16:09:18.000000000 +0200
  1401. ***************
  1402. *** 7082,7088 ****
  1403.   {
  1404.       if (search_hl.rm.regprog != NULL)
  1405.       {
  1406. !     vim_free(search_hl.rm.regprog);
  1407.       search_hl.rm.regprog = NULL;
  1408.       }
  1409.   }
  1410. --- 7082,7088 ----
  1411.   {
  1412.       if (search_hl.rm.regprog != NULL)
  1413.       {
  1414. !     vim_regfree(search_hl.rm.regprog);
  1415.       search_hl.rm.regprog = NULL;
  1416.       }
  1417.   }
  1418. ***************
  1419. *** 7284,7290 ****
  1420.           if (shl == &search_hl)
  1421.           {
  1422.           /* don't free regprog in the match list, it's a copy */
  1423. !         vim_free(shl->rm.regprog);
  1424.           no_hlsearch = TRUE;
  1425.           }
  1426.           shl->rm.regprog = NULL;
  1427. --- 7284,7290 ----
  1428.           if (shl == &search_hl)
  1429.           {
  1430.           /* don't free regprog in the match list, it's a copy */
  1431. !         vim_regfree(shl->rm.regprog);
  1432.           no_hlsearch = TRUE;
  1433.           }
  1434.           shl->rm.regprog = NULL;
  1435. *** ../vim-7.3.1148/src/macros.h    2012-07-19 17:18:21.000000000 +0200
  1436. --- src/macros.h    2013-06-08 16:53:34.000000000 +0200
  1437. ***************
  1438. *** 272,277 ****
  1439. --- 272,278 ----
  1440.   
  1441.   # define MB_COPY_CHAR(f, t) if (has_mbyte) mb_copy_char(&f, &t); else *t++ = *f++
  1442.   # define MB_CHARLEN(p)        (has_mbyte ? mb_charlen(p) : (int)STRLEN(p))
  1443. + # define MB_CHAR2LEN(c)        (has_mbyte ? mb_char2len(c) : 1)
  1444.   # define PTR2CHAR(p)        (has_mbyte ? mb_ptr2char(p) : (int)*(p))
  1445.   #else
  1446.   # define MB_PTR2LEN(p)        1
  1447. ***************
  1448. *** 280,285 ****
  1449. --- 281,287 ----
  1450.   # define mb_ptr_back(s, p)    --p
  1451.   # define MB_COPY_CHAR(f, t)    *t++ = *f++
  1452.   # define MB_CHARLEN(p)        STRLEN(p)
  1453. + # define MB_CHAR2LEN(c)        1
  1454.   # define PTR2CHAR(p)        ((int)*(p))
  1455.   #endif
  1456.   
  1457. *** ../vim-7.3.1148/src/testdir/test64.in    2013-06-05 18:52:36.000000000 +0200
  1458. --- src/testdir/test64.in    2013-06-08 13:05:08.000000000 +0200
  1459. ***************
  1460. *** 260,265 ****
  1461. --- 260,267 ----
  1462.   :call add(tl, [2, '[^[:alpha:]]\+','abcccadfoij7787ysf287yrnccdu','7787'])
  1463.   :call add(tl, [2, '[-a]', '-', '-'])
  1464.   :call add(tl, [2, '[a-]', '-', '-'])
  1465. + :call add(tl, [2, '[a-f]*\c','ABCDEFGH','ABCDEF'])
  1466. + :call add(tl, [2, '[abc][xyz]\c','-af-AF-BY--','BY'])
  1467.   :" filename regexp
  1468.   :call add(tl, [2, '[-./[:alnum:]_~]\+', 'log13.file', 'log13.file'])
  1469.   :" special chars
  1470. ***************
  1471. *** 385,390 ****
  1472. --- 387,398 ----
  1473.   :call add(tl, [2, '\(<<\)\@2<=span.', 'xxspanxxxx<spanxx<<spanyyy', 'spany', '<<'])
  1474.   :call add(tl, [2, '\(foo\)\@<!bar.', 'xx foobar1 xbar2 xx', 'bar2'])
  1475.   :"
  1476. + :" look-behind match in front of a zero-width item
  1477. + :call add(tl, [2, '\v\C%(<Last Changed:\s+)@<=.*$', '" test header'])
  1478. + :call add(tl, [2, '\v\C%(<Last Changed:\s+)@<=.*$', '" Last Changed: 1970', '1970'])
  1479. + :call add(tl, [2, '\(foo\)\@<=\>', 'foobar'])
  1480. + :call add(tl, [2, '\(foo\)\@<=\>', 'barfoo', '', 'foo'])
  1481. + :"
  1482.   :""""" \@>
  1483.   :call add(tl, [2, '\(a*\)\@>a', 'aaaa'])
  1484.   :call add(tl, [2, '\(a*\)\@>b', 'aaab', 'aaab', 'aaa'])
  1485. *** ../vim-7.3.1148/src/testdir/test64.ok    2013-06-05 18:52:36.000000000 +0200
  1486. --- src/testdir/test64.ok    2013-06-08 13:16:59.000000000 +0200
  1487. ***************
  1488. *** 584,589 ****
  1489. --- 584,595 ----
  1490.   OK 0 - [a-]
  1491.   OK 1 - [a-]
  1492.   OK 2 - [a-]
  1493. + OK 0 - [a-f]*\c
  1494. + OK 1 - [a-f]*\c
  1495. + OK 2 - [a-f]*\c
  1496. + OK 0 - [abc][xyz]\c
  1497. + OK 1 - [abc][xyz]\c
  1498. + OK 2 - [abc][xyz]\c
  1499.   OK 0 - [-./[:alnum:]_~]\+
  1500.   OK 1 - [-./[:alnum:]_~]\+
  1501.   OK 2 - [-./[:alnum:]_~]\+
  1502. ***************
  1503. *** 872,877 ****
  1504. --- 878,895 ----
  1505.   OK 0 - \(foo\)\@<!bar.
  1506.   OK 1 - \(foo\)\@<!bar.
  1507.   OK 2 - \(foo\)\@<!bar.
  1508. + OK 0 - \v\C%(<Last Changed:\s+)@<=.*$
  1509. + OK 1 - \v\C%(<Last Changed:\s+)@<=.*$
  1510. + OK 2 - \v\C%(<Last Changed:\s+)@<=.*$
  1511. + OK 0 - \v\C%(<Last Changed:\s+)@<=.*$
  1512. + OK 1 - \v\C%(<Last Changed:\s+)@<=.*$
  1513. + OK 2 - \v\C%(<Last Changed:\s+)@<=.*$
  1514. + OK 0 - \(foo\)\@<=\>
  1515. + OK 1 - \(foo\)\@<=\>
  1516. + OK 2 - \(foo\)\@<=\>
  1517. + OK 0 - \(foo\)\@<=\>
  1518. + OK 1 - \(foo\)\@<=\>
  1519. + OK 2 - \(foo\)\@<=\>
  1520.   OK 0 - \(a*\)\@>a
  1521.   OK 1 - \(a*\)\@>a
  1522.   OK 2 - \(a*\)\@>a
  1523. *** ../vim-7.3.1148/src/version.c    2013-06-08 15:24:41.000000000 +0200
  1524. --- src/version.c    2013-06-08 18:09:41.000000000 +0200
  1525. ***************
  1526. *** 730,731 ****
  1527. --- 730,733 ----
  1528.   {   /* Add new patch number below this line */
  1529. + /**/
  1530. +     1149,
  1531.   /**/
  1532.  
  1533. -- 
  1534. FIXME and XXX are two common keywords used to mark broken or incomplete code
  1535. not only since XXX as a sex reference would grab everybody's attention but
  1536. simply due to the fact that Vim would highlight these words.
  1537.                     -- Hendrik Scholz
  1538.  
  1539.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  1540. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  1541. \\\  an exciting new programming language -- http://www.Zimbu.org        ///
  1542.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  1543.