| To: vim_dev@googlegroups.com |
| Subject: Patch 7.3.1022 |
| 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.1022 |
| Problem: Compiler warning for shadowed variable. (John Little) |
| Solution: Move declaration, rename variables. |
| Files: src/regexp_nfa.c |
| |
| |
| |
| |
| |
| *** 604,610 **** |
| char_u *endp; |
| #ifdef FEAT_MBYTE |
| char_u *old_regparse = regparse; |
| - int i; |
| #endif |
| int extra = 0; |
| int first; |
| --- 604,609 ---- |
| |
| *** 827,850 **** |
| case 'u': /* %uabcd hex 4 */ |
| case 'U': /* %U1234abcd hex 8 */ |
| { |
| ! int i; |
| |
| switch (c) |
| { |
| ! case 'd': i = getdecchrs(); break; |
| ! case 'o': i = getoctchrs(); break; |
| ! case 'x': i = gethexchrs(2); break; |
| ! case 'u': i = gethexchrs(4); break; |
| ! case 'U': i = gethexchrs(8); break; |
| ! default: i = -1; break; |
| } |
| |
| ! if (i < 0) |
| EMSG2_RET_FAIL( |
| _("E678: Invalid character after %s%%[dxouU]"), |
| reg_magic == MAGIC_ALL); |
| /* TODO: what if a composing character follows? */ |
| ! EMIT(i); |
| } |
| break; |
| |
| --- 826,849 ---- |
| case 'u': /* %uabcd hex 4 */ |
| case 'U': /* %U1234abcd hex 8 */ |
| { |
| ! int nr; |
| |
| switch (c) |
| { |
| ! case 'd': nr = getdecchrs(); break; |
| ! case 'o': nr = getoctchrs(); break; |
| ! case 'x': nr = gethexchrs(2); break; |
| ! case 'u': nr = gethexchrs(4); break; |
| ! case 'U': nr = gethexchrs(8); break; |
| ! default: nr = -1; break; |
| } |
| |
| ! if (nr < 0) |
| EMSG2_RET_FAIL( |
| _("E678: Invalid character after %s%%[dxouU]"), |
| reg_magic == MAGIC_ALL); |
| /* TODO: what if a composing character follows? */ |
| ! EMIT(nr); |
| } |
| break; |
| |
| |
| *** 1229,1234 **** |
| --- 1228,1235 ---- |
| != (plen = (*mb_ptr2len)(old_regparse)) |
| || utf_iscomposing(c))) |
| { |
| + int i = 0; |
| + |
| /* A base character plus composing characters, or just one |
| * or more composing characters. |
| * This requires creating a separate atom as if enclosing |
| |
| *** 1237,1243 **** |
| * building the postfix form, not the NFA itself; |
| * a composing char could be: a, b, c, NFA_COMPOSING |
| * where 'b' and 'c' are chars with codes > 256. */ |
| - i = 0; |
| for (;;) |
| { |
| EMIT(c); |
| --- 1238,1243 ---- |
| |
| *** 2923,2931 **** |
| regsub_T *submatch; |
| regsub_T *m; |
| { |
| - int c; |
| - int n; |
| - int i = 0; |
| int result; |
| int size = 0; |
| int match = FALSE; |
| --- 2923,2928 ---- |
| |
| *** 2939,2944 **** |
| --- 2936,2942 ---- |
| nfa_list_T *listtbl[2][2]; |
| nfa_list_T *ll; |
| int listid = 1; |
| + int listidx; |
| nfa_list_T *thislist; |
| nfa_list_T *nextlist; |
| nfa_list_T *neglist; |
| |
| *** 3004,3010 **** |
| #define ADD_POS_NEG_STATE(node) \ |
| ll = listtbl[result ? 1 : 0][node->negated]; \ |
| if (ll != NULL) \ |
| ! addstate(ll, node->out , &t->sub, n, listid + 1, &match); |
| |
| |
| /* |
| --- 3002,3008 ---- |
| #define ADD_POS_NEG_STATE(node) \ |
| ll = listtbl[result ? 1 : 0][node->negated]; \ |
| if (ll != NULL) \ |
| ! addstate(ll, node->out , &t->sub, clen, listid + 1, &match); |
| |
| |
| /* |
| |
| *** 3012,3032 **** |
| */ |
| for (;;) |
| { |
| #ifdef FEAT_MBYTE |
| if (has_mbyte) |
| { |
| ! c = (*mb_ptr2char)(reginput); |
| ! n = (*mb_ptr2len)(reginput); |
| } |
| else |
| #endif |
| { |
| ! c = *reginput; |
| ! n = 1; |
| } |
| ! if (c == NUL) |
| { |
| ! n = 0; |
| go_to_nextline = FALSE; |
| } |
| |
| --- 3010,3033 ---- |
| */ |
| for (;;) |
| { |
| + int curc; |
| + int clen; |
| + |
| #ifdef FEAT_MBYTE |
| if (has_mbyte) |
| { |
| ! curc = (*mb_ptr2char)(reginput); |
| ! clen = (*mb_ptr2len)(reginput); |
| } |
| else |
| #endif |
| { |
| ! curc = *reginput; |
| ! clen = 1; |
| } |
| ! if (curc == NUL) |
| { |
| ! clen = 0; |
| go_to_nextline = FALSE; |
| } |
| |
| |
| *** 3040,3049 **** |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, "------------------------------------------\n"); |
| fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput); |
| ! fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", c, (int)c); |
| fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n); |
| ! for (i = 0; i < thislist->n; i++) |
| ! fprintf(log_fd, "%d ", abs(thislist->t[i].state->id)); |
| fprintf(log_fd, "\n"); |
| #endif |
| |
| --- 3041,3054 ---- |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, "------------------------------------------\n"); |
| fprintf(log_fd, ">>> Reginput is \"%s\"\n", reginput); |
| ! fprintf(log_fd, ">>> Advanced one character ... Current char is %c (code %d) \n", curc, (int)curc); |
| fprintf(log_fd, ">>> Thislist has %d states available: ", thislist->n); |
| ! { |
| ! int i; |
| ! |
| ! for (i = 0; i < thislist->n; i++) |
| ! fprintf(log_fd, "%d ", abs(thislist->t[i].state->id)); |
| ! } |
| fprintf(log_fd, "\n"); |
| #endif |
| |
| |
| *** 3057,3072 **** |
| break; |
| |
| /* compute nextlist */ |
| ! for (i = 0; i < thislist->n || neglist->n > 0; ++i) |
| { |
| if (neglist->n > 0) |
| { |
| t = &neglist->t[0]; |
| neglist->n--; |
| ! i--; |
| } |
| else |
| ! t = &thislist->t[i]; |
| |
| #ifdef NFA_REGEXP_DEBUG_LOG |
| nfa_set_code(t->state->c); |
| --- 3062,3077 ---- |
| break; |
| |
| /* compute nextlist */ |
| ! for (listidx = 0; listidx < thislist->n || neglist->n > 0; ++listidx) |
| { |
| if (neglist->n > 0) |
| { |
| t = &neglist->t[0]; |
| neglist->n--; |
| ! listidx--; |
| } |
| else |
| ! t = &thislist->t[listidx]; |
| |
| #ifdef NFA_REGEXP_DEBUG_LOG |
| nfa_set_code(t->state->c); |
| |
| *** 3116,3122 **** |
| * the parent call. */ |
| if (start->c == NFA_MOPEN + 0) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &i); |
| else |
| { |
| *m = t->sub; |
| --- 3121,3127 ---- |
| * the parent call. */ |
| if (start->c == NFA_MOPEN + 0) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &listidx); |
| else |
| { |
| *m = t->sub; |
| |
| *** 3190,3196 **** |
| } |
| /* t->state->out1 is the corresponding END_INVISIBLE node */ |
| addstate_here(thislist, t->state->out1->out, &t->sub, |
| ! listid, &match, &i); |
| } |
| else |
| { |
| --- 3195,3201 ---- |
| } |
| /* t->state->out1 is the corresponding END_INVISIBLE node */ |
| addstate_here(thislist, t->state->out1->out, &t->sub, |
| ! listid, &match, &listidx); |
| } |
| else |
| { |
| |
| *** 3202,3221 **** |
| case NFA_BOL: |
| if (reginput == regline) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &i); |
| break; |
| |
| case NFA_EOL: |
| ! if (c == NUL) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &i); |
| break; |
| |
| case NFA_BOW: |
| { |
| int bow = TRUE; |
| |
| ! if (c == NUL) |
| bow = FALSE; |
| #ifdef FEAT_MBYTE |
| else if (has_mbyte) |
| --- 3207,3226 ---- |
| case NFA_BOL: |
| if (reginput == regline) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &listidx); |
| break; |
| |
| case NFA_EOL: |
| ! if (curc == NUL) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &listidx); |
| break; |
| |
| case NFA_BOW: |
| { |
| int bow = TRUE; |
| |
| ! if (curc == NUL) |
| bow = FALSE; |
| #ifdef FEAT_MBYTE |
| else if (has_mbyte) |
| |
| *** 3230,3242 **** |
| bow = FALSE; |
| } |
| #endif |
| ! else if (!vim_iswordc_buf(c, reg_buf) |
| || (reginput > regline |
| && vim_iswordc_buf(reginput[-1], reg_buf))) |
| bow = FALSE; |
| if (bow) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &i); |
| break; |
| } |
| |
| --- 3235,3247 ---- |
| bow = FALSE; |
| } |
| #endif |
| ! else if (!vim_iswordc_buf(curc, reg_buf) |
| || (reginput > regline |
| && vim_iswordc_buf(reginput[-1], reg_buf))) |
| bow = FALSE; |
| if (bow) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &listidx); |
| break; |
| } |
| |
| |
| *** 3260,3277 **** |
| } |
| #endif |
| else if (!vim_iswordc_buf(reginput[-1], reg_buf) |
| ! || (reginput[0] != NUL && vim_iswordc_buf(c, reg_buf))) |
| eow = FALSE; |
| if (eow) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &i); |
| break; |
| } |
| |
| #ifdef FEAT_MBYTE |
| case NFA_COMPOSING: |
| { |
| ! int mc = c; |
| int len = 0; |
| nfa_state_T *end; |
| nfa_state_T *sta; |
| --- 3265,3283 ---- |
| } |
| #endif |
| else if (!vim_iswordc_buf(reginput[-1], reg_buf) |
| ! || (reginput[0] != NUL |
| ! && vim_iswordc_buf(curc, reg_buf))) |
| eow = FALSE; |
| if (eow) |
| addstate_here(thislist, t->state->out, &t->sub, listid, |
| ! &match, &listidx); |
| break; |
| } |
| |
| #ifdef FEAT_MBYTE |
| case NFA_COMPOSING: |
| { |
| ! int mc = curc; |
| int len = 0; |
| nfa_state_T *end; |
| nfa_state_T *sta; |
| |
| *** 3286,3299 **** |
| /* Only match composing character(s), ignore base |
| * character. Used for ".{composing}" and "{composing}" |
| * (no preceding character). */ |
| ! len += mb_char2len(c); |
| } |
| if (ireg_icombine) |
| { |
| /* If \Z was present, then ignore composing characters. |
| * When ignoring the base character this always matches. */ |
| /* TODO: How about negated? */ |
| ! if (len == 0 && sta->c != c) |
| result = FAIL; |
| else |
| result = OK; |
| --- 3292,3305 ---- |
| /* Only match composing character(s), ignore base |
| * character. Used for ".{composing}" and "{composing}" |
| * (no preceding character). */ |
| ! len += mb_char2len(mc); |
| } |
| if (ireg_icombine) |
| { |
| /* If \Z was present, then ignore composing characters. |
| * When ignoring the base character this always matches. */ |
| /* TODO: How about negated? */ |
| ! if (len == 0 && sta->c != curc) |
| result = FAIL; |
| else |
| result = OK; |
| |
| *** 3312,3318 **** |
| |
| /* We don't care about the order of composing characters. |
| * Get them into cchars[] first. */ |
| ! while (len < n) |
| { |
| mc = mb_ptr2char(reginput + len); |
| cchars[ccount++] = mc; |
| --- 3318,3324 ---- |
| |
| /* We don't care about the order of composing characters. |
| * Get them into cchars[] first. */ |
| ! while (len < clen) |
| { |
| mc = mb_ptr2char(reginput + len); |
| cchars[ccount++] = mc; |
| |
| *** 3349,3355 **** |
| |
| case NFA_NEWL: |
| if (!reg_line_lbr && REG_MULTI |
| ! && c == NUL && reglnum <= reg_maxline) |
| { |
| go_to_nextline = TRUE; |
| /* Pass -1 for the offset, which means taking the position |
| --- 3355,3361 ---- |
| |
| case NFA_NEWL: |
| if (!reg_line_lbr && REG_MULTI |
| ! && curc == NUL && reglnum <= reg_maxline) |
| { |
| go_to_nextline = TRUE; |
| /* Pass -1 for the offset, which means taking the position |
| |
| *** 3375,3409 **** |
| case NFA_CLASS_RETURN: |
| case NFA_CLASS_BACKSPACE: |
| case NFA_CLASS_ESCAPE: |
| ! result = check_char_class(t->state->c, c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_END_NEG_RANGE: |
| /* This follows a series of negated nodes, like: |
| * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */ |
| ! if (c > 0) |
| ! addstate(nextlist, t->state->out, &t->sub, n, listid + 1, |
| ! &match); |
| break; |
| |
| case NFA_ANY: |
| /* Any char except '\0', (end of input) does not match. */ |
| ! if (c > 0) |
| ! addstate(nextlist, t->state->out, &t->sub, n, listid + 1, |
| ! &match); |
| break; |
| |
| /* |
| * Character classes like \a for alpha, \d for digit etc. |
| */ |
| case NFA_IDENT: /* \i */ |
| ! result = vim_isIDc(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_SIDENT: /* \I */ |
| ! result = !VIM_ISDIGIT(c) && vim_isIDc(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| --- 3381,3415 ---- |
| case NFA_CLASS_RETURN: |
| case NFA_CLASS_BACKSPACE: |
| case NFA_CLASS_ESCAPE: |
| ! result = check_char_class(t->state->c, curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_END_NEG_RANGE: |
| /* This follows a series of negated nodes, like: |
| * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */ |
| ! if (curc > 0) |
| ! addstate(nextlist, t->state->out, &t->sub, clen, |
| ! listid + 1, &match); |
| break; |
| |
| case NFA_ANY: |
| /* Any char except '\0', (end of input) does not match. */ |
| ! if (curc > 0) |
| ! addstate(nextlist, t->state->out, &t->sub, clen, |
| ! listid + 1, &match); |
| break; |
| |
| /* |
| * Character classes like \a for alpha, \d for digit etc. |
| */ |
| case NFA_IDENT: /* \i */ |
| ! result = vim_isIDc(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_SIDENT: /* \I */ |
| ! result = !VIM_ISDIGIT(curc) && vim_isIDc(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| |
| *** 3413,3429 **** |
| break; |
| |
| case NFA_SKWORD: /* \K */ |
| ! result = !VIM_ISDIGIT(c) && vim_iswordp_buf(reginput, reg_buf); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_FNAME: /* \f */ |
| ! result = vim_isfilec(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_SFNAME: /* \F */ |
| ! result = !VIM_ISDIGIT(c) && vim_isfilec(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| --- 3419,3436 ---- |
| break; |
| |
| case NFA_SKWORD: /* \K */ |
| ! result = !VIM_ISDIGIT(curc) |
| ! && vim_iswordp_buf(reginput, reg_buf); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_FNAME: /* \f */ |
| ! result = vim_isfilec(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_SFNAME: /* \F */ |
| ! result = !VIM_ISDIGIT(curc) && vim_isfilec(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| |
| *** 3433,3529 **** |
| break; |
| |
| case NFA_SPRINT: /* \P */ |
| ! result = !VIM_ISDIGIT(c) && ptr2cells(reginput) == 1; |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_WHITE: /* \s */ |
| ! result = vim_iswhite(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NWHITE: /* \S */ |
| ! result = c != NUL && !vim_iswhite(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_DIGIT: /* \d */ |
| ! result = ri_digit(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NDIGIT: /* \D */ |
| ! result = c != NUL && !ri_digit(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_HEX: /* \x */ |
| ! result = ri_hex(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NHEX: /* \X */ |
| ! result = c != NUL && !ri_hex(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_OCTAL: /* \o */ |
| ! result = ri_octal(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NOCTAL: /* \O */ |
| ! result = c != NUL && !ri_octal(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_WORD: /* \w */ |
| ! result = ri_word(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NWORD: /* \W */ |
| ! result = c != NUL && !ri_word(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_HEAD: /* \h */ |
| ! result = ri_head(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NHEAD: /* \H */ |
| ! result = c != NUL && !ri_head(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_ALPHA: /* \a */ |
| ! result = ri_alpha(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NALPHA: /* \A */ |
| ! result = c != NUL && !ri_alpha(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_LOWER: /* \l */ |
| ! result = ri_lower(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NLOWER: /* \L */ |
| ! result = c != NUL && !ri_lower(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_UPPER: /* \u */ |
| ! result = ri_upper(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NUPPER: /* \U */ |
| ! result = c != NUL && !ri_upper(c); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| --- 3440,3536 ---- |
| break; |
| |
| case NFA_SPRINT: /* \P */ |
| ! result = !VIM_ISDIGIT(curc) && ptr2cells(reginput) == 1; |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_WHITE: /* \s */ |
| ! result = vim_iswhite(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NWHITE: /* \S */ |
| ! result = curc != NUL && !vim_iswhite(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_DIGIT: /* \d */ |
| ! result = ri_digit(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NDIGIT: /* \D */ |
| ! result = curc != NUL && !ri_digit(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_HEX: /* \x */ |
| ! result = ri_hex(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NHEX: /* \X */ |
| ! result = curc != NUL && !ri_hex(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_OCTAL: /* \o */ |
| ! result = ri_octal(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NOCTAL: /* \O */ |
| ! result = curc != NUL && !ri_octal(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_WORD: /* \w */ |
| ! result = ri_word(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NWORD: /* \W */ |
| ! result = curc != NUL && !ri_word(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_HEAD: /* \h */ |
| ! result = ri_head(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NHEAD: /* \H */ |
| ! result = curc != NUL && !ri_head(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_ALPHA: /* \a */ |
| ! result = ri_alpha(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NALPHA: /* \A */ |
| ! result = curc != NUL && !ri_alpha(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_LOWER: /* \l */ |
| ! result = ri_lower(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NLOWER: /* \L */ |
| ! result = curc != NUL && !ri_lower(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_UPPER: /* \u */ |
| ! result = ri_upper(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| case NFA_NUPPER: /* \U */ |
| ! result = curc != NUL && !ri_upper(curc); |
| ADD_POS_NEG_STATE(t->state); |
| break; |
| |
| |
| *** 3549,3565 **** |
| /* TODO: put this in #ifdef later */ |
| if (t->state->c < -256) |
| EMSGN("INTERNAL: Negative state char: %ld", t->state->c); |
| ! result = (no_Magic(t->state->c) == c); |
| |
| if (!result) |
| result = ireg_ic == TRUE |
| ! && MB_TOLOWER(t->state->c) == MB_TOLOWER(c); |
| #ifdef FEAT_MBYTE |
| /* If there is a composing character which is not being |
| * ignored there can be no match. Match with composing |
| * character uses NFA_COMPOSING above. */ |
| if (result && enc_utf8 && !ireg_icombine |
| ! && n != utf_char2len(c)) |
| result = FALSE; |
| #endif |
| ADD_POS_NEG_STATE(t->state); |
| --- 3556,3572 ---- |
| /* TODO: put this in #ifdef later */ |
| if (t->state->c < -256) |
| EMSGN("INTERNAL: Negative state char: %ld", t->state->c); |
| ! result = (no_Magic(t->state->c) == curc); |
| |
| if (!result) |
| result = ireg_ic == TRUE |
| ! && MB_TOLOWER(t->state->c) == MB_TOLOWER(curc); |
| #ifdef FEAT_MBYTE |
| /* If there is a composing character which is not being |
| * ignored there can be no match. Match with composing |
| * character uses NFA_COMPOSING above. */ |
| if (result && enc_utf8 && !ireg_icombine |
| ! && clen != utf_char2len(curc)) |
| result = FALSE; |
| #endif |
| ADD_POS_NEG_STATE(t->state); |
| |
| *** 3578,3598 **** |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, "(---) STARTSTATE\n"); |
| #endif |
| ! addstate(nextlist, start, m, n, listid + 1, &match); |
| } |
| |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n); |
| ! for (i = 0; i< thislist->n; i++) |
| ! fprintf(log_fd, "%d ", abs(thislist->t[i].state->id)); |
| fprintf(log_fd, "\n"); |
| #endif |
| |
| nextchar: |
| /* Advance to the next character, or advance to the next line, or |
| * finish. */ |
| ! if (n != 0) |
| ! reginput += n; |
| else if (go_to_nextline) |
| reg_nextline(); |
| else |
| --- 3585,3609 ---- |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, "(---) STARTSTATE\n"); |
| #endif |
| ! addstate(nextlist, start, m, clen, listid + 1, &match); |
| } |
| |
| #ifdef ENABLE_LOG |
| fprintf(log_fd, ">>> Thislist had %d states available: ", thislist->n); |
| ! { |
| ! int i; |
| ! |
| ! for (i = 0; i < thislist->n; i++) |
| ! fprintf(log_fd, "%d ", abs(thislist->t[i].state->id)); |
| ! } |
| fprintf(log_fd, "\n"); |
| #endif |
| |
| nextchar: |
| /* Advance to the next character, or advance to the next line, or |
| * finish. */ |
| ! if (clen != 0) |
| ! reginput += clen; |
| else if (go_to_nextline) |
| reg_nextline(); |
| else |
| |
| |
| |
| *** 730,731 **** |
| --- 730,733 ---- |
| { /* Add new patch number below this line */ |
| + /**/ |
| + 1022, |
| /**/ |
| |
| -- |
| Female engineers become irresistible at the age of consent and remain that |
| way until about thirty minutes after their clinical death. Longer if it's a |
| warm day. |
| (Scott Adams - The Dilbert principle) |
| |
| /// 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 /// |