From ebd2372f928c6f1cfe823d36aabf479f6930232f Mon Sep 17 00:00:00 2001 From: dundargoc <33953936+dundargoc@users.noreply.github.com> Date: Thu, 2 Feb 2023 23:56:25 +0100 Subject: refactor: use flexible arrays instead of the length-of-one trick (#22072) The "length-of-one" trick, where the last element of a struct is an array of size 1, but extra size is allocated when calling malloc where it uses more than 1 element in the array, cause problems with some compilers. Some compilers set _FORTIFY_SOURCE=2 by default which incorrectly considers it as an overflow. More information: https://github.com/neovim/neovim/issues/223#issuecomment-1413828554 Using flexible array members allows us to to properly convey to the compiler that its size may be larger than 1. This also enables us to remove lengthy workarounds that are unreliable, as they depend on CMAKE_BUILD_TYPE which isn't defined for multi-config generators. Closes: https://github.com/neovim/neovim/issues/223 --- src/nvim/regexp_defs.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index 16bb2db464..b27a5b5942 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -102,7 +102,7 @@ typedef struct { char_u *regmust; int regmlen; char_u reghasz; - char_u program[1]; // actually longer.. + char_u program[]; } bt_regprog_T; // Structure representing a NFA state. @@ -138,7 +138,7 @@ typedef struct { char *pattern; int nsubexp; // number of () int nstate; - nfa_state_T state[1]; // actually longer.. + nfa_state_T state[]; } nfa_regprog_T; // Structure to be used for single-line matching. -- cgit From 6cab36e5b7b0d741abe6c5a7c0e20bad30361034 Mon Sep 17 00:00:00 2001 From: dundargoc <33953936+dundargoc@users.noreply.github.com> Date: Sat, 4 Mar 2023 13:10:00 +0100 Subject: refactor: replace char_u with char or uint8_t (#22400) Work on https://github.com/neovim/neovim/issues/459 --- src/nvim/regexp_defs.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index b27a5b5942..ef155e8d46 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -98,11 +98,11 @@ typedef struct { bool re_in_use; int regstart; - char_u reganch; - char_u *regmust; + uint8_t reganch; + uint8_t *regmust; int regmlen; - char_u reghasz; - char_u program[]; + uint8_t reghasz; + uint8_t program[]; } bt_regprog_T; // Structure representing a NFA state. @@ -130,7 +130,7 @@ typedef struct { int reganch; // pattern starts with ^ int regstart; // char at start of pattern - char_u *match_text; // plain text to match with + uint8_t *match_text; // plain text to match with int has_zend; // pattern contains \ze int has_backref; // pattern contains \1 .. \9 @@ -158,19 +158,19 @@ typedef struct { // from 1 to zero the matches need to be freed. struct reg_extmatch { int16_t refcnt; - char_u *matches[NSUBEXP]; + uint8_t *matches[NSUBEXP]; }; struct regengine { /// bt_regcomp or nfa_regcomp - regprog_T *(*regcomp)(char_u *, int); + regprog_T *(*regcomp)(uint8_t *, int); /// bt_regfree or nfa_regfree void (*regfree)(regprog_T *); /// bt_regexec_nl or nfa_regexec_nl - int (*regexec_nl)(regmatch_T *, char_u *, colnr_T, bool); + int (*regexec_nl)(regmatch_T *, uint8_t *, colnr_T, bool); /// bt_regexec_mult or nfa_regexec_mult long (*regexec_multi)(regmmatch_T *, win_T *, buf_T *, linenr_T, colnr_T, proftime_T *, int *); - // char_u *expr; + // uint8_t *expr; }; // Flags used by vim_regsub() and vim_regsub_both() -- cgit From 8e932480f61d6101bf8bea1abc07ed93826221fd Mon Sep 17 00:00:00 2001 From: dundargoc Date: Fri, 29 Sep 2023 14:58:48 +0200 Subject: refactor: the long goodbye long is 32 bits on windows, while it is 64 bits on other architectures. This makes the type suboptimal for a codebase meant to be cross-platform. Replace it with more appropriate integer types. --- src/nvim/regexp_defs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index ef155e8d46..8c2f5e4cd7 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -169,7 +169,7 @@ struct regengine { /// bt_regexec_nl or nfa_regexec_nl int (*regexec_nl)(regmatch_T *, uint8_t *, colnr_T, bool); /// bt_regexec_mult or nfa_regexec_mult - long (*regexec_multi)(regmmatch_T *, win_T *, buf_T *, linenr_T, colnr_T, proftime_T *, int *); + int (*regexec_multi)(regmmatch_T *, win_T *, buf_T *, linenr_T, colnr_T, proftime_T *, int *); // uint8_t *expr; }; -- cgit From 4f8941c1a5f1ef6caa410feeb52e343db22763ce Mon Sep 17 00:00:00 2001 From: dundargoc Date: Fri, 10 Nov 2023 12:23:42 +0100 Subject: refactor: replace manual header guards with #pragma once It is less error-prone than manually defining header guards. Pretty much all compilers support it even if it's not part of the C standard. --- src/nvim/regexp_defs.h | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index 8c2f5e4cd7..28e861dbaf 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -7,8 +7,7 @@ // // NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE NOTICE -#ifndef NVIM_REGEXP_DEFS_H -#define NVIM_REGEXP_DEFS_H +#pragma once #include @@ -177,5 +176,3 @@ struct regengine { #define REGSUB_COPY 1 #define REGSUB_MAGIC 2 #define REGSUB_BACKSLASH 4 - -#endif // NVIM_REGEXP_DEFS_H -- cgit From f4aedbae4cb1f206f5b7c6142697b71dd473059b Mon Sep 17 00:00:00 2001 From: dundargoc Date: Mon, 27 Nov 2023 18:39:38 +0100 Subject: build(IWYU): fix includes for undo_defs.h --- src/nvim/regexp_defs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index 28e861dbaf..ab349bfc86 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -11,7 +11,7 @@ #include -#include "nvim/pos.h" +#include "nvim/pos_defs.h" #include "nvim/types.h" /// Used for "magic_overruled". -- cgit From 6c14ae6bfaf51415b555e9a6b85d1d280976358d Mon Sep 17 00:00:00 2001 From: dundargoc Date: Mon, 27 Nov 2023 20:27:32 +0100 Subject: refactor: rename types.h to types_defs.h --- src/nvim/regexp_defs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index ab349bfc86..f18bceb486 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -12,7 +12,7 @@ #include #include "nvim/pos_defs.h" -#include "nvim/types.h" +#include "nvim/types_defs.h" /// Used for "magic_overruled". typedef enum { -- cgit From 718053b7a97c4e2fbaa6077d3c9f4dc7012c8aad Mon Sep 17 00:00:00 2001 From: zeertzjq Date: Tue, 28 Nov 2023 07:47:36 +0800 Subject: refactor: fix runtime_defs.h (#26259) --- src/nvim/regexp_defs.h | 95 +++++++++++++++++++++++++++----------------------- 1 file changed, 51 insertions(+), 44 deletions(-) (limited to 'src/nvim/regexp_defs.h') diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h index f18bceb486..079f3b6929 100644 --- a/src/nvim/regexp_defs.h +++ b/src/nvim/regexp_defs.h @@ -10,6 +10,7 @@ #pragma once #include +#include #include "nvim/pos_defs.h" #include "nvim/types_defs.h" @@ -32,25 +33,29 @@ typedef enum { MAGIC_ALL = 4, ///< "\v" very magic } magic_T; -// The number of sub-matches is limited to 10. -// The first one (index 0) is the whole match, referenced with "\0". -// The second one (index 1) is the first sub-match, referenced with "\1". -// This goes up to the tenth (index 9), referenced with "\9". -#define NSUBEXP 10 +/// The number of sub-matches is limited to 10. +/// The first one (index 0) is the whole match, referenced with "\0". +/// The second one (index 1) is the first sub-match, referenced with "\1". +/// This goes up to the tenth (index 9), referenced with "\9". +enum { NSUBEXP = 10, }; -// In the NFA engine: how many braces are allowed. -// TODO(RE): Use dynamic memory allocation instead of static, like here -#define NFA_MAX_BRACES 20 +/// In the NFA engine: how many braces are allowed. +/// TODO(RE): Use dynamic memory allocation instead of static, like here +enum { NFA_MAX_BRACES = 20, }; -// In the NFA engine: how many states are allowed. -#define NFA_MAX_STATES 100000 -#define NFA_TOO_EXPENSIVE (-1) +/// In the NFA engine: how many states are allowed. +enum { + NFA_MAX_STATES = 100000, + NFA_TOO_EXPENSIVE = -1, +}; -// Which regexp engine to use? Needed for vim_regcomp(). -// Must match with 'regexpengine'. -#define AUTOMATIC_ENGINE 0 -#define BACKTRACKING_ENGINE 1 -#define NFA_ENGINE 2 +/// Which regexp engine to use? Needed for vim_regcomp(). +/// Must match with 'regexpengine'. +enum { + AUTOMATIC_ENGINE = 0, + BACKTRACKING_ENGINE = 1, + NFA_ENGINE = 2, +}; typedef struct regengine regengine_T; typedef struct regprog regprog_T; @@ -69,14 +74,14 @@ typedef struct { colnr_T rmm_matchcol; ///< match start without "\zs" int rmm_ic; - colnr_T rmm_maxcol; /// when not zero: maximum column + colnr_T rmm_maxcol; ///< when not zero: maximum column } regmmatch_T; #include "nvim/buffer_defs.h" -// Structure returned by vim_regcomp() to pass on to vim_regexec(). -// This is the general structure. For the actual matcher, two specific -// structures are used. See code below. +/// Structure returned by vim_regcomp() to pass on to vim_regexec(). +/// This is the general structure. For the actual matcher, two specific +/// structures are used. See code below. struct regprog { regengine_T *engine; unsigned regflags; @@ -85,9 +90,9 @@ struct regprog { bool re_in_use; ///< prog is being executed }; -// Structure used by the back track matcher. -// These fields are only to be used in regexp.c! -// See regexp.c for an explanation. +/// Structure used by the back track matcher. +/// These fields are only to be used in regexp.c! +/// See regexp.c for an explanation. typedef struct { // These four members implement regprog_T. regengine_T *engine; @@ -104,19 +109,19 @@ typedef struct { uint8_t program[]; } bt_regprog_T; -// Structure representing a NFA state. -// An NFA state may have no outgoing edge, when it is a NFA_MATCH state. +/// Structure representing a NFA state. +/// An NFA state may have no outgoing edge, when it is a NFA_MATCH state. typedef struct nfa_state nfa_state_T; struct nfa_state { int c; nfa_state_T *out; nfa_state_T *out1; int id; - int lastlist[2]; // 0: normal, 1: recursive + int lastlist[2]; ///< 0: normal, 1: recursive int val; }; -// Structure used by the NFA matcher. +/// Structure used by the NFA matcher. typedef struct { // These four members implement regprog_T. regengine_T *engine; @@ -125,24 +130,24 @@ typedef struct { unsigned re_flags; bool re_in_use; - nfa_state_T *start; // points into state[] + nfa_state_T *start; ///< points into state[] - int reganch; // pattern starts with ^ - int regstart; // char at start of pattern - uint8_t *match_text; // plain text to match with + int reganch; ///< pattern starts with ^ + int regstart; ///< char at start of pattern + uint8_t *match_text; ///< plain text to match with - int has_zend; // pattern contains \ze - int has_backref; // pattern contains \1 .. \9 + int has_zend; ///< pattern contains \ze + int has_backref; ///< pattern contains \1 .. \9 int reghasz; char *pattern; - int nsubexp; // number of () + int nsubexp; ///< number of () int nstate; nfa_state_T state[]; } nfa_regprog_T; -// Structure to be used for single-line matching. -// Sub-match "no" starts at "startp[no]" and ends just before "endp[no]". -// When there is no match, the pointer is NULL. +/// Structure to be used for single-line matching. +/// Sub-match "no" starts at "startp[no]" and ends just before "endp[no]". +/// When there is no match, the pointer is NULL. typedef struct { regprog_T *regprog; char *startp[NSUBEXP]; @@ -152,9 +157,9 @@ typedef struct { bool rm_ic; } regmatch_T; -// Structure used to store external references: "\z\(\)" to "\z\1". -// Use a reference count to avoid the need to copy this around. When it goes -// from 1 to zero the matches need to be freed. +/// Structure used to store external references: "\z\(\)" to "\z\1". +/// Use a reference count to avoid the need to copy this around. When it goes +/// from 1 to zero the matches need to be freed. struct reg_extmatch { int16_t refcnt; uint8_t *matches[NSUBEXP]; @@ -172,7 +177,9 @@ struct regengine { // uint8_t *expr; }; -// Flags used by vim_regsub() and vim_regsub_both() -#define REGSUB_COPY 1 -#define REGSUB_MAGIC 2 -#define REGSUB_BACKSLASH 4 +/// Flags used by vim_regsub() and vim_regsub_both() +enum { + REGSUB_COPY = 1, + REGSUB_MAGIC = 2, + REGSUB_BACKSLASH = 4, +}; -- cgit