rpms/vim
5
0
Fork 0
Code Issues Pull Requests Releases Activity

- patchlevel 1105

Browse Source
This commit is contained in:
Karsten Hopp 2013-06-04 12:06:58 +02:00
parent a42e099a75
commit f59ea23d81
1 changed files with 433 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

433
7.3.1105 Normal file
View File

@ -0,0 +1,433 @@
To: vim_dev@googlegroups.com
Subject: Patch 7.3.1105
Fcc: outbox
From: Bram Moolenaar <Bram@moolenaar.net>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
------------
Patch 7.3.1105
Problem: New regexp engine: too much code in one function. Dead code.
Solution: Move the recursive nfa_regmatch call to a separate function.
Remove the dead code.
Files: src/regexp_nfa.c
*** ../vim-7.3.1104/src/regexp_nfa.c 2013-06-02 22:07:57.000000000 +0200
--- src/regexp_nfa.c 2013-06-02 22:35:43.000000000 +0200
***************
*** 3665,3673 ****
--- 3665,3802 ----
return val == pos;
}
+ static int recursive_regmatch __ARGS((nfa_state_T *state, nfa_regprog_T *prog, regsubs_T *submatch, regsubs_T *m, int **listids));
static int nfa_regmatch __ARGS((nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *submatch, regsubs_T *m));
/*
+ * Recursively call nfa_regmatch()
+ */
+ static int
+ recursive_regmatch(state, prog, submatch, m, listids)
+ nfa_state_T *state;
+ nfa_regprog_T *prog;
+ regsubs_T *submatch;
+ regsubs_T *m;
+ int **listids;
+ {
+ char_u *save_reginput = reginput;
+ char_u *save_regline = regline;
+ int save_reglnum = reglnum;
+ int save_nfa_match = nfa_match;
+ save_se_T *save_nfa_endp = nfa_endp;
+ save_se_T endpos;
+ save_se_T *endposp = NULL;
+ int result;
+
+ if (state->c == NFA_START_INVISIBLE_BEFORE)
+ {
+ /* The recursive match must end at the current position. */
+ endposp = &endpos;
+ if (REG_MULTI)
+ {
+ endpos.se_u.pos.col = (int)(reginput - regline);
+ endpos.se_u.pos.lnum = reglnum;
+ }
+ else
+ endpos.se_u.ptr = reginput;
+
+ /* Go back the specified number of bytes, or as far as the
+ * start of the previous line, to try matching "\@<=" or
+ * not matching "\@<!".
+ * TODO: This is very inefficient! Would be better to
+ * first check for a match with what follows. */
+ if (state->val <= 0)
+ {
+ if (REG_MULTI)
+ {
+ regline = reg_getline(--reglnum);
+ if (regline == NULL)
+ /* can't go before the first line */
+ regline = reg_getline(++reglnum);
+ }
+ reginput = regline;
+ }
+ else
+ {
+ if (REG_MULTI && (int)(reginput - regline) < state->val)
+ {
+ /* Not enough bytes in this line, go to end of
+ * previous line. */
+ regline = reg_getline(--reglnum);
+ if (regline == NULL)
+ {
+ /* can't go before the first line */
+ regline = reg_getline(++reglnum);
+ reginput = regline;
+ }
+ else
+ reginput = regline + STRLEN(regline);
+ }
+ if ((int)(reginput - regline) >= state->val)
+ {
+ reginput -= state->val;
+ #ifdef FEAT_MBYTE
+ if (has_mbyte)
+ reginput -= mb_head_off(regline, reginput);
+ #endif
+ }
+ else
+ reginput = regline;
+ }
+ }
+
+ /* Call nfa_regmatch() to check if the current concat matches
+ * at this position. The concat ends with the node
+ * NFA_END_INVISIBLE */
+ if (*listids == NULL)
+ {
+ *listids = (int *)lalloc(sizeof(int) * nstate, TRUE);
+ if (*listids == NULL)
+ {
+ EMSG(_("E878: (NFA) Could not allocate memory for branch traversal!"));
+ return 0;
+ }
+ }
+ #ifdef ENABLE_LOG
+ if (log_fd != stderr)
+ fclose(log_fd);
+ log_fd = NULL;
+ #endif
+ /* Have to clear the listid field of the NFA nodes, so that
+ * nfa_regmatch() and addstate() can run properly after
+ * recursion. */
+ nfa_save_listids(prog, *listids);
+ nfa_endp = endposp;
+ result = nfa_regmatch(prog, state->out, submatch, m);
+ nfa_restore_listids(prog, *listids);
+
+ /* restore position in input text */
+ reginput = save_reginput;
+ regline = save_regline;
+ reglnum = save_reglnum;
+ nfa_match = save_nfa_match;
+ nfa_endp = save_nfa_endp;
+
+ #ifdef ENABLE_LOG
+ log_fd = fopen(NFA_REGEXP_RUN_LOG, "a");
+ if (log_fd != NULL)
+ {
+ fprintf(log_fd, "****************************\n");
+ fprintf(log_fd, "FINISHED RUNNING nfa_regmatch() recursively\n");
+ fprintf(log_fd, "MATCH = %s\n", result == TRUE ? "OK" : "FALSE");
+ fprintf(log_fd, "****************************\n");
+ }
+ else
+ {
+ EMSG(_("Could not open temporary log file for writing, displaying on stderr ... "));
+ log_fd = stderr;
+ }
+ #endif
+
+ return result;
+ }
+
+ /*
* Main matching routine.
*
* Run NFA to determine whether it matches reginput.
***************
*** 3881,4051 ****
}
case NFA_END_INVISIBLE:
! /* This is only encountered after a NFA_START_INVISIBLE or
* NFA_START_INVISIBLE_BEFORE node.
* They surround a zero-width group, used with "\@=", "\&",
* "\@!", "\@<=" and "\@<!".
* If we got here, it means that the current "invisible" group
* finished successfully, so return control to the parent
! * nfa_regmatch(). Submatches are stored in *m, and used in
! * the parent call. */
! if (start->c == NFA_MOPEN)
! /* TODO: do we ever get here? */
! addstate_here(thislist, t->state->out, &t->subs, &listidx);
! else
! {
#ifdef ENABLE_LOG
! if (nfa_endp != NULL)
! {
! if (REG_MULTI)
! fprintf(log_fd, "Current lnum: %d, endp lnum: %d; current col: %d, endp col: %d\n",
! (int)reglnum,
! (int)nfa_endp->se_u.pos.lnum,
! (int)(reginput - regline),
! nfa_endp->se_u.pos.col);
! else
! fprintf(log_fd, "Current col: %d, endp col: %d\n",
! (int)(reginput - regline),
! (int)(nfa_endp->se_u.ptr - reginput));
! }
! #endif
! /* It's only a match if it ends at "nfa_endp" */
! if (nfa_endp != NULL && (REG_MULTI
! ? (reglnum != nfa_endp->se_u.pos.lnum
! || (int)(reginput - regline)
! != nfa_endp->se_u.pos.col)
! : reginput != nfa_endp->se_u.ptr))
! break;
!
! /* do not set submatches for \@! */
! if (!t->state->negated)
! {
! copy_sub(&m->norm, &t->subs.norm);
! #ifdef FEAT_SYN_HL
! if (nfa_has_zsubexpr)
! copy_sub(&m->synt, &t->subs.synt);
! #endif
! }
! nfa_match = TRUE;
! }
! break;
!
! case NFA_START_INVISIBLE:
! case NFA_START_INVISIBLE_BEFORE:
! {
! char_u *save_reginput = reginput;
! char_u *save_regline = regline;
! int save_reglnum = reglnum;
! int save_nfa_match = nfa_match;
! save_se_T *save_nfa_endp = nfa_endp;
! save_se_T endpos;
! save_se_T *endposp = NULL;
!
! if (t->state->c == NFA_START_INVISIBLE_BEFORE)
{
- /* The recursive match must end at the current position. */
- endposp = &endpos;
if (REG_MULTI)
! {
! endpos.se_u.pos.col = (int)(reginput - regline);
! endpos.se_u.pos.lnum = reglnum;
! }
else
! endpos.se_u.ptr = reginput;
!
! /* Go back the specified number of bytes, or as far as the
! * start of the previous line, to try matching "\@<=" or
! * not matching "\@<!".
! * TODO: This is very inefficient! Would be better to
! * first check for a match with what follows. */
! if (t->state->val <= 0)
! {
! if (REG_MULTI)
! {
! regline = reg_getline(--reglnum);
! if (regline == NULL)
! /* can't go before the first line */
! regline = reg_getline(++reglnum);
! }
! reginput = regline;
! }
! else
! {
! if (REG_MULTI
! && (int)(reginput - regline) < t->state->val)
! {
! /* Not enough bytes in this line, go to end of
! * previous line. */
! regline = reg_getline(--reglnum);
! if (regline == NULL)
! {
! /* can't go before the first line */
! regline = reg_getline(++reglnum);
! reginput = regline;
! }
! else
! reginput = regline + STRLEN(regline);
! }
! if ((int)(reginput - regline) >= t->state->val)
! {
! reginput -= t->state->val;
! #ifdef FEAT_MBYTE
! if (has_mbyte)
! reginput -= mb_head_off(regline, reginput);
! #endif
! }
! else
! reginput = regline;
! }
}
! /* Call nfa_regmatch() to check if the current concat matches
! * at this position. The concat ends with the node
! * NFA_END_INVISIBLE */
! if (listids == NULL)
{
! listids = (int *)lalloc(sizeof(int) * nstate, TRUE);
! if (listids == NULL)
! {
! EMSG(_("E878: (NFA) Could not allocate memory for branch traversal!"));
! return 0;
! }
}
! #ifdef ENABLE_LOG
! if (log_fd != stderr)
! fclose(log_fd);
! log_fd = NULL;
! #endif
! /* Have to clear the listid field of the NFA nodes, so that
! * nfa_regmatch() and addstate() can run properly after
! * recursion. */
! nfa_save_listids(prog, listids);
! nfa_endp = endposp;
! result = nfa_regmatch(prog, t->state->out, submatch, m);
! nfa_restore_listids(prog, listids);
!
! /* restore position in input text */
! reginput = save_reginput;
! regline = save_regline;
! reglnum = save_reglnum;
! nfa_match = save_nfa_match;
! nfa_endp = save_nfa_endp;
- #ifdef ENABLE_LOG
- log_fd = fopen(NFA_REGEXP_RUN_LOG, "a");
- if (log_fd != NULL)
- {
- fprintf(log_fd, "****************************\n");
- fprintf(log_fd, "FINISHED RUNNING nfa_regmatch() recursively\n");
- fprintf(log_fd, "MATCH = %s\n", result == TRUE ? "OK" : "FALSE");
- fprintf(log_fd, "****************************\n");
- }
- else
- {
- EMSG(_("Could not open temporary log file for writing, displaying on stderr ... "));
- log_fd = stderr;
- }
- #endif
/* for \@! it is a match when result is FALSE */
if (result != t->state->negated)
{
--- 4010,4066 ----
}
case NFA_END_INVISIBLE:
! /*
! * This is only encountered after a NFA_START_INVISIBLE or
* NFA_START_INVISIBLE_BEFORE node.
* They surround a zero-width group, used with "\@=", "\&",
* "\@!", "\@<=" and "\@<!".
* If we got here, it means that the current "invisible" group
* finished successfully, so return control to the parent
! * nfa_regmatch(). For a look-behind match only when it ends
! * in the position in "nfa_endp".
! * Submatches are stored in *m, and used in the parent call.
! */
#ifdef ENABLE_LOG
! if (nfa_endp != NULL)
{
if (REG_MULTI)
! fprintf(log_fd, "Current lnum: %d, endp lnum: %d; current col: %d, endp col: %d\n",
! (int)reglnum,
! (int)nfa_endp->se_u.pos.lnum,
! (int)(reginput - regline),
! nfa_endp->se_u.pos.col);
else
! fprintf(log_fd, "Current col: %d, endp col: %d\n",
! (int)(reginput - regline),
! (int)(nfa_endp->se_u.ptr - reginput));
}
+ #endif
+ /* It's only a match if it ends at "nfa_endp" */
+ if (nfa_endp != NULL && (REG_MULTI
+ ? (reglnum != nfa_endp->se_u.pos.lnum
+ || (int)(reginput - regline)
+ != nfa_endp->se_u.pos.col)
+ : reginput != nfa_endp->se_u.ptr))
+ break;
! /* do not set submatches for \@! */
! if (!t->state->negated)
{
! copy_sub(&m->norm, &t->subs.norm);
! #ifdef FEAT_SYN_HL
! if (nfa_has_zsubexpr)
! copy_sub(&m->synt, &t->subs.synt);
! #endif
}
! nfa_match = TRUE;
! break;
!
! case NFA_START_INVISIBLE:
! case NFA_START_INVISIBLE_BEFORE:
! result = recursive_regmatch(t->state, prog, submatch, m,
! &listids);
/* for \@! it is a match when result is FALSE */
if (result != t->state->negated)
{
***************
*** 4056,4067 ****
#endif
/* t->state->out1 is the corresponding END_INVISIBLE node;
! * Add it to the current list (zero-width match). */
addstate_here(thislist, t->state->out1->out, &t->subs,
&listidx);
}
break;
- }
case NFA_BOL:
if (reginput == regline)
--- 4071,4081 ----
#endif
/* t->state->out1 is the corresponding END_INVISIBLE node;
! * Add its out to the current list (zero-width match). */
addstate_here(thislist, t->state->out1->out, &t->subs,
&listidx);
}
break;
case NFA_BOL:
if (reginput == regline)
*** ../vim-7.3.1104/src/version.c 2013-06-02 22:07:57.000000000 +0200
--- src/version.c 2013-06-02 22:37:02.000000000 +0200
***************
*** 730,731 ****
--- 730,733 ----
{ /* Add new patch number below this line */
+ /**/
+ 1105,
/**/
--
"I can't complain, but sometimes I still do." (Joe Walsh)
/// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\ an exciting new programming language -- http://www.Zimbu.org ///
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///