mirror of
https://github.com/neovim/neovim.git
synced 2025-02-25 18:55:25 -06:00
refactor(uncrustify): enable formatting for regexp and indent files (#18549)
The formatting for these files were originally disabled as to signal that "we don't own these files", meaning we intentionally want to minimize the amount of work put in these files as the return will be very little. This unfortunately conflicts with other refactoring efforts that happen to touch these files, and it's easier to simply enable formatting.
This commit is contained in:
dundargoc
GitHub
parent
83da441d16
commit
0adc66171a
1046
src/nvim/indent_c.c
1046
src/nvim/indent_c.c
File diff suppressed because it is too large
Load Diff
@ -1,8 +1,6 @@
|
||||
// This is an open source non-commercial project. Dear PVS-Studio, please check
|
||||
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
|
||||
|
||||
// uncrustify:off
|
||||
|
||||
/*
|
||||
* Handling of regular expressions: vim_regcomp(), vim_regexec(), vim_regsub()
|
||||
*/
|
||||
@ -18,21 +16,21 @@
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "nvim/vim.h"
|
||||
#include "nvim/ascii.h"
|
||||
#include "nvim/regexp.h"
|
||||
#include "nvim/charset.h"
|
||||
#include "nvim/eval.h"
|
||||
#include "nvim/eval/userfunc.h"
|
||||
#include "nvim/ex_cmds2.h"
|
||||
#include "nvim/garray.h"
|
||||
#include "nvim/mark.h"
|
||||
#include "nvim/memline.h"
|
||||
#include "nvim/memory.h"
|
||||
#include "nvim/message.h"
|
||||
#include "nvim/os/input.h"
|
||||
#include "nvim/plines.h"
|
||||
#include "nvim/garray.h"
|
||||
#include "nvim/regexp.h"
|
||||
#include "nvim/strings.h"
|
||||
#include "nvim/vim.h"
|
||||
|
||||
#ifdef REGEXP_DEBUG
|
||||
// show/save debugging data when BT engine is used
|
||||
@ -62,15 +60,17 @@ typedef void (*(*fptr_T)(int *, int))(void);
|
||||
|
||||
static int no_Magic(int x)
|
||||
{
|
||||
if (is_Magic(x))
|
||||
if (is_Magic(x)) {
|
||||
return un_Magic(x);
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
static int toggle_Magic(int x)
|
||||
{
|
||||
if (is_Magic(x))
|
||||
if (is_Magic(x)) {
|
||||
return un_Magic(x);
|
||||
}
|
||||
return Magic(x);
|
||||
}
|
||||
|
||||
@ -88,13 +88,12 @@ static int toggle_Magic(int x)
|
||||
#define IEMSG_RET_NULL(m) return (iemsg(m), rc_did_emsg = true, (void *)NULL)
|
||||
#define EMSG_RET_FAIL(m) return (emsg(m), rc_did_emsg = true, FAIL)
|
||||
#define EMSG2_RET_NULL(m, c) \
|
||||
return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, (void *)NULL)
|
||||
return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, (void *)NULL)
|
||||
#define EMSG3_RET_NULL(m, c, a) \
|
||||
return (semsg((const char *)(m), (c) ? "" : "\\", (a)), rc_did_emsg = true, (void *)NULL)
|
||||
return (semsg((const char *)(m), (c) ? "" : "\\", (a)), rc_did_emsg = true, (void *)NULL)
|
||||
#define EMSG2_RET_FAIL(m, c) \
|
||||
return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, FAIL)
|
||||
#define EMSG_ONE_RET_NULL EMSG2_RET_NULL(_( \
|
||||
"E369: invalid item in %s%%[]"), reg_magic == MAGIC_ALL)
|
||||
return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, FAIL)
|
||||
#define EMSG_ONE_RET_NULL EMSG2_RET_NULL(_("E369: invalid item in %s%%[]"), reg_magic == MAGIC_ALL)
|
||||
|
||||
#define MAX_LIMIT (32767L << 16L)
|
||||
|
||||
@ -128,30 +127,32 @@ static char_u e_regexp_number_after_dot_pos_search[]
|
||||
/// Return MULTI_MULT if c is a multi "multi" operator.
|
||||
static int re_multi_type(int c)
|
||||
{
|
||||
if (c == Magic('@') || c == Magic('=') || c == Magic('?'))
|
||||
if (c == Magic('@') || c == Magic('=') || c == Magic('?')) {
|
||||
return MULTI_ONE;
|
||||
if (c == Magic('*') || c == Magic('+') || c == Magic('{'))
|
||||
}
|
||||
if (c == Magic('*') || c == Magic('+') || c == Magic('{')) {
|
||||
return MULTI_MULT;
|
||||
}
|
||||
return NOT_MULTI;
|
||||
}
|
||||
|
||||
static char_u *reg_prev_sub = NULL;
|
||||
static char_u *reg_prev_sub = NULL;
|
||||
|
||||
/*
|
||||
* REGEXP_INRANGE contains all characters which are always special in a []
|
||||
* range after '\'.
|
||||
* REGEXP_ABBR contains all characters which act as abbreviations after '\'.
|
||||
* These are:
|
||||
* \n - New line (NL).
|
||||
* \r - Carriage Return (CR).
|
||||
* \t - Tab (TAB).
|
||||
* \e - Escape (ESC).
|
||||
* \b - Backspace (Ctrl_H).
|
||||
* \n - New line (NL).
|
||||
* \r - Carriage Return (CR).
|
||||
* \t - Tab (TAB).
|
||||
* \e - Escape (ESC).
|
||||
* \b - Backspace (Ctrl_H).
|
||||
* \d - Character code in decimal, eg \d123
|
||||
* \o - Character code in octal, eg \o80
|
||||
* \x - Character code in hex, eg \x4a
|
||||
* \u - Multibyte character code, eg \u20ac
|
||||
* \U - Long multibyte character code, eg \U12345678
|
||||
* \o - Character code in octal, eg \o80
|
||||
* \x - Character code in hex, eg \x4a
|
||||
* \u - Multibyte character code, eg \u20ac
|
||||
* \U - Long multibyte character code, eg \U12345678
|
||||
*/
|
||||
static char_u REGEXP_INRANGE[] = "]^-n\\";
|
||||
static char_u REGEXP_ABBR[] = "nrtebdoxuU";
|
||||
@ -163,10 +164,14 @@ static char_u REGEXP_ABBR[] = "nrtebdoxuU";
|
||||
static int backslash_trans(int c)
|
||||
{
|
||||
switch (c) {
|
||||
case 'r': return CAR;
|
||||
case 't': return TAB;
|
||||
case 'e': return ESC;
|
||||
case 'b': return BS;
|
||||
case 'r':
|
||||
return CAR;
|
||||
case 't':
|
||||
return TAB;
|
||||
case 'e':
|
||||
return ESC;
|
||||
case 'b':
|
||||
return BS;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
@ -223,11 +228,12 @@ static int get_char_class(char_u **pp)
|
||||
int i;
|
||||
|
||||
if ((*pp)[1] == ':') {
|
||||
for (i = 0; i < (int)ARRAY_SIZE(class_names); ++i)
|
||||
for (i = 0; i < (int)ARRAY_SIZE(class_names); i++) {
|
||||
if (STRNCMP(*pp + 2, class_names[i], STRLEN(class_names[i])) == 0) {
|
||||
*pp += STRLEN(class_names[i]) + 2;
|
||||
return i;
|
||||
}
|
||||
}
|
||||
}
|
||||
return CLASS_NONE;
|
||||
}
|
||||
@ -253,41 +259,43 @@ static void init_class_tab(void)
|
||||
int i;
|
||||
static int done = false;
|
||||
|
||||
if (done)
|
||||
if (done) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < 256; ++i) {
|
||||
if (i >= '0' && i <= '7')
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (i >= '0' && i <= '7') {
|
||||
class_tab[i] = RI_DIGIT + RI_HEX + RI_OCTAL + RI_WORD;
|
||||
else if (i >= '8' && i <= '9')
|
||||
} else if (i >= '8' && i <= '9') {
|
||||
class_tab[i] = RI_DIGIT + RI_HEX + RI_WORD;
|
||||
else if (i >= 'a' && i <= 'f')
|
||||
} else if (i >= 'a' && i <= 'f') {
|
||||
class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER;
|
||||
else if (i >= 'g' && i <= 'z')
|
||||
} else if (i >= 'g' && i <= 'z') {
|
||||
class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_LOWER;
|
||||
else if (i >= 'A' && i <= 'F')
|
||||
} else if (i >= 'A' && i <= 'F') {
|
||||
class_tab[i] = RI_HEX + RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER;
|
||||
else if (i >= 'G' && i <= 'Z')
|
||||
} else if (i >= 'G' && i <= 'Z') {
|
||||
class_tab[i] = RI_WORD + RI_HEAD + RI_ALPHA + RI_UPPER;
|
||||
else if (i == '_')
|
||||
} else if (i == '_') {
|
||||
class_tab[i] = RI_WORD + RI_HEAD;
|
||||
else
|
||||
} else {
|
||||
class_tab[i] = 0;
|
||||
}
|
||||
}
|
||||
class_tab[' '] |= RI_WHITE;
|
||||
class_tab['\t'] |= RI_WHITE;
|
||||
done = true;
|
||||
}
|
||||
|
||||
# define ri_digit(c) ((c) < 0x100 && (class_tab[c] & RI_DIGIT))
|
||||
# define ri_hex(c) ((c) < 0x100 && (class_tab[c] & RI_HEX))
|
||||
# define ri_octal(c) ((c) < 0x100 && (class_tab[c] & RI_OCTAL))
|
||||
# define ri_word(c) ((c) < 0x100 && (class_tab[c] & RI_WORD))
|
||||
# define ri_head(c) ((c) < 0x100 && (class_tab[c] & RI_HEAD))
|
||||
# define ri_alpha(c) ((c) < 0x100 && (class_tab[c] & RI_ALPHA))
|
||||
# define ri_lower(c) ((c) < 0x100 && (class_tab[c] & RI_LOWER))
|
||||
# define ri_upper(c) ((c) < 0x100 && (class_tab[c] & RI_UPPER))
|
||||
# define ri_white(c) ((c) < 0x100 && (class_tab[c] & RI_WHITE))
|
||||
#define ri_digit(c) ((c) < 0x100 && (class_tab[c] & RI_DIGIT))
|
||||
#define ri_hex(c) ((c) < 0x100 && (class_tab[c] & RI_HEX))
|
||||
#define ri_octal(c) ((c) < 0x100 && (class_tab[c] & RI_OCTAL))
|
||||
#define ri_word(c) ((c) < 0x100 && (class_tab[c] & RI_WORD))
|
||||
#define ri_head(c) ((c) < 0x100 && (class_tab[c] & RI_HEAD))
|
||||
#define ri_alpha(c) ((c) < 0x100 && (class_tab[c] & RI_ALPHA))
|
||||
#define ri_lower(c) ((c) < 0x100 && (class_tab[c] & RI_LOWER))
|
||||
#define ri_upper(c) ((c) < 0x100 && (class_tab[c] & RI_UPPER))
|
||||
#define ri_white(c) ((c) < 0x100 && (class_tab[c] & RI_WHITE))
|
||||
|
||||
// flags for regflags
|
||||
#define RF_ICASE 1 // ignore case
|
||||
@ -320,6 +328,8 @@ static int reg_strict; // "[abc" is illegal
|
||||
* META contains all characters that may be magic, except '^' and '$'.
|
||||
*/
|
||||
|
||||
// uncrustify:off
|
||||
|
||||
// META[] is used often enough to justify turning it into a table.
|
||||
static char_u META_flags[] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
@ -338,6 +348,8 @@ static char_u META_flags[] = {
|
||||
1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1
|
||||
};
|
||||
|
||||
// uncrustify:on
|
||||
|
||||
static int curchr; // currently parsed character
|
||||
// Previous character. Note: prevchr is sometimes -1 when we are not at the
|
||||
// start, eg in /[ ^I]^ the pattern was never found even if it existed,
|
||||
@ -389,7 +401,7 @@ static int get_equi_class(char_u **pp)
|
||||
{
|
||||
int c;
|
||||
int l = 1;
|
||||
char_u *p = *pp;
|
||||
char_u *p = *pp;
|
||||
|
||||
if (p[1] == '=' && p[2] != NUL) {
|
||||
l = utfc_ptr2len((char *)p + 2);
|
||||
@ -413,7 +425,7 @@ static int get_coll_element(char_u **pp)
|
||||
{
|
||||
int c;
|
||||
int l = 1;
|
||||
char_u *p = *pp;
|
||||
char_u *p = *pp;
|
||||
|
||||
if (p[0] != NUL && p[1] == '.' && p[2] != NUL) {
|
||||
l = utfc_ptr2len((char *)p + 2);
|
||||
@ -451,7 +463,7 @@ static char_u *skip_anyof(char_u *p)
|
||||
while (*p != NUL && *p != ']') {
|
||||
if ((l = utfc_ptr2len((char *)p)) > 1) {
|
||||
p += l;
|
||||
} else if (*p == '-') {
|
||||
} else if (*p == '-') {
|
||||
p++;
|
||||
if (*p != ']' && *p != NUL) {
|
||||
MB_PTR_ADV(p);
|
||||
@ -488,12 +500,13 @@ static char_u *skip_anyof(char_u *p)
|
||||
char_u *skip_regexp(char_u *startp, int dirc, int magic, char_u **newp)
|
||||
{
|
||||
int mymagic;
|
||||
char_u *p = startp;
|
||||
char_u *p = startp;
|
||||
|
||||
if (magic)
|
||||
if (magic) {
|
||||
mymagic = MAGIC_ON;
|
||||
else
|
||||
} else {
|
||||
mymagic = MAGIC_OFF;
|
||||
}
|
||||
get_cpo_flags();
|
||||
|
||||
for (; p[0] != NUL; MB_PTR_ADV(p)) {
|
||||
@ -503,9 +516,10 @@ char_u *skip_regexp(char_u *startp, int dirc, int magic, char_u **newp)
|
||||
if ((p[0] == '[' && mymagic >= MAGIC_ON)
|
||||
|| (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF)) {
|
||||
p = skip_anyof(p + 1);
|
||||
if (p[0] == NUL)
|
||||
if (p[0] == NUL) {
|
||||
break;
|
||||
} else if (p[0] == '\\' && p[1] != NUL) {
|
||||
}
|
||||
} else if (p[0] == '\\' && p[1] != NUL) {
|
||||
if (dirc == '?' && newp != NULL && p[1] == '?') {
|
||||
// change "\?" to "?", make a copy first.
|
||||
if (*newp == NULL) {
|
||||
@ -686,8 +700,7 @@ static int peekchr(void)
|
||||
}
|
||||
}
|
||||
break;
|
||||
case '\\':
|
||||
{
|
||||
case '\\': {
|
||||
int c = regparse[1];
|
||||
|
||||
if (c == NUL) {
|
||||
@ -712,13 +725,11 @@ static int peekchr(void)
|
||||
* Handle abbreviations, like "\t" for TAB -- webb
|
||||
*/
|
||||
curchr = backslash_trans(c);
|
||||
} else if (reg_magic == MAGIC_NONE && (c == '$' || c == '^'))
|
||||
} else if (reg_magic == MAGIC_NONE && (c == '$' || c == '^')) {
|
||||
curchr = toggle_Magic(c);
|
||||
else {
|
||||
/*
|
||||
* Next character can never be (made) magic?
|
||||
* Then backslashing it won't do anything.
|
||||
*/
|
||||
} else {
|
||||
// Next character can never be (made) magic?
|
||||
// Then backslashing it won't do anything.
|
||||
curchr = utf_ptr2char((char *)regparse + 1);
|
||||
}
|
||||
break;
|
||||
@ -804,7 +815,7 @@ static void ungetchr(void)
|
||||
* Return -1 if there is no valid hex number.
|
||||
* The position is updated:
|
||||
* blahblah\%x20asdf
|
||||
* before-^ ^-after
|
||||
* before-^ ^-after
|
||||
* The parameter controls the maximum number of input characters. This will be
|
||||
* 2 when reading a \%x20 sequence and 4 when reading a \%u20AC sequence.
|
||||
*/
|
||||
@ -816,15 +827,17 @@ static int64_t gethexchrs(int maxinputlen)
|
||||
|
||||
for (i = 0; i < maxinputlen; ++i) {
|
||||
c = regparse[0];
|
||||
if (!ascii_isxdigit(c))
|
||||
if (!ascii_isxdigit(c)) {
|
||||
break;
|
||||
}
|
||||
nr <<= 4;
|
||||
nr |= hex2nr(c);
|
||||
++regparse;
|
||||
}
|
||||
|
||||
if (i == 0)
|
||||
if (i == 0) {
|
||||
return -1;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
@ -840,16 +853,18 @@ static int64_t getdecchrs(void)
|
||||
|
||||
for (i = 0;; ++i) {
|
||||
c = regparse[0];
|
||||
if (c < '0' || c > '9')
|
||||
if (c < '0' || c > '9') {
|
||||
break;
|
||||
}
|
||||
nr *= 10;
|
||||
nr += c - '0';
|
||||
regparse++;
|
||||
curchr = -1; // no longer valid
|
||||
}
|
||||
|
||||
if (i == 0)
|
||||
if (i == 0) {
|
||||
return -1;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
@ -859,7 +874,7 @@ static int64_t getdecchrs(void)
|
||||
* numbers > 377 correctly (for example, 400 is treated as 40) and doesn't
|
||||
* treat 8 or 9 as recognised characters. Position is updated:
|
||||
* blahblah\%o210asdf
|
||||
* before-^ ^-after
|
||||
* before-^ ^-after
|
||||
*/
|
||||
static int64_t getoctchrs(void)
|
||||
{
|
||||
@ -869,15 +884,17 @@ static int64_t getoctchrs(void)
|
||||
|
||||
for (i = 0; i < 3 && nr < 040; i++) { // -V536
|
||||
c = regparse[0];
|
||||
if (c < '0' || c > '7')
|
||||
if (c < '0' || c > '7') {
|
||||
break;
|
||||
}
|
||||
nr <<= 3;
|
||||
nr |= hex2nr(c);
|
||||
++regparse;
|
||||
}
|
||||
|
||||
if (i == 0)
|
||||
if (i == 0) {
|
||||
return -1;
|
||||
}
|
||||
return nr;
|
||||
}
|
||||
|
||||
@ -891,7 +908,7 @@ static int64_t getoctchrs(void)
|
||||
static int read_limits(long *minval, long *maxval)
|
||||
{
|
||||
int reverse = false;
|
||||
char_u *first_char;
|
||||
char_u *first_char;
|
||||
long tmp;
|
||||
|
||||
if (*regparse == '-') {
|
||||
@ -943,7 +960,7 @@ static int read_limits(long *minval, long *maxval)
|
||||
// Sometimes need to save a copy of a line. Since alloc()/free() is very
|
||||
// slow, we keep one allocated piece of memory and only re-allocate it when
|
||||
// it's too small. It's freed in bt_regexec_both() when finished.
|
||||
static char_u *reg_tofree = NULL;
|
||||
static char_u *reg_tofree = NULL;
|
||||
static unsigned reg_tofreelen;
|
||||
|
||||
// Structure used to store the execution state of the regex engine.
|
||||
@ -1039,8 +1056,8 @@ static char_u *reg_getline(linenr_T lnum)
|
||||
return ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, false);
|
||||
}
|
||||
|
||||
static char_u *reg_startzp[NSUBEXP]; // Workspace to mark beginning
|
||||
static char_u *reg_endzp[NSUBEXP]; // and end of \z(...\) matches
|
||||
static char_u *reg_startzp[NSUBEXP]; // Workspace to mark beginning
|
||||
static char_u *reg_endzp[NSUBEXP]; // and end of \z(...\) matches
|
||||
static lpos_T reg_startzpos[NSUBEXP]; // idem, beginning pos
|
||||
static lpos_T reg_endzpos[NSUBEXP]; // idem, end pos
|
||||
|
||||
@ -1063,8 +1080,9 @@ static reg_extmatch_T *make_extmatch(void)
|
||||
*/
|
||||
reg_extmatch_T *ref_extmatch(reg_extmatch_T *em)
|
||||
{
|
||||
if (em != NULL)
|
||||
if (em != NULL) {
|
||||
em->refcnt++;
|
||||
}
|
||||
return em;
|
||||
}
|
||||
|
||||
@ -1077,8 +1095,9 @@ void unref_extmatch(reg_extmatch_T *em)
|
||||
int i;
|
||||
|
||||
if (em != NULL && --em->refcnt <= 0) {
|
||||
for (i = 0; i < NSUBEXP; ++i)
|
||||
for (i = 0; i < NSUBEXP; i++) {
|
||||
xfree(em->matches[i]);
|
||||
}
|
||||
xfree(em);
|
||||
}
|
||||
}
|
||||
@ -1087,9 +1106,8 @@ void unref_extmatch(reg_extmatch_T *em)
|
||||
static int reg_prev_class(void)
|
||||
{
|
||||
if (rex.input > rex.line) {
|
||||
return mb_get_class_tab(
|
||||
rex.input - 1 - utf_head_off(rex.line, rex.input - 1),
|
||||
rex.reg_buf->b_chartab);
|
||||
return mb_get_class_tab(rex.input - 1 - utf_head_off(rex.line, rex.input - 1),
|
||||
rex.reg_buf->b_chartab);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@ -1147,10 +1165,12 @@ static bool reg_match_visual(void)
|
||||
} else if (mode == Ctrl_V) {
|
||||
getvvcol(wp, &top, &start, NULL, &end);
|
||||
getvvcol(wp, &bot, &start2, NULL, &end2);
|
||||
if (start2 < start)
|
||||
if (start2 < start) {
|
||||
start = start2;
|
||||
if (end2 > end)
|
||||
}
|
||||
if (end2 > end) {
|
||||
end = end2;
|
||||
}
|
||||
if (top.col == MAXCOL || bot.col == MAXCOL || curswant == MAXCOL) {
|
||||
end = MAXCOL;
|
||||
}
|
||||
@ -1175,7 +1195,7 @@ static bool reg_match_visual(void)
|
||||
*/
|
||||
static int prog_magic_wrong(void)
|
||||
{
|
||||
regprog_T *prog;
|
||||
regprog_T *prog;
|
||||
|
||||
prog = REG_MULTI ? rex.reg_mmatch->regprog : rex.reg_match->regprog;
|
||||
if (prog->engine == &nfa_regengine) {
|
||||
@ -1241,21 +1261,18 @@ static void reg_nextline(void)
|
||||
* If "bytelen" is not NULL, it is set to the byte length of the match in the
|
||||
* last line.
|
||||
*/
|
||||
static int match_with_backref(
|
||||
linenr_T start_lnum,
|
||||
colnr_T start_col,
|
||||
linenr_T end_lnum,
|
||||
colnr_T end_col,
|
||||
int *bytelen)
|
||||
static int match_with_backref(linenr_T start_lnum, colnr_T start_col, linenr_T end_lnum,
|
||||
colnr_T end_col, int *bytelen)
|
||||
{
|
||||
linenr_T clnum = start_lnum;
|
||||
colnr_T ccol = start_col;
|
||||
int len;
|
||||
char_u *p;
|
||||
char_u *p;
|
||||
|
||||
if (bytelen != NULL)
|
||||
if (bytelen != NULL) {
|
||||
*bytelen = 0;
|
||||
for (;; ) {
|
||||
}
|
||||
for (;;) {
|
||||
// Since getting one line may invalidate the other, need to make copy.
|
||||
// Slow!
|
||||
if (rex.line != reg_tofree) {
|
||||
@ -1275,10 +1292,11 @@ static int match_with_backref(
|
||||
p = reg_getline(clnum);
|
||||
assert(p);
|
||||
|
||||
if (clnum == end_lnum)
|
||||
if (clnum == end_lnum) {
|
||||
len = end_col - ccol;
|
||||
else
|
||||
} else {
|
||||
len = (int)STRLEN(p + ccol);
|
||||
}
|
||||
|
||||
if (cstrncmp(p + ccol, rex.input, &len) != 0) {
|
||||
return RA_NOMATCH; // doesn't match
|
||||
@ -1295,12 +1313,14 @@ static int match_with_backref(
|
||||
|
||||
// Advance to next line.
|
||||
reg_nextline();
|
||||
if (bytelen != NULL)
|
||||
if (bytelen != NULL) {
|
||||
*bytelen = 0;
|
||||
++clnum;
|
||||
}
|
||||
clnum++;
|
||||
ccol = 0;
|
||||
if (got_int)
|
||||
if (got_int) {
|
||||
return RA_FAIL;
|
||||
}
|
||||
}
|
||||
|
||||
// found a match! Note that rex.line may now point to a copy of the line,
|
||||
@ -1324,7 +1344,7 @@ typedef struct {
|
||||
} decomp_T;
|
||||
|
||||
// 0xfb20 - 0xfb4f
|
||||
static decomp_T decomp_table[0xfb4f-0xfb20+1] =
|
||||
static decomp_T decomp_table[0xfb4f - 0xfb20 + 1] =
|
||||
{
|
||||
{ 0x5e2, 0, 0 }, // 0xfb20 alt ayin
|
||||
{ 0x5d0, 0, 0 }, // 0xfb21 alt alef
|
||||
@ -1407,7 +1427,7 @@ static int cstrncmp(char_u *s1, char_u *s2, int *n)
|
||||
|
||||
// if it failed and it's utf8 and we want to combineignore:
|
||||
if (result != 0 && rex.reg_icombine) {
|
||||
char_u *str1, *str2;
|
||||
char_u *str1, *str2;
|
||||
int c1, c2, c11, c12;
|
||||
int junk;
|
||||
|
||||
@ -1435,8 +1455,9 @@ static int cstrncmp(char_u *s1, char_u *s2, int *n)
|
||||
}
|
||||
}
|
||||
result = c2 - c1;
|
||||
if (result == 0)
|
||||
if (result == 0) {
|
||||
*n = (int)(str2 - s2);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
@ -1533,9 +1554,9 @@ static fptr_T do_Lower(int *d, int c)
|
||||
*/
|
||||
char_u *regtilde(char_u *source, int magic, bool preview)
|
||||
{
|
||||
char_u *newsub = source;
|
||||
char_u *tmpsub;
|
||||
char_u *p;
|
||||
char_u *newsub = source;
|
||||
char_u *tmpsub;
|
||||
char_u *p;
|
||||
int len;
|
||||
int prevlen;
|
||||
|
||||
@ -1605,8 +1626,7 @@ static regsubmatch_T rsm; // can only be used when can_f_submatch is true
|
||||
|
||||
/// Put the submatches in "argv[argskip]" which is a list passed into
|
||||
/// call_func() by vim_regsub_both().
|
||||
static int fill_submatch_list(int argc FUNC_ATTR_UNUSED, typval_T *argv,
|
||||
int argskip, int argcount)
|
||||
static int fill_submatch_list(int argc FUNC_ATTR_UNUSED, typval_T *argv, int argskip, int argcount)
|
||||
FUNC_ATTR_NONNULL_ALL
|
||||
{
|
||||
typval_T *listarg = argv + argskip;
|
||||
@ -1658,8 +1678,8 @@ static void clear_submatch_list(staticList10_T *sl)
|
||||
/// references invalid!
|
||||
///
|
||||
/// Returns the size of the replacement, including terminating NUL.
|
||||
int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest,
|
||||
int copy, int magic, int backslash)
|
||||
int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest, int copy, int magic,
|
||||
int backslash)
|
||||
{
|
||||
regexec_T rex_save;
|
||||
bool rex_in_use_save = rex_in_use;
|
||||
@ -1685,8 +1705,8 @@ int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest,
|
||||
return result;
|
||||
}
|
||||
|
||||
int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest,
|
||||
int copy, int magic, int backslash)
|
||||
int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int copy,
|
||||
int magic, int backslash)
|
||||
{
|
||||
regexec_T rex_save;
|
||||
bool rex_in_use_save = rex_in_use;
|
||||
@ -1713,12 +1733,12 @@ int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *de
|
||||
return result;
|
||||
}
|
||||
|
||||
static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
int copy, int magic, int backslash)
|
||||
static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest, int copy, int magic,
|
||||
int backslash)
|
||||
{
|
||||
char_u *src;
|
||||
char_u *dst;
|
||||
char_u *s;
|
||||
char_u *src;
|
||||
char_u *dst;
|
||||
char_u *s;
|
||||
int c;
|
||||
int cc;
|
||||
int no = -1;
|
||||
@ -1737,8 +1757,9 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
emsg(_(e_null));
|
||||
return 0;
|
||||
}
|
||||
if (prog_magic_wrong())
|
||||
if (prog_magic_wrong()) {
|
||||
return 0;
|
||||
}
|
||||
src = source;
|
||||
dst = dest;
|
||||
|
||||
@ -1851,11 +1872,11 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
rsm = rsm_save;
|
||||
}
|
||||
}
|
||||
} else
|
||||
} else {
|
||||
while ((c = *src++) != NUL) {
|
||||
if (c == '&' && magic)
|
||||
if (c == '&' && magic) {
|
||||
no = 0;
|
||||
else if (c == '\\' && *src != NUL) {
|
||||
} else if (c == '\\' && *src != NUL) {
|
||||
if (*src == '&' && !magic) {
|
||||
++src;
|
||||
no = 0;
|
||||
@ -1863,16 +1884,21 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
no = *src++ - '0';
|
||||
} else if (vim_strchr((char_u *)"uUlLeE", *src)) {
|
||||
switch (*src++) {
|
||||
case 'u': func_one = (fptr_T)do_upper;
|
||||
case 'u':
|
||||
func_one = (fptr_T)do_upper;
|
||||
continue;
|
||||
case 'U': func_all = (fptr_T)do_Upper;
|
||||
case 'U':
|
||||
func_all = (fptr_T)do_Upper;
|
||||
continue;
|
||||
case 'l': func_one = (fptr_T)do_lower;
|
||||
case 'l':
|
||||
func_one = (fptr_T)do_lower;
|
||||
continue;
|
||||
case 'L': func_all = (fptr_T)do_Lower;
|
||||
case 'L':
|
||||
func_all = (fptr_T)do_Lower;
|
||||
continue;
|
||||
case 'e':
|
||||
case 'E': func_one = func_all = (fptr_T)NULL;
|
||||
case 'E':
|
||||
func_one = func_all = (fptr_T)NULL;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
@ -1894,12 +1920,16 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
if (c == '\\' && *src != NUL) {
|
||||
// Check for abbreviations -- webb
|
||||
switch (*src) {
|
||||
case 'r': c = CAR; ++src; break;
|
||||
case 'n': c = NL; ++src; break;
|
||||
case 't': c = TAB; ++src; break;
|
||||
case 'r':
|
||||
c = CAR; ++src; break;
|
||||
case 'n':
|
||||
c = NL; ++src; break;
|
||||
case 't':
|
||||
c = TAB; ++src; break;
|
||||
// Oh no! \e already has meaning in subst pat :-(
|
||||
// case 'e': c = ESC; ++src; break;
|
||||
case 'b': c = Ctrl_H; ++src; break;
|
||||
case 'b':
|
||||
c = Ctrl_H; ++src; break;
|
||||
|
||||
// If "backslash" is true the backslash will be removed
|
||||
// later. Used to insert a literal CR.
|
||||
@ -1967,7 +1997,7 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
}
|
||||
}
|
||||
if (s != NULL) {
|
||||
for (;; ) {
|
||||
for (;;) {
|
||||
if (len == 0) {
|
||||
if (REG_MULTI) {
|
||||
if (rex.reg_mmatch->endpos[no].lnum == clnum) {
|
||||
@ -2042,8 +2072,10 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest,
|
||||
no = -1;
|
||||
}
|
||||
}
|
||||
if (copy)
|
||||
}
|
||||
if (copy) {
|
||||
*dst = NUL;
|
||||
}
|
||||
|
||||
exit:
|
||||
return (int)((dst - dest) + 1 - num_escaped);
|
||||
@ -2078,13 +2110,14 @@ static char_u *reg_getline_submatch(linenr_T lnum)
|
||||
*/
|
||||
char_u *reg_submatch(int no)
|
||||
{
|
||||
char_u *retval = NULL;
|
||||
char_u *s;
|
||||
char_u *retval = NULL;
|
||||
char_u *s;
|
||||
int round;
|
||||
linenr_T lnum;
|
||||
|
||||
if (!can_f_submatch || no < 0)
|
||||
if (!can_f_submatch || no < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (rsm.sm_match == NULL) {
|
||||
ssize_t len;
|
||||
@ -2123,12 +2156,14 @@ char_u *reg_submatch(int no)
|
||||
lnum++;
|
||||
while (lnum < rsm.sm_mmatch->endpos[no].lnum) {
|
||||
s = reg_getline_submatch(lnum++);
|
||||
if (round == 2)
|
||||
if (round == 2) {
|
||||
STRCPY(retval + len, s);
|
||||
}
|
||||
len += STRLEN(s);
|
||||
if (round == 2)
|
||||
if (round == 2) {
|
||||
retval[len] = '\n';
|
||||
++len;
|
||||
}
|
||||
len++;
|
||||
}
|
||||
if (round == 2) {
|
||||
STRNCPY(retval + len, reg_getline_submatch(lnum),
|
||||
@ -2252,9 +2287,9 @@ static char_u regname[][30] = {
|
||||
*/
|
||||
regprog_T *vim_regcomp(char_u *expr_arg, int re_flags)
|
||||
{
|
||||
regprog_T *prog = NULL;
|
||||
char_u *expr = expr_arg;
|
||||
int save_called_emsg;
|
||||
regprog_T *prog = NULL;
|
||||
char_u *expr = expr_arg;
|
||||
int save_called_emsg;
|
||||
|
||||
regexp_engine = p_re;
|
||||
|
||||
@ -2273,8 +2308,7 @@ regprog_T *vim_regcomp(char_u *expr_arg, int re_flags)
|
||||
regname[newengine]);
|
||||
#endif
|
||||
} else {
|
||||
emsg(_(
|
||||
"E864: \\%#= can only be followed by 0, 1, or 2. The automatic engine will be used "));
|
||||
emsg(_("E864: \\%#= can only be followed by 0, 1, or 2. The automatic engine will be used "));
|
||||
regexp_engine = AUTOMATIC_ENGINE;
|
||||
}
|
||||
}
|
||||
@ -2292,7 +2326,7 @@ regprog_T *vim_regcomp(char_u *expr_arg, int re_flags)
|
||||
called_emsg = false;
|
||||
if (regexp_engine != BACKTRACKING_ENGINE) {
|
||||
prog = nfa_regengine.regcomp(expr,
|
||||
re_flags + (regexp_engine == AUTOMATIC_ENGINE ? RE_AUTO : 0));
|
||||
re_flags + (regexp_engine == AUTOMATIC_ENGINE ? RE_AUTO : 0));
|
||||
} else {
|
||||
prog = bt_regengine.regcomp(expr, re_flags);
|
||||
}
|
||||
@ -2339,8 +2373,9 @@ regprog_T *vim_regcomp(char_u *expr_arg, int re_flags)
|
||||
*/
|
||||
void vim_regfree(regprog_T *prog)
|
||||
{
|
||||
if (prog != NULL)
|
||||
if (prog != NULL) {
|
||||
prog->engine->regfree(prog);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -2462,16 +2497,17 @@ bool vim_regexec_nl(regmatch_T *rmp, char_u *line, colnr_T col)
|
||||
/// Note: "rmp->regprog" may be freed and changed, even set to NULL.
|
||||
/// Uses curbuf for line count and 'iskeyword'.
|
||||
///
|
||||
/// Return zero if there is no match. Return number of lines contained in the
|
||||
/// match otherwise.
|
||||
long vim_regexec_multi(
|
||||
regmmatch_T *rmp,
|
||||
win_T *win, // window in which to search or NULL
|
||||
buf_T *buf, // buffer in which to search
|
||||
linenr_T lnum, // nr of line to start looking for match
|
||||
colnr_T col, // column to start looking for match
|
||||
proftime_T *tm, // timeout limit or NULL
|
||||
int *timed_out) // flag is set when timeout limit reached
|
||||
/// @param win window in which to search or NULL
|
||||
/// @param buf buffer in which to search
|
||||
/// @param lnum nr of line to start looking for match
|
||||
/// @param col column to start looking for match
|
||||
/// @param tm timeout limit or NULL
|
||||
/// @param timed_out flag is set when timeout limit reached
|
||||
///
|
||||
/// @return zero if there is no match. Return number of lines contained in the
|
||||
/// match otherwise.
|
||||
long vim_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum, colnr_T col,
|
||||
proftime_T *tm, int *timed_out)
|
||||
FUNC_ATTR_NONNULL_ARG(1)
|
||||
{
|
||||
regexec_T rex_save;
|
||||
|
||||
2043
src/nvim/regexp_bt.c
2043
src/nvim/regexp_bt.c
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user