diff options
84 files changed, 843 insertions, 2239 deletions
diff --git a/cmake.deps/CMakeLists.txt b/cmake.deps/CMakeLists.txt index 76eadb88bd..4659183d19 100644 --- a/cmake.deps/CMakeLists.txt +++ b/cmake.deps/CMakeLists.txt @@ -157,8 +157,8 @@ set(LIBTERMKEY_SHA256 6945bd3c4aaa83da83d80a045c5563da4edd7d0374c62c0d35aec09eb3 set(LIBVTERM_URL https://launchpad.net/libvterm/trunk/v0.3/+download/libvterm-0.3.1.tar.gz) set(LIBVTERM_SHA256 25a8ad9c15485368dfd0a8a9dca1aec8fea5c27da3fa74ec518d5d3787f0c397) -set(LUV_URL https://github.com/luvit/luv/archive/e5da6417db06a09d75bb5315662a2cf3e48a4a89.tar.gz) -set(LUV_SHA256 16720d17b9e6d42a7008b902207ea2d61e3eeaef3cf358398dbbf3777867ec09) +set(LUV_URL https://github.com/luvit/luv/archive/093a977b82077591baefe1e880d37dfa2730bd54.tar.gz) +set(LUV_SHA256 222b38b6425f0926218e14e7da81481fdde6f9660c1feac25a53e6fb52e886e6) set(LUA_COMPAT53_URL https://github.com/keplerproject/lua-compat-5.3/archive/v0.9.tar.gz) set(LUA_COMPAT53_SHA256 ad05540d2d96a48725bb79a1def35cf6652a4e2ec26376e2617c8ce2baa6f416) @@ -191,11 +191,11 @@ set(TREESITTER_C_SHA256 af66fde03feb0df4faf03750102a0d265b007e5d957057b6b293c131 set(TREESITTER_LUA_URL https://github.com/MunifTanjim/tree-sitter-lua/archive/v0.0.14.tar.gz) set(TREESITTER_LUA_SHA256 930d0370dc15b66389869355c8e14305b9ba7aafd36edbfdb468c8023395016d) -set(TREESITTER_VIM_URL https://github.com/vigoux/tree-sitter-viml/archive/55ff1b080c09edeced9b748cf4c16d0b49d17fb9.tar.gz) -set(TREESITTER_VIM_SHA256 1b1cd39e33c8fb02fa7fe3977e844883c2a8508a7edd621f2d21e39a9aeefa92) +set(TREESITTER_VIM_URL https://github.com/vigoux/tree-sitter-viml/archive/e39a7bbcfdcfc7900629962b785c7e14503ae590.tar.gz) +set(TREESITTER_VIM_SHA256 7ca85fa1a5a9e4d057ff3b7ae53d13d31371973e734ada87a83f3f6cbe9c0e32) -set(TREESITTER_HELP_URL https://github.com/neovim/tree-sitter-vimdoc/archive/v1.3.0.tar.gz) -set(TREESITTER_HELP_SHA256 f33f6d49c7d71feb2fd68ef2b2684da150f9f8e486ad9726213631d673942331) +set(TREESITTER_VIMDOC_URL https://github.com/neovim/tree-sitter-vimdoc/archive/b2ec4ec5f7be24cb6f7ccffafd7204477fe5784a.tar.gz) +set(TREESITTER_VIMDOC_SHA256 0689a57d455243de6c6a6c8737a8ce137e225eb8f32676a7037f7dd13dfaec5d) set(TREESITTER_QUERY_URL https://github.com/nvim-treesitter/tree-sitter-query/archive/v0.1.0.tar.gz) set(TREESITTER_QUERY_SHA256 e2b806f80e8bf1c4f4e5a96248393fe6622fc1fc6189d6896d269658f67f914c) diff --git a/cmake.deps/cmake/BuildTreesitterParsers.cmake b/cmake.deps/cmake/BuildTreesitterParsers.cmake index 1202e4f7a4..ef7d521249 100644 --- a/cmake.deps/cmake/BuildTreesitterParsers.cmake +++ b/cmake.deps/cmake/BuildTreesitterParsers.cmake @@ -38,9 +38,9 @@ BuildTSParser( CMAKE_FILE TreesitterParserCMakeLists.txt) BuildTSParser( - LANG help - URL ${TREESITTER_HELP_URL} - SHA256 ${TREESITTER_HELP_SHA256} + LANG vimdoc + URL ${TREESITTER_VIMDOC_URL} + SHA256 ${TREESITTER_VIMDOC_SHA256} CMAKE_FILE TreesitterParserCMakeLists.txt) BuildTSParser( diff --git a/runtime/doc/api.txt b/runtime/doc/api.txt index 844bf772f1..3c3e66dd57 100644 --- a/runtime/doc/api.txt +++ b/runtime/doc/api.txt @@ -2546,6 +2546,8 @@ nvim_buf_get_extmark_by_id({buffer}, {ns_id}, {id}, {opts}) • {id} Extmark id • {opts} Optional parameters. Keys: • details: Whether to include the details dict + • hl_name: Whether to include highlight group name instead + of id, true if omitted Return: ~ 0-indexed (row, col) tuple or empty list () if extmark id was absent @@ -2582,7 +2584,8 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {opts}) Parameters: ~ • {buffer} Buffer handle, or 0 for current buffer - • {ns_id} Namespace id from |nvim_create_namespace()| + • {ns_id} Namespace id from |nvim_create_namespace()| or -1 for all + namespaces • {start} Start of range: a 0-indexed (row, col) or valid extmark id (whose position defines the bound). |api-indexing| • {end} End of range (inclusive): a 0-indexed (row, col) or valid @@ -2590,7 +2593,11 @@ nvim_buf_get_extmarks({buffer}, {ns_id}, {start}, {end}, {opts}) |api-indexing| • {opts} Optional parameters. Keys: • limit: Maximum number of marks to return - • details Whether to include the details dict + • details: Whether to include the details dict + • hl_name: Whether to include highlight group name instead + of id, true if omitted + • type: Filter marks by type: "highlight", "sign", + "virt_text" and "virt_lines" Return: ~ List of [extmark_id, row, col] tuples in "traversal order". diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt index 14f2ba2b04..ebbf8bb463 100644 --- a/runtime/doc/lua.txt +++ b/runtime/doc/lua.txt @@ -1635,8 +1635,8 @@ defaulttable({create}) *vim.defaulttable()* < Parameters: ~ - • {create} (function|nil) The function called to create a missing - value. + • {create} function?(key:any):any The function called to create a + missing value. Return: ~ (table) Empty table with metamethod diff --git a/runtime/doc/luvref.txt b/runtime/doc/luvref.txt index 0fdd010880..799d0f6f74 100644 --- a/runtime/doc/luvref.txt +++ b/runtime/doc/luvref.txt @@ -91,7 +91,7 @@ used here to facilitate documenting consistent behavior: metamethod - `buffer`: a `string` or a sequential `table` of `string`s - `threadargs`: variable arguments (`...`) of type `nil`, `boolean`, `number`, - `string`, or `userdata` + `string`, or `userdata`; number of arguments limited to 9. ============================================================================== CONTENTS *luv-contents* @@ -2576,7 +2576,7 @@ uv.fs_poll_start({fs_poll}, {path}, {interval}, {callback}) *uv.fs_poll_start()* > method form `fs_poll:start(path, interval, callback)` Parameters: - - `fs_event`: `uv_fs_event_t userdata` + - `fs_poll`: `uv_fs_poll_t userdata` - `path`: `string` - `interval`: `integer` - `callback`: `callable` @@ -3484,6 +3484,9 @@ uv.new_thread([{options}, ] {entry}, {...}) *uv.new_thread()* Returns: `luv_thread_t userdata` or `fail` + Note: unsafe, please make sure that the thread's end of life + is before Lua state is closed. + uv.thread_equal({thread}, {other_thread}) *uv.thread_equal()* > method form `thread:equal(other_thread)` diff --git a/runtime/doc/news.txt b/runtime/doc/news.txt index 401719b432..7b71b53b29 100644 --- a/runtime/doc/news.txt +++ b/runtime/doc/news.txt @@ -62,11 +62,20 @@ The following changes may require adaptations in user config or plugins. • |nvim_exec()| is now deprecated in favor of |nvim_exec2()|. +• `help` treesitter parser was renamed to `vimdoc`. The only user-visible + change is that language-specific highlight groups need to be renamed from + `@foo.help` to `@foo.vimdoc`. + ============================================================================== NEW FEATURES *news-features* The following new APIs or features were added. +• |nvim_buf_get_extmarks()| now accepts a -1 `ns_id` to request extmarks from + all namespaces and adds the namespace id to the details array. + Other missing properties have been added to the details array and marks can + be filtered by type. + • Added a new experimental |lua-loader| that byte-compiles and caches lua files. To enable the new loader, add the following at the top of your |init.lua|: >lua vim.loader.enable() diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt index 96021d6272..0298f5a9b1 100644 --- a/runtime/doc/treesitter.txt +++ b/runtime/doc/treesitter.txt @@ -195,7 +195,7 @@ treesitter queries from Lua. TREESITTER QUERY PREDICATES *treesitter-predicates* Predicates are special scheme nodes that are evaluated to conditionally capture -nodes. For example, the `eq?` predicate can be used as follows: > +nodes. For example, the `eq?` predicate can be used as follows: >query ((identifier) @foo (#eq? @foo "foo")) < @@ -204,13 +204,13 @@ to only match identifier corresponding to the `"foo"` text. The following predicates are built in: `eq?` *treesitter-predicate-eq?* - Match a string against the text corresponding to a node: > + Match a string against the text corresponding to a node: >query ((identifier) @foo (#eq? @foo "foo")) ((node1) @left (node2) @right (#eq? @left @right)) < `match?` *treesitter-predicate-match?* `vim-match?` *treesitter-predicate-vim-match?* - Match a |regexp| against the text corresponding to a node: > + Match a |regexp| against the text corresponding to a node: >query ((identifier) @constant (#match? @constant "^[A-Z_]+$")) < Note: The `^` and `$` anchors will match the start and end of the node's text. @@ -220,13 +220,14 @@ The following predicates are built in: similar to `match?` `contains?` *treesitter-predicate-contains?* - Match a string against parts of the text corresponding to a node: > + Match a string against parts of the text corresponding to a node: + >query ((identifier) @foo (#contains? @foo "foo")) ((identifier) @foo-bar (#contains? @foo-bar "foo" "bar")) < `any-of?` *treesitter-predicate-any-of?* Match any of the given strings against the text corresponding to - a node: > + a node: >query ((identifier) @foo (#any-of? @foo "foo" "bar")) < This is the recommended way to check if the node matches one of many @@ -243,7 +244,7 @@ Use |vim.treesitter.query.list_predicates()| to list all available predicates. TREESITTER QUERY DIRECTIVES *treesitter-directives* Treesitter directives store metadata for a node or match and perform side -effects. For example, the `set!` directive sets metadata on the match or node: > +effects. For example, the `set!` directive sets metadata on the match or node: >query ((identifier) @foo (#set! "type" "parameter")) < @@ -259,7 +260,7 @@ The following directives are built in: {key} {value} - Examples: > + Examples: >query ((identifier) @foo (#set! @foo "kind" "parameter")) ((node1) @left (node2) @right (#set! "type" "pair")) < @@ -275,7 +276,7 @@ The following directives are built in: {end_row} {end_col} - Example: > + Example: >query ((identifier) @constant (#offset! @constant 0 1 0 -1)) < @@ -304,7 +305,8 @@ currently supported modeline alternatives: a base depends on your 'runtimepath' value. Note: These modeline comments must be at the top of the query, but can be -repeated, for example, the following two modeline blocks are both valid: > +repeated, for example, the following two modeline blocks are both valid: +>query ;; inherits: foo,bar ;; extends @@ -318,13 +320,13 @@ TREESITTER SYNTAX HIGHLIGHTING *treesitter-highlight* Syntax highlighting is specified through queries named `highlights.scm`, which match a |TSNode| in the parsed |TSTree| to a `capture` that can be -assigned a highlight group. For example, the query > +assigned a highlight group. For example, the query >query (parameters (identifier) @parameter) < matches any `identifier` node inside a function `parameter` node (e.g., the `bar` in `foo(bar)`) to the capture named `@parameter`. It is also possible to -match literal expressions (provided the parser returns them): > +match literal expressions (provided the parser returns them): >query "return" @keyword.return < @@ -409,7 +411,7 @@ The following captures are linked by default to standard |group-name|s: *treesitter-highlight-spell* The special `@spell` capture can be used to indicate that a node should be spell checked by Nvim's builtin |spell| checker. For example, the following -capture marks comments as to be checked: > +capture marks comments as to be checked: >query (comment) @spell < @@ -420,14 +422,14 @@ There is also `@nospell` which disables spellchecking regions with `@spell`. Treesitter highlighting supports |conceal| via the `conceal` metadata. By convention, nodes to be concealed are captured as `@conceal`, but any capture can be used. For example, the following query can be used to hide code block -delimiters in Markdown: > +delimiters in Markdown: >query - (fenced_code_block_delimiter) @conceal (#set! conceal "") + (fenced_code_block_delimiter @conceal (#set! conceal "")) < It is also possible to replace a node with a single character, which (unlike legacy syntax) can be given a custom highlight. For example, the following (ill-advised) query replaces the `!=` operator by a Unicode glyph, which is -still highlighted the same as other operators: > +still highlighted the same as other operators: >query "!=" @operator (#set! conceal "≠") < @@ -438,9 +440,10 @@ Treesitter uses |nvim_buf_set_extmark()| to set highlights with a default priority of 100. This enables plugins to set a highlighting priority lower or higher than tree-sitter. It is also possible to change the priority of an individual query pattern manually by setting its `"priority"` metadata -attribute: > +attribute: >query - (super_important_node) @ImportantHighlight (#set! "priority" 105) + ((super_important_node) @superimportant (#set! "priority" 105)) +< ============================================================================== TREESITTER LANGUAGE INJECTIONS *treesitter-language-injections* diff --git a/runtime/lua/vim/shared.lua b/runtime/lua/vim/shared.lua index 884929e33a..9e337e93e8 100644 --- a/runtime/lua/vim/shared.lua +++ b/runtime/lua/vim/shared.lua @@ -796,13 +796,15 @@ end --- a.b.c = 1 --- </pre> --- ----@param create function|nil The function called to create a missing value. +---@param create function?(key:any):any The function called to create a missing value. ---@return table Empty table with metamethod function vim.defaulttable(create) - create = create or vim.defaulttable + create = create or function(_) + return vim.defaulttable() + end return setmetatable({}, { __index = function(tbl, key) - rawset(tbl, key, create()) + rawset(tbl, key, create(key)) return rawget(tbl, key) end, }) diff --git a/runtime/lua/vim/treesitter/health.lua b/runtime/lua/vim/treesitter/health.lua index fd1188fde4..dabf2cdf6c 100644 --- a/runtime/lua/vim/treesitter/health.lua +++ b/runtime/lua/vim/treesitter/health.lua @@ -22,7 +22,7 @@ function M.check() ) ) else - local lang = ts.language.inspect_language(parsername) + local lang = ts.language.inspect(parsername) health.report_ok( string.format('Parser: %-10s ABI: %d, path: %s', parsername, lang._abi_version, parser) ) diff --git a/runtime/lua/vim/treesitter/language.lua b/runtime/lua/vim/treesitter/language.lua index b1c788e6ba..5b74bb6200 100644 --- a/runtime/lua/vim/treesitter/language.lua +++ b/runtime/lua/vim/treesitter/language.lua @@ -4,7 +4,9 @@ local a = vim.api local M = {} ---@type table<string,string> -local ft_to_lang = {} +local ft_to_lang = { + help = 'vimdoc', +} --- Get the filetypes associated with the parser named {lang}. --- @param lang string Name of parser diff --git a/runtime/queries/c/highlights.scm b/runtime/queries/c/highlights.scm index 33e6df74ab..dee70f9cc7 100644 --- a/runtime/queries/c/highlights.scm +++ b/runtime/queries/c/highlights.scm @@ -1,22 +1,19 @@ -(identifier) @variable +; Lower priority to prefer @parameter when identifier appears in parameter_declaration. +((identifier) @variable (#set! "priority" 95)) [ - "const" "default" "enum" - "extern" - "inline" - "return" - "sizeof" - "static" "struct" "typedef" "union" - "volatile" "goto" - "register" ] @keyword +"sizeof" @keyword.operator + +"return" @keyword.return + [ "while" "for" @@ -32,7 +29,6 @@ "switch" ] @conditional -"#define" @constant.macro [ "#if" "#ifdef" @@ -41,10 +37,18 @@ "#elif" "#endif" (preproc_directive) -] @keyword +] @preproc + +"#define" @define "#include" @include +[ ";" ":" "," ] @punctuation.delimiter + +"..." @punctuation.special + +[ "(" ")" "[" "]" "{" "}"] @punctuation.bracket + [ "=" @@ -62,6 +66,7 @@ ">>" "->" + "." "<" "<=" @@ -88,35 +93,25 @@ "++" ] @operator +;; Make sure the comma operator is given a highlight group after the comma +;; punctuator so the operator is highlighted properly. +(comma_expression [ "," ] @operator) + [ (true) (false) ] @boolean -[ "." ";" ":" "," ] @punctuation.delimiter - -(conditional_expression [ "?" ":" ] @conditional) - - -[ "(" ")" "[" "]" "{" "}"] @punctuation.bracket +(conditional_expression [ "?" ":" ] @conditional.ternary) (string_literal) @string -(string_literal) @spell (system_lib_string) @string +(escape_sequence) @string.escape (null) @constant.builtin (number_literal) @number -(char_literal) @number +(char_literal) @character -(call_expression - function: (identifier) @function) -(call_expression - function: (field_expression - field: (field_identifier) @function)) -(function_declarator - declarator: (identifier) @function) -(preproc_function_def - name: (identifier) @function.macro) [ (preproc_arg) (preproc_defined) @@ -126,18 +121,32 @@ (statement_identifier) @label [ -(type_identifier) -(primitive_type) -(sized_type_specifier) -(type_descriptor) - ] @type + (type_identifier) + (sized_type_specifier) + (type_descriptor) +] @type + +(storage_class_specifier) @storageclass + +(type_qualifier) @type.qualifier + +(linkage_specification + "extern" @storageclass) -(declaration (type_qualifier) @type) -(cast_expression type: (type_descriptor) @type) -(sizeof_expression value: (parenthesized_expression (identifier) @type)) +(type_definition + declarator: (type_identifier) @type.definition) + +(primitive_type) @type.builtin ((identifier) @constant - (#match? @constant "^[A-Z][A-Z0-9_]+$")) + (#lua-match? @constant "^[A-Z][A-Z0-9_]+$")) +(enumerator + name: (identifier) @constant) +(case_statement + value: (identifier) @constant) + +((identifier) @constant.builtin + (#any-of? @constant.builtin "stderr" "stdin" "stdout")) ;; Preproc def / undef (preproc_def @@ -147,9 +156,20 @@ argument: (_) @constant (#eq? @_u "#undef")) +(call_expression + function: (identifier) @function.call) +(call_expression + function: (field_expression + field: (field_identifier) @function.call)) +(function_declarator + declarator: (identifier) @function) +(preproc_function_def + name: (identifier) @function.macro) + +(comment) @comment @spell -(comment) @comment -(comment) @spell +((comment) @comment.documentation + (#lua-match? @comment.documentation "^/[*][*][^*].*[*]/$")) ;; Parameters (parameter_declaration @@ -158,7 +178,20 @@ (parameter_declaration declarator: (pointer_declarator) @parameter) -(preproc_params - (identifier)) @parameter +(preproc_params (identifier) @parameter) + +[ + "__attribute__" + "__cdecl" + "__clrcall" + "__stdcall" + "__fastcall" + "__thiscall" + "__vectorcall" + "_unaligned" + "__unaligned" + "__declspec" + (attribute_declaration) +] @attribute (ERROR) @error diff --git a/runtime/queries/c/injections.scm b/runtime/queries/c/injections.scm index 84ae33683e..3b99c7a444 100644 --- a/runtime/queries/c/injections.scm +++ b/runtime/queries/c/injections.scm @@ -1,5 +1,5 @@ -((preproc_arg) @injection.content - (#set! injection.language "c")) +; ((preproc_arg) @injection.content +; (#set! injection.language "c")) ; ((comment) @injection.content ; (#set! injection.language "comment")) diff --git a/runtime/queries/lua/highlights.scm b/runtime/queries/lua/highlights.scm index 2c0dc5447a..5fbf8a1833 100644 --- a/runtime/queries/lua/highlights.scm +++ b/runtime/queries/lua/highlights.scm @@ -8,8 +8,6 @@ "local" ] @keyword -(label_statement) @label - (break_statement) @keyword (do_statement @@ -109,6 +107,7 @@ [ ";" ":" + "::" "," "." ] @punctuation.delimiter @@ -129,12 +128,21 @@ (identifier) @variable ((identifier) @variable.builtin - (#eq? @variable.builtin "self")) + (#any-of? @variable.builtin "_G" "_VERSION" "debug" "io" "jit" "math" "os" "package" "self" "string" "table" "utf8")) + +((identifier) @keyword.coroutine + (#eq? @keyword.coroutine "coroutine")) (variable_list - attribute: (attribute - (["<" ">"] @punctuation.bracket - (identifier) @attribute))) + attribute: (attribute + (["<" ">"] @punctuation.bracket + (identifier) @attribute))) + +;; Labels + +(label_statement (identifier) @label) + +(goto_statement (identifier) @label) ;; Constants @@ -172,7 +180,7 @@ (function_call name: (dot_index_expression field: (identifier) @function.call)) (function_declaration name: (dot_index_expression field: (identifier) @function)) -(method_index_expression method: (identifier) @method) +(method_index_expression method: (identifier) @method.call) (function_call (identifier) @function.builtin @@ -180,20 +188,27 @@ ;; built-in functions in Lua 5.1 "assert" "collectgarbage" "dofile" "error" "getfenv" "getmetatable" "ipairs" "load" "loadfile" "loadstring" "module" "next" "pairs" "pcall" "print" - "rawequal" "rawget" "rawset" "require" "select" "setfenv" "setmetatable" - "tonumber" "tostring" "type" "unpack" "xpcall")) + "rawequal" "rawget" "rawlen" "rawset" "require" "select" "setfenv" "setmetatable" + "tonumber" "tostring" "type" "unpack" "xpcall" + "__add" "__band" "__bnot" "__bor" "__bxor" "__call" "__concat" "__div" "__eq" "__gc" + "__idiv" "__index" "__le" "__len" "__lt" "__metatable" "__mod" "__mul" "__name" "__newindex" + "__pairs" "__pow" "__shl" "__shr" "__sub" "__tostring" "__unm")) ;; Others -(comment) @comment -(comment) @spell +(comment) @comment @spell + +((comment) @comment.documentation + (#lua-match? @comment.documentation "^[-][-][-]")) + +((comment) @comment.documentation + (#lua-match? @comment.documentation "^[-][-](%s?)@")) -(hash_bang_line) @comment +(hash_bang_line) @preproc (number) @number -(string) @string -(string) @spell +(string) @string @spell ;; Error (ERROR) @error diff --git a/runtime/queries/lua/injections.scm b/runtime/queries/lua/injections.scm index 10eb4c4054..1c7bdaf951 100644 --- a/runtime/queries/lua/injections.scm +++ b/runtime/queries/lua/injections.scm @@ -11,18 +11,18 @@ name: (_) @_vimcmd_identifier arguments: (arguments (string content: _ @injection.content))) (#set! injection.language "vim") - (#any-of? @_vimcmd_identifier "vim.cmd" "vim.api.nvim_command" "vim.api.nvim_exec" "vim.api.nvim_cmd")) + (#any-of? @_vimcmd_identifier "vim.cmd" "vim.api.nvim_command" "vim.api.nvim_exec2" "vim.api.nvim_cmd")) ((function_call name: (_) @_vimcmd_identifier arguments: (arguments (string content: _ @injection.content) .)) (#set! injection.language "query") - (#eq? @_vimcmd_identifier "vim.treesitter.query.set_query")) + (#any-of? @_vimcmd_identifier "vim.treesitter.query.set" "vim.treesitter.query.parse")) -; ;; highlight string as query if starts with `;; query` -; ((string ("string_content") @injection.content) -; (#set! injection.language "query") -; (#lua-match? @injection.content "^%s*;+%s?query")) +;; highlight string as query if starts with `;; query` +((string ("string_content") @injection.content) + (#set! injection.language "query") + (#lua-match? @injection.content "^%s*;+%s?query")) ; ((comment) @injection.content ; (#set! injection.language "comment")) diff --git a/runtime/queries/vim/highlights.scm b/runtime/queries/vim/highlights.scm index 239b0a0b37..ce25b13b9f 100644 --- a/runtime/queries/vim/highlights.scm +++ b/runtime/queries/vim/highlights.scm @@ -271,7 +271,7 @@ ":" ] @punctuation.delimiter -(ternary_expression ["?" ":"] @conditional) +(ternary_expression ["?" ":"] @conditional.ternary) ; Options ((set_value) @number diff --git a/runtime/queries/help/highlights.scm b/runtime/queries/vimdoc/highlights.scm index c0d88301bc..c0d88301bc 100644 --- a/runtime/queries/help/highlights.scm +++ b/runtime/queries/vimdoc/highlights.scm diff --git a/runtime/queries/help/injections.scm b/runtime/queries/vimdoc/injections.scm index 260a05d863..260a05d863 100644 --- a/runtime/queries/help/injections.scm +++ b/runtime/queries/vimdoc/injections.scm diff --git a/scripts/gen_help_html.lua b/scripts/gen_help_html.lua index 2563f2f410..367ce60765 100644 --- a/scripts/gen_help_html.lua +++ b/scripts/gen_help_html.lua @@ -624,7 +624,7 @@ local function get_helptags(help_dir) return m end --- Use the help.so parser defined in the build, not whatever happens to be installed on the system. +-- Use the vimdoc parser defined in the build, not whatever happens to be installed on the system. local function ensure_runtimepath() if not vim.o.runtimepath:find('build/lib/nvim/') then vim.cmd[[set runtimepath^=./build/lib/nvim/]] @@ -643,8 +643,8 @@ local function parse_buf(fname) buf = fname vim.cmd('sbuffer '..tostring(fname)) -- Buffer number. end - -- vim.treesitter.require_language('help', './build/lib/nvim/parser/help.so') - local lang_tree = vim.treesitter.get_parser(buf, 'help') + -- vim.treesitter.require_language('help', './build/lib/nvim/parser/vimdoc.so') + local lang_tree = vim.treesitter.get_parser(buf) return lang_tree, buf end diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c index adc2925b7e..4afbdfa487 100644 --- a/src/nvim/api/extmark.c +++ b/src/nvim/api/extmark.c @@ -105,7 +105,16 @@ bool ns_initialized(uint32_t ns) return ns < (uint32_t)next_namespace_id; } -static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict) +static Object hl_group_name(int hl_id, bool hl_name) +{ + if (hl_name) { + return STRING_OBJ(cstr_to_string(syn_id2name(hl_id))); + } else { + return INTEGER_OBJ(hl_id); + } +} + +static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict, bool hl_name) { Array rv = ARRAY_DICT_INIT; if (id) { @@ -117,6 +126,8 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict if (add_dict) { Dictionary dict = ARRAY_DICT_INIT; + PUT(dict, "ns_id", INTEGER_OBJ((Integer)extmark->ns_id)); + PUT(dict, "right_gravity", BOOLEAN_OBJ(extmark->right_gravity)); if (extmark->end_row >= 0) { @@ -127,8 +138,7 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict const Decoration *decor = &extmark->decor; if (decor->hl_id) { - String name = cstr_to_string((const char *)syn_id2name(decor->hl_id)); - PUT(dict, "hl_group", STRING_OBJ(name)); + PUT(dict, "hl_group", hl_group_name(decor->hl_id, hl_name)); PUT(dict, "hl_eol", BOOLEAN_OBJ(decor->hl_eol)); } if (decor->hl_mode) { @@ -142,8 +152,7 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict VirtTextChunk *vtc = &decor->virt_text.items[i]; ADD(chunk, STRING_OBJ(cstr_to_string(vtc->text))); if (vtc->hl_id > 0) { - ADD(chunk, - STRING_OBJ(cstr_to_string((const char *)syn_id2name(vtc->hl_id)))); + ADD(chunk, hl_group_name(vtc->hl_id, hl_name)); } ADD(chunks, ARRAY_OBJ(chunk)); } @@ -172,8 +181,7 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict VirtTextChunk *vtc = &vt->items[j]; ADD(chunk, STRING_OBJ(cstr_to_string(vtc->text))); if (vtc->hl_id > 0) { - ADD(chunk, - STRING_OBJ(cstr_to_string((const char *)syn_id2name(vtc->hl_id)))); + ADD(chunk, hl_group_name(vtc->hl_id, hl_name)); } ADD(chunks, ARRAY_OBJ(chunk)); } @@ -184,10 +192,44 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict PUT(dict, "virt_lines_leftcol", BOOLEAN_OBJ(virt_lines_leftcol)); } - if (decor->hl_id || kv_size(decor->virt_text) || decor->ui_watched) { + if (decor->sign_text) { + PUT(dict, "sign_text", STRING_OBJ(cstr_to_string(decor->sign_text))); + } + + // uncrustify:off + + struct { char *name; const int val; } hls[] = { + { "sign_hl_group" , decor->sign_hl_id }, + { "number_hl_group" , decor->number_hl_id }, + { "line_hl_group" , decor->line_hl_id }, + { "cursorline_hl_group", decor->cursorline_hl_id }, + { NULL, 0 }, + }; + + // uncrustify:on + + for (int j = 0; hls[j].name && hls[j].val; j++) { + if (hls[j].val) { + PUT(dict, hls[j].name, hl_group_name(hls[j].val, hl_name)); + } + } + + if (decor->sign_text + || decor->hl_id + || kv_size(decor->virt_text) + || decor->ui_watched) { PUT(dict, "priority", INTEGER_OBJ(decor->priority)); } + if (decor->conceal) { + String name = cstr_to_string((char *)&decor->conceal_char); + PUT(dict, "conceal", STRING_OBJ(name)); + } + + if (decor->spell != kNone) { + PUT(dict, "spell", BOOLEAN_OBJ(decor->spell == kTrue)); + } + if (dict.size) { ADD(rv, DICTIONARY_OBJ(dict)); } @@ -203,6 +245,7 @@ static Array extmark_to_array(const ExtmarkInfo *extmark, bool id, bool add_dict /// @param id Extmark id /// @param opts Optional parameters. Keys: /// - details: Whether to include the details dict +/// - hl_name: Whether to include highlight group name instead of id, true if omitted /// @param[out] err Error details, if any /// @return 0-indexed (row, col) tuple or empty list () if extmark id was /// absent @@ -224,18 +267,19 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id, }); bool details = false; + bool hl_name = true; for (size_t i = 0; i < opts.size; i++) { String k = opts.items[i].key; Object *v = &opts.items[i].value; if (strequal("details", k.data)) { - if (v->type == kObjectTypeBoolean) { - details = v->data.boolean; - } else if (v->type == kObjectTypeInteger) { - details = v->data.integer; - } else { - VALIDATE_EXP(false, "details", "Boolean or Integer", api_typename(v->type), { - return rv; - }); + details = api_object_to_bool(*v, "details", false, err); + if (ERROR_SET(err)) { + return rv; + } + } else if (strequal("hl_name", k.data)) { + hl_name = api_object_to_bool(*v, "hl_name", false, err); + if (ERROR_SET(err)) { + return rv; } } else { VALIDATE_S(false, "'opts' key", k.data, { @@ -248,7 +292,7 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id, if (extmark.row < 0) { return rv; } - return extmark_to_array(&extmark, false, details); + return extmark_to_array(&extmark, false, details, hl_name); } /// Gets |extmarks| in "traversal order" from a |charwise| region defined by @@ -282,14 +326,16 @@ ArrayOf(Integer) nvim_buf_get_extmark_by_id(Buffer buffer, Integer ns_id, /// </pre> /// /// @param buffer Buffer handle, or 0 for current buffer -/// @param ns_id Namespace id from |nvim_create_namespace()| +/// @param ns_id Namespace id from |nvim_create_namespace()| or -1 for all namespaces /// @param start Start of range: a 0-indexed (row, col) or valid extmark id /// (whose position defines the bound). |api-indexing| /// @param end End of range (inclusive): a 0-indexed (row, col) or valid /// extmark id (whose position defines the bound). |api-indexing| /// @param opts Optional parameters. Keys: /// - limit: Maximum number of marks to return -/// - details Whether to include the details dict +/// - details: Whether to include the details dict +/// - hl_name: Whether to include highlight group name instead of id, true if omitted +/// - type: Filter marks by type: "highlight", "sign", "virt_text" and "virt_lines" /// @param[out] err Error details, if any /// @return List of [extmark_id, row, col] tuples in "traversal order". Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object end, Dictionary opts, @@ -303,12 +349,20 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object e return rv; } - VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, { - return rv; - }); + bool all_ns; + if (ns_id == -1) { + all_ns = true; + } else { + VALIDATE_INT(ns_initialized((uint32_t)ns_id), "ns_id", ns_id, { + return rv; + }); + all_ns = false; + } Integer limit = -1; bool details = false; + bool hl_name = true; + ExtmarkType type = kExtmarkNone; for (size_t i = 0; i < opts.size; i++) { String k = opts.items[i].key; @@ -319,12 +373,29 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object e }); limit = v->data.integer; } else if (strequal("details", k.data)) { - if (v->type == kObjectTypeBoolean) { - details = v->data.boolean; - } else if (v->type == kObjectTypeInteger) { - details = v->data.integer; + details = api_object_to_bool(*v, "details", false, err); + if (ERROR_SET(err)) { + return rv; + } + } else if (strequal("hl_name", k.data)) { + hl_name = api_object_to_bool(*v, "hl_name", false, err); + if (ERROR_SET(err)) { + return rv; + } + } else if (strequal("type", k.data)) { + VALIDATE_EXP(v->type == kObjectTypeString, "type", "String", api_typename(v->type), { + return rv; + }); + if (strequal(v->data.string.data, "sign")) { + type = kExtmarkSign; + } else if (strequal(v->data.string.data, "virt_text")) { + type = kExtmarkVirtText; + } else if (strequal(v->data.string.data, "virt_lines")) { + type = kExtmarkVirtLines; + } else if (strequal(v->data.string.data, "highlight")) { + type = kExtmarkHighlight; } else { - VALIDATE_EXP(false, "details", "Boolean or Integer", api_typename(v->type), { + VALIDATE_EXP(false, "type", "sign, virt_text, virt_lines or highlight", v->data.string.data, { return rv; }); } @@ -359,11 +430,11 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object e reverse = true; } - ExtmarkInfoArray marks = extmark_get(buf, (uint32_t)ns_id, l_row, l_col, - u_row, u_col, (int64_t)limit, reverse); + ExtmarkInfoArray marks = extmark_get(buf, (uint32_t)ns_id, l_row, l_col, u_row, + u_col, (int64_t)limit, reverse, all_ns, type); for (size_t i = 0; i < kv_size(marks); i++) { - ADD(rv, ARRAY_OBJ(extmark_to_array(&kv_A(marks, i), true, (bool)details))); + ADD(rv, ARRAY_OBJ(extmark_to_array(&kv_A(marks, i), true, (bool)details, hl_name))); } kv_destroy(marks); diff --git a/src/nvim/channel.c b/src/nvim/channel.c index f68ee2b39e..a0fe3cc734 100644 --- a/src/nvim/channel.c +++ b/src/nvim/channel.c @@ -218,7 +218,7 @@ void channel_create_event(Channel *chan, const char *ext_source) source = ext_source; } else { eval_fmt_source_name_line(IObuff, sizeof(IObuff)); - source = (const char *)IObuff; + source = IObuff; } assert(chan->id <= VARNUMBER_MAX); diff --git a/src/nvim/charset.c b/src/nvim/charset.c index a3aa6783ee..2be8ccc456 100644 --- a/src/nvim/charset.c +++ b/src/nvim/charset.c @@ -55,7 +55,7 @@ static bool chartab_initialized = false; ((chartab)[(unsigned)(c) >> 6] & (1ull << ((c) & 0x3f))) // Table used below, see init_chartab() for an explanation -static char_u g_chartab[256]; +static uint8_t g_chartab[256]; // Flags for g_chartab[]. #define CT_CELL_MASK 0x07 ///< mask: nr of display cells (1, 2 or 4) @@ -286,7 +286,7 @@ void trans_characters(char *buf, int bufsize) if ((trs_len = utfc_ptr2len(buf)) > 1) { len -= trs_len; } else { - trs = (char *)transchar_byte((uint8_t)(*buf)); + trs = transchar_byte((uint8_t)(*buf)); trs_len = (int)strlen(trs); if (trs_len > 1) { @@ -532,7 +532,7 @@ char *str_foldcase(char *str, int orglen, char *buf, int buflen) // Does NOT work for multi-byte characters, c must be <= 255. // Also doesn't work for the first byte of a multi-byte, "c" must be a // character! -static char_u transchar_charbuf[11]; +static uint8_t transchar_charbuf[11]; /// Translate a character into a printable one, leaving printable ASCII intact /// @@ -543,10 +543,10 @@ static char_u transchar_charbuf[11]; /// @return translated character into a static buffer. char *transchar(int c) { - return (char *)transchar_buf(curbuf, c); + return transchar_buf(curbuf, c); } -char_u *transchar_buf(const buf_T *buf, int c) +char *transchar_buf(const buf_T *buf, int c) { int i = 0; if (IS_SPECIAL(c)) { @@ -560,14 +560,14 @@ char_u *transchar_buf(const buf_T *buf, int c) if ((!chartab_initialized && (c >= ' ' && c <= '~')) || ((c <= 0xFF) && vim_isprintc_strict(c))) { // printable character - transchar_charbuf[i] = (char_u)c; + transchar_charbuf[i] = (uint8_t)c; transchar_charbuf[i + 1] = NUL; } else if (c <= 0xFF) { - transchar_nonprint(buf, transchar_charbuf + i, c); + transchar_nonprint(buf, (char *)transchar_charbuf + i, c); } else { transchar_hex((char *)transchar_charbuf + i, c); } - return transchar_charbuf; + return (char *)transchar_charbuf; } /// Like transchar(), but called with a byte instead of a character. @@ -577,7 +577,7 @@ char_u *transchar_buf(const buf_T *buf, int c) /// @param[in] c Byte to translate. /// /// @return pointer to translated character in transchar_charbuf. -char_u *transchar_byte(const int c) +char *transchar_byte(const int c) FUNC_ATTR_WARN_UNUSED_RESULT { return transchar_byte_buf(curbuf, c); @@ -590,12 +590,12 @@ char_u *transchar_byte(const int c) /// @param[in] c Byte to translate. /// /// @return pointer to translated character in transchar_charbuf. -char_u *transchar_byte_buf(const buf_T *buf, const int c) +char *transchar_byte_buf(const buf_T *buf, const int c) FUNC_ATTR_WARN_UNUSED_RESULT { if (c >= 0x80) { - transchar_nonprint(buf, transchar_charbuf, c); - return transchar_charbuf; + transchar_nonprint(buf, (char *)transchar_charbuf, c); + return (char *)transchar_charbuf; } return transchar_buf(buf, c); } @@ -609,7 +609,7 @@ char_u *transchar_byte_buf(const buf_T *buf, const int c) /// at least 5 bytes (conversion result + NUL). /// @param[in] c Character to convert. NUL is assumed to be NL according to /// `:h NL-used-for-NUL`. -void transchar_nonprint(const buf_T *buf, char_u *charbuf, int c) +void transchar_nonprint(const buf_T *buf, char *charbuf, int c) { if (c == NL) { // we use newline in place of a NUL @@ -622,12 +622,12 @@ void transchar_nonprint(const buf_T *buf, char_u *charbuf, int c) if (dy_flags & DY_UHEX || c > 0x7f) { // 'display' has "uhex" - transchar_hex((char *)charbuf, c); + transchar_hex(charbuf, c); } else { // 0x00 - 0x1f and 0x7f charbuf[0] = '^'; // DEL displayed as ^? - charbuf[1] = (char_u)(c ^ 0x40); + charbuf[1] = (char)(uint8_t)(c ^ 0x40); charbuf[2] = NUL; } @@ -755,7 +755,7 @@ int ptr2cells(const char *p_in) /// @param s /// /// @return number of character cells. -int vim_strsize(char *s) +int vim_strsize(const char *s) { return vim_strnsize(s, MAXCOL); } @@ -769,7 +769,7 @@ int vim_strsize(char *s) /// @param len /// /// @return Number of character cells. -int vim_strnsize(char *s, int len) +int vim_strnsize(const char *s, int len) { assert(s != NULL); int size = 0; diff --git a/src/nvim/charset.h b/src/nvim/charset.h index e1ef06ef1d..f98ed94b87 100644 --- a/src/nvim/charset.h +++ b/src/nvim/charset.h @@ -54,6 +54,6 @@ static inline bool vim_isbreak(int c) /// Used very often if 'linebreak' is set static inline bool vim_isbreak(int c) { - return breakat_flags[(char_u)c]; + return breakat_flags[(uint8_t)c]; } #endif // NVIM_CHARSET_H diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c index 6d8cf1c7e1..caad88c212 100644 --- a/src/nvim/drawline.c +++ b/src/nvim/drawline.c @@ -2371,7 +2371,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange, mb_c = c; mb_utf8 = check_mb_utf8(&c, u8cc); } else if (c != NUL) { - wlv.p_extra = (char *)transchar_buf(wp->w_buffer, c); + wlv.p_extra = transchar_buf(wp->w_buffer, c); if (wlv.n_extra == 0) { wlv.n_extra = byte2cells(c) - 1; } diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c index bccf8a352f..f90a41c406 100644 --- a/src/nvim/drawscreen.c +++ b/src/nvim/drawscreen.c @@ -941,9 +941,9 @@ int showmode(void) } if (length - vim_strsize(edit_submode) > 0) { if (edit_submode_pre != NULL) { - msg_puts_attr((const char *)edit_submode_pre, attr); + msg_puts_attr(edit_submode_pre, attr); } - msg_puts_attr((const char *)edit_submode, attr); + msg_puts_attr(edit_submode, attr); } if (edit_submode_extra != NULL) { msg_puts_attr(" ", attr); // Add a space in between. @@ -952,7 +952,7 @@ int showmode(void) } else { sub_attr = attr; } - msg_puts_attr((const char *)edit_submode_extra, sub_attr); + msg_puts_attr(edit_submode_extra, sub_attr); } } } else { diff --git a/src/nvim/edit.c b/src/nvim/edit.c index 26101d06ed..c551ec2726 100644 --- a/src/nvim/edit.c +++ b/src/nvim/edit.c @@ -1955,7 +1955,7 @@ static void insert_special(int c, int allow_modmask, int ctrlv) allow_modmask = true; } if (IS_SPECIAL(c) || (mod_mask && allow_modmask)) { - char *p = (char *)get_special_key_name(c, mod_mask); + char *p = get_special_key_name(c, mod_mask); int len = (int)strlen(p); c = (uint8_t)p[len - 1]; if (len > 2) { diff --git a/src/nvim/eval.c b/src/nvim/eval.c index fc9ddb75ef..edaa2bb809 100644 --- a/src/nvim/eval.c +++ b/src/nvim/eval.c @@ -596,7 +596,7 @@ int var_redir_start(char *name, int append) /// :redir => foo /// :let foo /// :redir END -void var_redir_str(char *value, int value_len) +void var_redir_str(const char *value, int value_len) { if (redir_lval == NULL) { return; @@ -2147,10 +2147,10 @@ int pattern_match(const char *pat, const char *text, bool ic) // avoid 'l' flag in 'cpoptions' char *save_cpo = p_cpo; p_cpo = empty_option; - regmatch.regprog = vim_regcomp((char *)pat, RE_MAGIC + RE_STRING); + regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); if (regmatch.regprog != NULL) { regmatch.rm_ic = ic; - matches = vim_regexec_nl(®match, (char *)text, (colnr_T)0); + matches = vim_regexec_nl(®match, text, (colnr_T)0); vim_regfree(regmatch.regprog); } p_cpo = save_cpo; diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c index df8004dc73..4286e16eb1 100644 --- a/src/nvim/eval/funcs.c +++ b/src/nvim/eval/funcs.c @@ -4670,7 +4670,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv, } } - regmatch.regprog = vim_regcomp((char *)pat, RE_MAGIC + RE_STRING); + regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING); if (regmatch.regprog != NULL) { regmatch.rm_ic = p_ic; @@ -6197,7 +6197,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) } # else char *v = os_realpath(fname, NULL); - rettv->vval.v_string = (char_u *)(v == NULL ? xstrdup(fname) : v); + rettv->vval.v_string = v == NULL ? xstrdup(fname) : v; # endif #endif @@ -7895,7 +7895,7 @@ static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) } regmatch_T regmatch = { - .regprog = vim_regcomp((char *)pat, RE_MAGIC + RE_STRING), + .regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING), .startp = { NULL }, .endp = { NULL }, .rm_ic = false, @@ -7906,7 +7906,7 @@ static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) if (*str == NUL) { match = false; // Empty item at the end. } else { - match = vim_regexec_nl(®match, (char *)str, col); + match = vim_regexec_nl(®match, str, col); } const char *end; if (match) { diff --git a/src/nvim/eval/typval_defs.h b/src/nvim/eval/typval_defs.h index 4615198441..80432271b0 100644 --- a/src/nvim/eval/typval_defs.h +++ b/src/nvim/eval/typval_defs.h @@ -206,7 +206,7 @@ typedef struct { struct { \ typval_T di_tv; /* Structure that holds scope dictionary itself. */ \ uint8_t di_flags; /* Flags. */ \ - char_u di_key[__VA_ARGS__]; /* Key value. */ /* NOLINT(runtime/arrays)*/ \ + char di_key[__VA_ARGS__]; /* Key value. */ /* NOLINT(runtime/arrays)*/ \ } /// Structure to hold a scope dictionary diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c index 13779f4173..40bca9acc1 100644 --- a/src/nvim/eval/userfunc.c +++ b/src/nvim/eval/userfunc.c @@ -90,7 +90,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int * bool mustend = false; char *arg = *argp; char *p = arg; - char_u c; + uint8_t c; int i; if (newargs != NULL) { @@ -128,7 +128,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int * } if (newargs != NULL) { ga_grow(newargs, 1); - c = (char_u)(*p); + c = (uint8_t)(*p); *p = NUL; arg = xstrdup(arg); @@ -159,7 +159,7 @@ static int get_function_args(char **argp, char endchar, garray_T *newargs, int * while (p > expr && ascii_iswhite(p[-1])) { p--; } - c = (char_u)(*p); + c = (uint8_t)(*p); *p = NUL; expr = xstrdup(expr); ((char **)(default_args->ga_data))[default_args->ga_len] = expr; diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c index ac3c8c4f8e..705f0fe83d 100644 --- a/src/nvim/ex_cmds.c +++ b/src/nvim/ex_cmds.c @@ -149,7 +149,7 @@ void do_ascii(const exarg_T *const eap) char buf1[20]; if (vim_isprintc_strict(c) && (c < ' ' || c > '~')) { char buf3[7]; - transchar_nonprint(curbuf, (char_u *)buf3, c); + transchar_nonprint(curbuf, buf3, c); vim_snprintf(buf1, sizeof(buf1), " <%s>", (char *)buf3); } else { buf1[0] = NUL; @@ -4742,7 +4742,7 @@ void ex_oldfiles(exarg_T *eap) } nr++; const char *fname = tv_get_string(TV_LIST_ITEM_TV(li)); - if (!message_filtered((char *)fname)) { + if (!message_filtered(fname)) { msg_outnum(nr); msg_puts(": "); msg_outtrans((char *)tv_get_string(TV_LIST_ITEM_TV(li))); diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c index c777efb445..a86676733f 100644 --- a/src/nvim/ex_cmds2.c +++ b/src/nvim/ex_cmds2.c @@ -201,7 +201,7 @@ void dialog_changed(buf_T *buf, bool checkall) .forceit = false, }; - dialog_msg((char *)buff, _("Save changes to \"%s\"?"), buf->b_fname); + dialog_msg(buff, _("Save changes to \"%s\"?"), buf->b_fname); if (checkall) { ret = vim_dialog_yesnoallcancel(VIM_QUESTION, NULL, buff, 1); } else { diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c index 5112505eda..bd7ddbf567 100644 --- a/src/nvim/ex_getln.c +++ b/src/nvim/ex_getln.c @@ -2117,7 +2117,7 @@ static int command_line_handle_key(CommandLineState *s) // put the character in the command line if (IS_SPECIAL(s->c) || mod_mask != 0) { - put_on_cmdline((char *)get_special_key_name(s->c, mod_mask), -1, true); + put_on_cmdline(get_special_key_name(s->c, mod_mask), -1, true); } else { int j = utf_char2bytes(s->c, IObuff); IObuff[j] = NUL; // exclude composing chars diff --git a/src/nvim/ex_session.c b/src/nvim/ex_session.c index 855a5f7538..d47d40cbee 100644 --- a/src/nvim/ex_session.c +++ b/src/nvim/ex_session.c @@ -959,7 +959,7 @@ void ex_mkrc(exarg_T *eap) // When using 'viewdir' may have to create the directory. if (using_vdir && !os_isdir(p_vdir)) { - vim_mkdir_emsg((const char *)p_vdir, 0755); + vim_mkdir_emsg(p_vdir, 0755); } fd = open_exfile(fname, eap->forceit, WRITEBIN); diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c index d385a2018f..32050c5b41 100644 --- a/src/nvim/extmark.c +++ b/src/nvim/extmark.c @@ -301,7 +301,8 @@ bool extmark_clear(buf_T *buf, uint32_t ns_id, int l_row, colnr_T l_col, int u_r /// dir can be set to control the order of the array /// amount = amount of marks to find or -1 for all ExtmarkInfoArray extmark_get(buf_T *buf, uint32_t ns_id, int l_row, colnr_T l_col, int u_row, - colnr_T u_col, int64_t amount, bool reverse) + colnr_T u_col, int64_t amount, bool reverse, bool all_ns, + ExtmarkType type_filter) { ExtmarkInfoArray array = KV_INITIAL_VALUE; MarkTreeIter itr[1]; @@ -320,7 +321,25 @@ ExtmarkInfoArray extmark_get(buf_T *buf, uint32_t ns_id, int l_row, colnr_T l_co goto next_mark; } - if (mark.ns == ns_id) { + uint16_t type_flags = kExtmarkNone; + if (type_filter != kExtmarkNone) { + Decoration *decor = mark.decor_full; + if (decor && (decor->sign_text || decor->number_hl_id)) { + type_flags |= kExtmarkSign; + } + if (decor && decor->virt_text.size) { + type_flags |= kExtmarkVirtText; + } + if (decor && decor->virt_lines.size) { + type_flags |= kExtmarkVirtLines; + } + if ((decor && (decor->line_hl_id || decor->cursorline_hl_id)) + || mark.hl_id) { + type_flags |= kExtmarkHighlight; + } + } + + if ((all_ns || mark.ns == ns_id) && type_flags & type_filter) { mtkey_t end = marktree_get_alt(buf->b_marktree, mark, NULL); kv_push(array, ((ExtmarkInfo) { .ns_id = mark.ns, .mark_id = mark.id, diff --git a/src/nvim/extmark.h b/src/nvim/extmark.h index 657e99a938..0b1f22aa84 100644 --- a/src/nvim/extmark.h +++ b/src/nvim/extmark.h @@ -76,6 +76,14 @@ typedef enum { kExtmarkClear, } UndoObjectType; +typedef enum { + kExtmarkNone = 0x1, + kExtmarkSign = 0x2, + kExtmarkVirtText = 0x4, + kExtmarkVirtLines = 0x8, + kExtmarkHighlight = 0x10, +} ExtmarkType; + // TODO(bfredl): reduce the number of undo action types struct undo_object { UndoObjectType type; diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c index e27c7c4349..d91e2dfeeb 100644 --- a/src/nvim/file_search.c +++ b/src/nvim/file_search.c @@ -794,7 +794,7 @@ char *vim_findfile(void *search_ctx_arg) ) { #ifdef FF_VERBOSE if (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list, - file_path, (char_u *)"") == FAIL) { + file_path, "") == FAIL) { if (p_verbose >= 5) { verbose_enter_scroll(); smsg("Already: %s", file_path); diff --git a/src/nvim/generators/gen_ex_cmds.lua b/src/nvim/generators/gen_ex_cmds.lua index 935d7b333e..26edd33604 100644 --- a/src/nvim/generators/gen_ex_cmds.lua +++ b/src/nvim/generators/gen_ex_cmds.lua @@ -41,7 +41,7 @@ static const uint16_t cmdidxs1[%u] = { -- Values in cmdidxs2[c1][c2] are relative to cmdidxs1[c1] so that they -- fit in a byte. local cmdidxs2_out = string.format([[ -static const char_u cmdidxs2[%u][%u] = { +static const uint8_t cmdidxs2[%u][%u] = { /* a b c d e f g h i j k l m n o p q r s t u v w x y z */ ]], a_to_z, a_to_z) diff --git a/src/nvim/generators/gen_options.lua b/src/nvim/generators/gen_options.lua index edb7dae159..54b97c5286 100644 --- a/src/nvim/generators/gen_options.lua +++ b/src/nvim/generators/gen_options.lua @@ -139,7 +139,7 @@ local dump_option = function(i, o) w(get_cond(o.enable_if)) end if o.varname then - w(' .var=(char_u *)&' .. o.varname) + w(' .var=(char *)&' .. o.varname) elseif #o.scope == 1 and o.scope[1] == 'window' then w(' .var=VAR_WIN') end diff --git a/src/nvim/globals.h b/src/nvim/globals.h index 816471d7c1..571df45e89 100644 --- a/src/nvim/globals.h +++ b/src/nvim/globals.h @@ -169,7 +169,7 @@ EXTERN char *edit_submode_extra INIT(= NULL); // appended to edit_submode EXTERN hlf_T edit_submode_highl; // highl. method for extra info // state for putting characters in the message area -EXTERN int cmdmsg_rl INIT(= false); // cmdline is drawn right to left +EXTERN bool cmdmsg_rl INIT(= false); // cmdline is drawn right to left EXTERN int msg_col; EXTERN int msg_row; EXTERN int msg_scrolled; // Number of screen lines that windows have @@ -224,7 +224,7 @@ EXTERN bool did_wait_return INIT(= false); // wait_return() was used and // nothing written since then EXTERN bool need_maketitle INIT(= true); // call maketitle() soon -EXTERN int quit_more INIT(= false); // 'q' hit at "--more--" msg +EXTERN bool quit_more INIT(= false); // 'q' hit at "--more--" msg EXTERN int vgetc_busy INIT(= 0); // when inside vgetc() then > 0 EXTERN bool didset_vim INIT(= false); // did set $VIM ourselves @@ -233,7 +233,7 @@ EXTERN bool didset_vimruntime INIT(= false); // idem for $VIMRUNTIME /// Lines left before a "more" message. Ex mode needs to be able to reset this /// after you type something. EXTERN int lines_left INIT(= -1); // lines left for listing -EXTERN int msg_no_more INIT(= false); // don't use more prompt, truncate +EXTERN bool msg_no_more INIT(= false); // don't use more prompt, truncate // messages EXTERN int ex_nesting_level INIT(= 0); // nesting level @@ -275,7 +275,7 @@ EXTERN int trylevel INIT(= 0); /// non-zero (and ":silent!" was not used) or an exception is being thrown at /// the time an error is detected. It is set to false when "trylevel" gets /// zero again and there was no error or interrupt or throw. -EXTERN int force_abort INIT(= false); +EXTERN bool force_abort INIT(= false); /// "msg_list" points to a variable in the stack of do_cmdline() which keeps /// the list of arguments of several emsg() calls, one of which is to be @@ -308,8 +308,8 @@ EXTERN except_T *caught_stack INIT(= NULL); /// "garbage_collect_at_exit" indicates garbagecollect(1) was called. /// EXTERN bool may_garbage_collect INIT(= false); -EXTERN int want_garbage_collect INIT(= false); -EXTERN int garbage_collect_at_exit INIT(= false); +EXTERN bool want_garbage_collect INIT(= false); +EXTERN bool garbage_collect_at_exit INIT(= false); // Special values for current_SID. #define SID_MODELINE (-1) // when using a modeline @@ -360,19 +360,19 @@ EXTERN linenr_T search_last_line INIT(= MAXLNUM); // for :{first},{LAST}s/pat EXTERN bool no_smartcase INIT(= false); // don't use 'smartcase' once -EXTERN int need_check_timestamps INIT(= false); // need to check file - // timestamps asap -EXTERN int did_check_timestamps INIT(= false); // did check timestamps - // recently -EXTERN int no_check_timestamps INIT(= 0); // Don't check timestamps +EXTERN bool need_check_timestamps INIT(= false); // need to check file + // timestamps asap +EXTERN bool did_check_timestamps INIT(= false); // did check timestamps + // recently +EXTERN int no_check_timestamps INIT(= 0); // Don't check timestamps -EXTERN int autocmd_busy INIT(= false); // Is apply_autocmds() busy? +EXTERN bool autocmd_busy INIT(= false); // Is apply_autocmds() busy? EXTERN int autocmd_no_enter INIT(= false); // *Enter autocmds disabled EXTERN int autocmd_no_leave INIT(= false); // *Leave autocmds disabled EXTERN int modified_was_set; // did ":set modified" -EXTERN int did_filetype INIT(= false); // FileType event found +EXTERN bool did_filetype INIT(= false); // FileType event found // value for did_filetype when starting to execute autocommands -EXTERN int keep_filetype INIT(= false); +EXTERN bool keep_filetype INIT(= false); // When deleting the current buffer, another one must be loaded. // If we know which one is preferred, au_new_curbuf is set to it. @@ -398,7 +398,7 @@ EXTERN int mouse_dragging INIT(= 0); // extending Visual area with EXTERN vimmenu_T *root_menu INIT(= NULL); // While defining the system menu, sys_menu is true. This avoids // overruling of menus that the user already defined. -EXTERN int sys_menu INIT(= false); +EXTERN bool sys_menu INIT(= false); // All windows are linked in a list. firstwin points to the first entry, // lastwin to the last entry (can be the same as firstwin) and curwin to the @@ -501,7 +501,7 @@ EXTERN bool stderr_isatty INIT(= true); EXTERN int stdin_fd INIT(= -1); // true when doing full-screen output, otherwise only writing some messages. -EXTERN int full_screen INIT(= false); +EXTERN bool full_screen INIT(= false); /// Non-zero when only "safe" commands are allowed EXTERN int secure INIT(= 0); @@ -519,14 +519,14 @@ EXTERN int allbuf_lock INIT(= 0); EXTERN int sandbox INIT(= 0); /// Batch-mode: "-es", "-Es", "-l" commandline argument was given. -EXTERN int silent_mode INIT(= false); +EXTERN bool silent_mode INIT(= false); /// Start position of active Visual selection. EXTERN pos_T VIsual; /// Whether Visual mode is active. -EXTERN int VIsual_active INIT(= false); +EXTERN bool VIsual_active INIT(= false); /// Whether Select mode is active. -EXTERN int VIsual_select INIT(= false); +EXTERN bool VIsual_select INIT(= false); /// Register name for Select mode EXTERN int VIsual_select_reg INIT(= 0); /// Restart Select mode when next cmd finished @@ -536,7 +536,7 @@ EXTERN int VIsual_reselect; /// Type of Visual mode. EXTERN int VIsual_mode INIT(= 'v'); /// true when redoing Visual. -EXTERN int redo_VIsual_busy INIT(= false); +EXTERN bool redo_VIsual_busy INIT(= false); // The Visual area is remembered for reselection. EXTERN int resel_VIsual_mode INIT(= NUL); // 'v', 'V', or Ctrl-V @@ -704,8 +704,8 @@ EXTERN char os_buf[ ///< Buffer for the os/ layer // When non-zero, postpone redrawing. EXTERN int RedrawingDisabled INIT(= 0); -EXTERN int readonlymode INIT(= false); // Set to true for "view" -EXTERN int recoverymode INIT(= false); // Set to true for "-r" option +EXTERN bool readonlymode INIT(= false); // Set to true for "view" +EXTERN bool recoverymode INIT(= false); // Set to true for "-r" option // typeahead buffer EXTERN typebuf_T typebuf INIT(= { NULL, NULL, 0, 0, 0, 0, 0, 0, 0 }); @@ -714,13 +714,13 @@ EXTERN typebuf_T typebuf INIT(= { NULL, NULL, 0, 0, 0, 0, 0, 0, 0 }); /// :normal argument was exhausted. EXTERN bool typebuf_was_empty INIT(= false); -EXTERN int ex_normal_busy INIT(= 0); // recursiveness of ex_normal() -EXTERN int expr_map_lock INIT(= 0); // running expr mapping, prevent use of ex_normal() and text changes -EXTERN int ignore_script INIT(= false); // ignore script input -EXTERN int stop_insert_mode; // for ":stopinsert" -EXTERN bool KeyTyped; // true if user typed current char -EXTERN int KeyStuffed; // true if current char from stuffbuf -EXTERN int maptick INIT(= 0); // tick for each non-mapped char +EXTERN int ex_normal_busy INIT(= 0); // recursiveness of ex_normal() +EXTERN int expr_map_lock INIT(= 0); // running expr mapping, prevent use of ex_normal() and text changes +EXTERN bool ignore_script INIT(= false); // ignore script input +EXTERN int stop_insert_mode; // for ":stopinsert" +EXTERN bool KeyTyped; // true if user typed current char +EXTERN int KeyStuffed; // true if current char from stuffbuf +EXTERN int maptick INIT(= 0); // tick for each non-mapped char EXTERN int must_redraw INIT(= 0); // type of redraw necessary EXTERN bool skip_redraw INIT(= false); // skip redraw once @@ -776,7 +776,7 @@ EXTERN int replace_offset INIT(= 0); // offset for replace_push() EXTERN char *escape_chars INIT(= " \t\\\"|"); // need backslash in cmd line -EXTERN int keep_help_flag INIT(= false); // doing :ta from help file +EXTERN bool keep_help_flag INIT(= false); // doing :ta from help file // When a string option is NULL (which only happens in out-of-memory // situations), it is set to empty_option, to avoid having to check for NULL diff --git a/src/nvim/grid.c b/src/nvim/grid.c index cd70e98047..3c4b1e9d70 100644 --- a/src/nvim/grid.c +++ b/src/nvim/grid.c @@ -197,10 +197,10 @@ void grid_put_schar(ScreenGrid *grid, int row, int col, char *schar, int attr) /// like grid_puts(), but output "text[len]". When "len" is -1 output up to /// a NUL. -int grid_puts_len(ScreenGrid *grid, char *text, int textlen, int row, int col, int attr) +int grid_puts_len(ScreenGrid *grid, const char *text, int textlen, int row, int col, int attr) { size_t off; - char *ptr = text; + const char *ptr = text; int len = textlen; int c; size_t max_off; diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c index 56fa206247..cce124de77 100644 --- a/src/nvim/highlight_group.c +++ b/src/nvim/highlight_group.c @@ -1631,7 +1631,7 @@ static bool highlight_list_arg(const int id, bool didh, const int type, int iarg } } - (void)syn_list_header(didh, vim_strsize((char *)ts) + (int)strlen(name) + 1, id, false); + (void)syn_list_header(didh, vim_strsize(ts) + (int)strlen(name) + 1, id, false); didh = true; if (!got_int) { if (*name != NUL) { diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c index f3d379c2e9..8eec9014f7 100644 --- a/src/nvim/keycodes.c +++ b/src/nvim/keycodes.c @@ -34,18 +34,18 @@ static const struct modmasktable { uint16_t mod_mask; ///< Bit-mask for particular key modifier. uint16_t mod_flag; ///< Bit(s) for particular key modifier. - char_u name; ///< Single letter name of modifier. + char name; ///< Single letter name of modifier. } mod_mask_table[] = { - { MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'M' }, - { MOD_MASK_META, MOD_MASK_META, (char_u)'T' }, - { MOD_MASK_CTRL, MOD_MASK_CTRL, (char_u)'C' }, - { MOD_MASK_SHIFT, MOD_MASK_SHIFT, (char_u)'S' }, - { MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, (char_u)'2' }, - { MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, (char_u)'3' }, - { MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, (char_u)'4' }, - { MOD_MASK_CMD, MOD_MASK_CMD, (char_u)'D' }, + { MOD_MASK_ALT, MOD_MASK_ALT, 'M' }, + { MOD_MASK_META, MOD_MASK_META, 'T' }, + { MOD_MASK_CTRL, MOD_MASK_CTRL, 'C' }, + { MOD_MASK_SHIFT, MOD_MASK_SHIFT, 'S' }, + { MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, '2' }, + { MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, '3' }, + { MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, '4' }, + { MOD_MASK_CMD, MOD_MASK_CMD, 'D' }, // 'A' must be the last one - { MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'A' }, + { MOD_MASK_ALT, MOD_MASK_ALT, 'A' }, { 0, 0, NUL } // NOTE: when adding an entry, update MAX_KEY_NAME_LEN! }; @@ -386,7 +386,7 @@ int name_to_mod_mask(int c) { c = TOUPPER_ASC(c); for (size_t i = 0; mod_mask_table[i].mod_mask != 0; i++) { - if (c == mod_mask_table[i].name) { + if (c == (uint8_t)mod_mask_table[i].name) { return mod_mask_table[i].mod_flag; } } @@ -468,9 +468,9 @@ int handle_x_keys(const int key) } /// @return a string which contains the name of the given key when the given modifiers are down. -char_u *get_special_key_name(int c, int modifiers) +char *get_special_key_name(int c, int modifiers) { - static char_u string[MAX_KEY_NAME_LEN + 1]; + static char string[MAX_KEY_NAME_LEN + 1]; int i, idx; int table_idx; @@ -524,7 +524,7 @@ char_u *get_special_key_name(int c, int modifiers) if ((modifiers & mod_mask_table[i].mod_mask) == mod_mask_table[i].mod_flag) { string[idx++] = mod_mask_table[i].name; - string[idx++] = (char_u)'-'; + string[idx++] = '-'; } } @@ -532,18 +532,18 @@ char_u *get_special_key_name(int c, int modifiers) if (IS_SPECIAL(c)) { string[idx++] = 't'; string[idx++] = '_'; - string[idx++] = (char_u)KEY2TERMCAP0(c); - string[idx++] = KEY2TERMCAP1(c); + string[idx++] = (char)(uint8_t)KEY2TERMCAP0(c); + string[idx++] = (char)(uint8_t)KEY2TERMCAP1(c); } else { // Not a special key, only modifiers, output directly. if (utf_char2len(c) > 1) { - idx += utf_char2bytes(c, (char *)string + idx); + idx += utf_char2bytes(c, string + idx); } else if (vim_isprintc(c)) { - string[idx++] = (char_u)c; + string[idx++] = (char)(uint8_t)c; } else { s = transchar(c); while (*s) { - string[idx++] = (uint8_t)(*s++); + string[idx++] = *s++; } } } @@ -1083,7 +1083,7 @@ char *vim_strsave_escape_ks(char *p) /// vim_strsave_escape_ks(). Works in-place. void vim_unescape_ks(char *p) { - char_u *s = (char_u *)p, *d = (char_u *)p; + uint8_t *s = (uint8_t *)p, *d = (uint8_t *)p; while (*s != NUL) { if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER) { diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c index dfbbfe9ab5..b5dd7a3e78 100644 --- a/src/nvim/lua/executor.c +++ b/src/nvim/lua/executor.c @@ -623,7 +623,7 @@ static bool nlua_init_packages(lua_State *lstate, bool is_standalone) lua_getglobal(lstate, "require"); lua_pushstring(lstate, "vim._init_packages"); if (nlua_pcall(lstate, 1, 0)) { - os_errmsg((char *)lua_tostring(lstate, -1)); + os_errmsg(lua_tostring(lstate, -1)); os_errmsg("\n"); return false; } diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c index ee5676e927..20a99b2836 100644 --- a/src/nvim/lua/stdlib.c +++ b/src/nvim/lua/stdlib.c @@ -288,7 +288,7 @@ int nlua_regex(lua_State *lstate) regprog_T *prog = NULL; TRY_WRAP(&err, { - prog = vim_regcomp((char *)text, RE_AUTO | RE_MAGIC | RE_STRICT); + prog = vim_regcomp(text, RE_AUTO | RE_MAGIC | RE_STRICT); }); if (ERROR_SET(&err)) { diff --git a/src/nvim/main.c b/src/nvim/main.c index a16badc1a0..1f16ecff76 100644 --- a/src/nvim/main.c +++ b/src/nvim/main.c @@ -2153,7 +2153,7 @@ static void print_mainerr(const char *errstr, const char *str) os_errmsg(_(errstr)); if (str != NULL) { os_errmsg(": \""); - os_errmsg((char *)str); + os_errmsg(str); os_errmsg("\""); } os_errmsg(_("\nMore info with \"")); diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c index 5cedc5e97d..2941d5965b 100644 --- a/src/nvim/mapping.c +++ b/src/nvim/mapping.c @@ -1189,7 +1189,7 @@ static char *translate_mapping(char *str_in, int cpo_flags) str += 2; } if (IS_SPECIAL(c) || modifiers) { // special key - ga_concat(&ga, (char *)get_special_key_name(c, modifiers)); + ga_concat(&ga, get_special_key_name(c, modifiers)); continue; // for (str) } } @@ -1436,7 +1436,7 @@ int ExpandMappings(char *pat, regmatch_T *regmatch, int *numMatches, char ***mat bool check_abbr(int c, char *ptr, int col, int mincol) { int scol; // starting column of the abbr. - char_u tb[MB_MAXBYTES + 4]; + uint8_t tb[MB_MAXBYTES + 4]; mapblock_T *mp; mapblock_T *mp2; int clen = 0; // length in characters @@ -1535,8 +1535,8 @@ bool check_abbr(int c, char *ptr, int col, int mincol) // special key code, split up if (IS_SPECIAL(c) || c == K_SPECIAL) { tb[j++] = K_SPECIAL; - tb[j++] = (char_u)K_SECOND(c); - tb[j++] = (char_u)K_THIRD(c); + tb[j++] = (uint8_t)K_SECOND(c); + tb[j++] = (uint8_t)K_THIRD(c); } else { if (c < ABBR_OFF && (c < ' ' || c > '~')) { tb[j++] = Ctrl_V; // special char needs CTRL-V @@ -1918,7 +1918,7 @@ int put_escstr(FILE *fd, char *strstart, int what) str += 2; } if (IS_SPECIAL(c) || modifiers) { // special key - if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0) { + if (fputs(get_special_key_name(c, modifiers), fd) < 0) { return FAIL; } continue; diff --git a/src/nvim/match.c b/src/nvim/match.c index 93c8a58051..29d4b7c225 100644 --- a/src/nvim/match.c +++ b/src/nvim/match.c @@ -98,7 +98,7 @@ static int match_add(win_T *wp, const char *const grp, const char *const pat, in if ((hlg_id = syn_check_group(grp, strlen(grp))) == 0) { return -1; } - if (pat != NULL && (regprog = vim_regcomp((char *)pat, RE_MAGIC)) == NULL) { + if (pat != NULL && (regprog = vim_regcomp(pat, RE_MAGIC)) == NULL) { semsg(_(e_invarg2), pat); return -1; } @@ -1232,7 +1232,7 @@ void ex_match(exarg_T *eap) if (!eap->skip) { if (*end != NUL && !ends_excmd(*skipwhite(end + 1))) { xfree(g); - eap->errmsg = ex_errmsg(e_trailing_arg, (const char *)end); + eap->errmsg = ex_errmsg(e_trailing_arg, end); return; } if (*end != *p) { @@ -1243,8 +1243,7 @@ void ex_match(exarg_T *eap) c = (uint8_t)(*end); *end = NUL; - match_add(curwin, (const char *)g, (const char *)p + 1, 10, id, - NULL, NULL); + match_add(curwin, g, p + 1, 10, id, NULL, NULL); xfree(g); *end = (char)c; } diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c index fb52a11025..c580dc29e6 100644 --- a/src/nvim/mbyte.c +++ b/src/nvim/mbyte.c @@ -653,32 +653,32 @@ int utf_ptr2char(const char *const p_in) // // If byte sequence is illegal or incomplete, returns -1 and does not advance // "s". -static int utf_safe_read_char_adv(const char_u **s, size_t *n) +static int utf_safe_read_char_adv(const char **s, size_t *n) { if (*n == 0) { // end of buffer return 0; } - uint8_t k = utf8len_tab_zero[**s]; + uint8_t k = utf8len_tab_zero[(uint8_t)(**s)]; if (k == 1) { // ASCII character or NUL (*n)--; - return *(*s)++; + return (uint8_t)(*(*s)++); } if (k <= *n) { // We have a multibyte sequence and it isn't truncated by buffer // limits so utf_ptr2char() is safe to use. Or the first byte is // illegal (k=0), and it's also safe to use utf_ptr2char(). - int c = utf_ptr2char((char *)(*s)); + int c = utf_ptr2char(*s); // On failure, utf_ptr2char() returns the first byte, so here we // check equality with the first byte. The only non-ASCII character // which equals the first byte of its own UTF-8 representation is // U+00C3 (UTF-8: 0xC3 0x83), so need to check that special case too. // It's safe even if n=1, else we would have k=2 > n. - if (c != (int)(**s) || (c == 0xC3 && (*s)[1] == 0x83)) { + if (c != (int)((uint8_t)(**s)) || (c == 0xC3 && (uint8_t)(*s)[1] == 0x83)) { // byte sequence was successfully decoded *s += k; *n -= k; @@ -1271,7 +1271,7 @@ bool mb_isalpha(int a) return mb_islower(a) || mb_isupper(a); } -static int utf_strnicmp(const char_u *s1, const char_u *s2, size_t n1, size_t n2) +static int utf_strnicmp(const char *s1, const char *s2, size_t n1, size_t n2) { int c1, c2, cdiff; char buffer[6]; @@ -1313,14 +1313,14 @@ static int utf_strnicmp(const char_u *s1, const char_u *s2, size_t n1, size_t n2 if (c1 != -1 && c2 == -1) { n1 = (size_t)utf_char2bytes(utf_fold(c1), (char *)buffer); - s1 = (char_u *)buffer; + s1 = buffer; } else if (c2 != -1 && c1 == -1) { n2 = (size_t)utf_char2bytes(utf_fold(c2), (char *)buffer); - s2 = (char_u *)buffer; + s2 = buffer; } while (n1 > 0 && n2 > 0 && *s1 != NUL && *s2 != NUL) { - cdiff = (int)(*s1) - (int)(*s2); + cdiff = (int)((uint8_t)(*s1)) - (int)((uint8_t)(*s2)); if (cdiff != 0) { return cdiff; } @@ -1498,7 +1498,7 @@ ssize_t mb_utf_index_to_bytes(const char *s, size_t len, size_t index, bool use_ /// two characters otherwise. int mb_strnicmp(const char *s1, const char *s2, const size_t nn) { - return utf_strnicmp((char_u *)s1, (char_u *)s2, nn, nn); + return utf_strnicmp(s1, s2, nn, nn); } /// Compare strings case-insensitively diff --git a/src/nvim/memline.c b/src/nvim/memline.c index 0f2790b06c..51a4186775 100644 --- a/src/nvim/memline.c +++ b/src/nvim/memline.c @@ -351,7 +351,7 @@ int ml_open(buf_T *buf) dp->db_index[0] = --dp->db_txt_start; // at end of block dp->db_free -= 1 + (unsigned)INDEX_SIZE; dp->db_line_count = 1; - *((char_u *)dp + dp->db_txt_start) = NUL; // empty line + *((char *)dp + dp->db_txt_start) = NUL; // empty line return OK; @@ -1065,7 +1065,7 @@ void ml_recover(bool checkext) } // make sure there is a NUL at the end of the block - *((char_u *)dp + dp->db_txt_end - 1) = NUL; + *((char *)dp + dp->db_txt_end - 1) = NUL; // check number of lines in block // if wrong, use count in data block diff --git a/src/nvim/message.c b/src/nvim/message.c index aecb46c6bd..b43bc6ce9b 100644 --- a/src/nvim/message.c +++ b/src/nvim/message.c @@ -216,13 +216,13 @@ void msg_grid_validate(void) /// When terminal not initialized (yet) os_errmsg(..) is used. /// /// @return true if wait_return() not called -int msg(char *s) +int msg(const char *s) { return msg_attr_keep(s, 0, false, false); } /// Like msg() but keep it silent when 'verbosefile' is set. -int verb_msg(char *s) +int verb_msg(const char *s) { verbose_enter(); int n = msg_attr_keep(s, 0, false, false); @@ -278,8 +278,7 @@ void msg_multiattr(HlMessage hl_msg, const char *kind, bool history) msg_ext_set_kind(kind); for (uint32_t i = 0; i < kv_size(hl_msg); i++) { HlMessageChunk chunk = kv_A(hl_msg, i); - msg_multiline_attr((const char *)chunk.text.data, chunk.attr, - true, &need_clear); + msg_multiline_attr(chunk.text.data, chunk.attr, true, &need_clear); } if (history && kv_size(hl_msg)) { add_msg_hist_multiattr(NULL, 0, 0, true, hl_msg); @@ -305,7 +304,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline) // Skip messages not match ":filter pattern". // Don't filter when there is an error. - if (!emsg_on_display && message_filtered((char *)s)) { + if (!emsg_on_display && message_filtered(s)) { return true; } @@ -333,7 +332,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline) // Truncate the message if needed. msg_start(); - buf = msg_strtrunc((char *)s, false); + buf = msg_strtrunc(s, false); if (buf != NULL) { s = buf; } @@ -349,8 +348,8 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline) } retval = msg_end(); - if (keep && retval && vim_strsize((char *)s) < (Rows - cmdline_row - 1) * Columns + sc_col) { - set_keep_msg((char *)s, 0); + if (keep && retval && vim_strsize(s) < (Rows - cmdline_row - 1) * Columns + sc_col) { + set_keep_msg(s, 0); } need_fileinfo = false; @@ -365,7 +364,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline) /// @return an allocated string or NULL when no truncating is done. /// /// @param force always truncate -char *msg_strtrunc(char *s, int force) +char *msg_strtrunc(const char *s, int force) { char *buf = NULL; @@ -395,7 +394,7 @@ char *msg_strtrunc(char *s, int force) /// Truncate a string "s" to "buf" with cell width "room". /// "s" and "buf" may be equal. -void trunc_string(char *s, char *buf, int room_in, int buflen) +void trunc_string(const char *s, char *buf, int room_in, int buflen) { int room = room_in - 3; // "..." takes 3 chars int half; @@ -503,7 +502,7 @@ int smsg_attr(int attr, const char *s, ...) va_start(arglist, s); vim_vsnprintf(IObuff, IOSIZE, s, arglist); va_end(arglist); - return msg_attr((const char *)IObuff, attr); + return msg_attr(IObuff, attr); } int smsg_attr_keep(int attr, const char *s, ...) @@ -514,7 +513,7 @@ int smsg_attr_keep(int attr, const char *s, ...) va_start(arglist, s); vim_vsnprintf(IObuff, IOSIZE, s, arglist); va_end(arglist); - return msg_attr_keep((const char *)IObuff, attr, true, false); + return msg_attr_keep(IObuff, attr, true, false); } // Remember the last sourcing name/lnum used in an error message, so that it @@ -862,7 +861,7 @@ void siemsg(const char *s, ...) } /// Give an "Internal error" message. -void internal_error(char *where) +void internal_error(const char *where) { siemsg(_(e_intern2), where); } @@ -1327,7 +1326,7 @@ static void hit_return_msg(void) } /// Set "keep_msg" to "s". Free the old value and check for NULL pointer. -void set_keep_msg(char *s, int attr) +void set_keep_msg(const char *s, int attr) { xfree(keep_msg); if (s != NULL && msg_silent == 0) { @@ -1562,7 +1561,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr) // If the string starts with a composing character first draw a space on // which the composing char can be drawn. - if (utf_iscomposing(utf_ptr2char((char *)msgstr))) { + if (utf_iscomposing(utf_ptr2char(msgstr))) { msg_puts_attr(" ", attr); } @@ -1590,7 +1589,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr) len -= mb_l - 1; str += mb_l; } else { - s = (char *)transchar_byte_buf(NULL, (uint8_t)(*str)); + s = transchar_byte_buf(NULL, (uint8_t)(*str)); if (s[1] != NUL) { // Unprintable char: print the printable chars so far and the // translation of the unprintable char. @@ -1598,7 +1597,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr) msg_puts_attr_len(plain_start, str - plain_start, attr); } plain_start = str + 1; - msg_puts_attr((const char *)s, attr == 0 ? HL_ATTR(HLF_8) : attr); + msg_puts_attr(s, attr == 0 ? HL_ATTR(HLF_8) : attr); retval += (int)strlen(s); } else { retval++; @@ -1672,9 +1671,9 @@ int msg_outtrans_special(const char *strstart, bool from, int maxlen) } if (text[0] != NUL && text[1] == NUL) { // single-byte character or illegal byte - text = (char *)transchar_byte_buf(NULL, (uint8_t)text[0]); + text = transchar_byte_buf(NULL, (uint8_t)text[0]); } - const int len = vim_strsize((char *)text); + const int len = vim_strsize(text); if (maxlen > 0 && retval + len >= maxlen) { break; } @@ -1918,7 +1917,7 @@ void msg_prt_line(char *s, int list) s--; } else if (c != NUL && (n = byte2cells(c)) > 1) { n_extra = n - 1; - p_extra = (char *)transchar_byte_buf(NULL, c); + p_extra = transchar_byte_buf(NULL, c); c_extra = NUL; c_final = NUL; c = (unsigned char)(*p_extra++); @@ -1966,7 +1965,7 @@ void msg_prt_line(char *s, int list) /// Use grid_puts() to output one multi-byte character. /// /// @return the pointer "s" advanced to the next character. -static char *screen_puts_mbyte(char *s, int l, int attr) +static const char *screen_puts_mbyte(const char *s, int l, int attr) { int cw; attr = hl_combine_attr(HL_ATTR(HLF_MSG), attr); @@ -2212,7 +2211,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) } else { l = utfc_ptr2len(s); } - s = screen_puts_mbyte((char *)s, l, attr); + s = screen_puts_mbyte(s, l, attr); did_last_char = true; } else { did_last_char = false; @@ -2229,7 +2228,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) if (p_more) { // Store text for scrolling back. - store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, true); + store_sb_text(&sb_str, s, attr, &sb_col, true); } inc_msg_scrolled(); @@ -2274,7 +2273,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) if (wrap && p_more && !recurse) { // Store text for scrolling back. - store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, true); + store_sb_text(&sb_str, s, attr, &sb_col, true); } if (*s == '\n') { // go to next line @@ -2312,7 +2311,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) // characters and draw them all at once later. if (cmdmsg_rl || (cw > 1 && msg_col + t_col >= Columns - 1)) { if (l > 1) { - s = screen_puts_mbyte((char *)s, l, attr) - 1; + s = screen_puts_mbyte(s, l, attr) - 1; } else { msg_screen_putchar(*s, attr); } @@ -2333,7 +2332,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) t_puts(&t_col, t_s, s, attr); } if (p_more && !recurse && !(s == sb_str + 1 && *sb_str == '\n')) { - store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, false); + store_sb_text(&sb_str, s, attr, &sb_col, false); } msg_check(); @@ -2341,7 +2340,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse) /// @return true when ":filter pattern" was used and "msg" does not match /// "pattern". -bool message_filtered(char *msg) +bool message_filtered(const char *msg) { if (cmdmod.cmod_filter_regmatch.regprog == NULL) { return false; @@ -2507,7 +2506,7 @@ static sb_clear_T do_clear_sb_text = SB_CLEAR_NONE; /// @param sb_str start of string /// @param s just after string /// @param finish line ends -static void store_sb_text(char **sb_str, char *s, int attr, int *sb_col, int finish) +static void store_sb_text(const char **sb_str, const char *s, int attr, int *sb_col, int finish) { msgchunk_T *mp; @@ -2681,7 +2680,7 @@ static void t_puts(int *t_col, const char *t_s, const char *s, int attr) attr = hl_combine_attr(HL_ATTR(HLF_MSG), attr); // Output postponed text. msg_didout = true; // Remember that line is not empty. - grid_puts_len(&msg_grid_adj, (char *)t_s, (int)(s - t_s), msg_row, msg_col, attr); + grid_puts_len(&msg_grid_adj, t_s, (int)(s - t_s), msg_row, msg_col, attr); msg_col += *t_col; *t_col = 0; // If the string starts with a composing character don't increment the @@ -3308,7 +3307,7 @@ static void redir_write(const char *const str, const ptrdiff_t maxlen) write_reg_contents(redir_reg, s, (ssize_t)len, true); } if (redir_vname) { - var_redir_str((char *)s, (int)maxlen); + var_redir_str(s, (int)maxlen); } // Write and adjust the current column. @@ -3417,7 +3416,7 @@ int verbose_open(void) /// Give a warning message (for searching). /// Use 'w' highlighting and may repeat the message after redrawing -void give_warning(char *message, bool hl) +void give_warning(const char *message, bool hl) FUNC_ATTR_NONNULL_ARG(1) { // Don't do this for ":silent". @@ -3440,7 +3439,7 @@ void give_warning(char *message, bool hl) msg_ext_set_kind("wmsg"); } - if (msg_attr((const char *)message, keep_msg_attr) && msg_scrolled == 0) { + if (msg_attr(message, keep_msg_attr) && msg_scrolled == 0) { set_keep_msg(message, keep_msg_attr); } msg_didout = false; // Overwrite this message. @@ -3450,7 +3449,7 @@ void give_warning(char *message, bool hl) no_wait_return--; } -void give_warning2(char *const message, char *const a1, bool hl) +void give_warning2(const char *const message, const char *const a1, bool hl) { vim_snprintf(IObuff, IOSIZE, message, a1); give_warning(IObuff, hl); diff --git a/src/nvim/move.c b/src/nvim/move.c index a9f7ffaa76..e74dc32fd4 100644 --- a/src/nvim/move.c +++ b/src/nvim/move.c @@ -2241,7 +2241,7 @@ void do_check_cursorbind(void) int old_VIsual_active = VIsual_active; // loop through the cursorbound windows - VIsual_select = VIsual_active = 0; + VIsual_select = VIsual_active = false; FOR_ALL_WINDOWS_IN_TAB(wp, curtab) { curwin = wp; curbuf = curwin->w_buffer; diff --git a/src/nvim/ops.c b/src/nvim/ops.c index 2edd1772ca..d66ed9abff 100644 --- a/src/nvim/ops.c +++ b/src/nvim/ops.c @@ -5162,7 +5162,7 @@ void write_reg_contents_ex(int name, const char *str, ssize_t len, bool must_app /// @param str string or list of strings to put in register /// @param len length of the string (Ignored when str_list=true.) /// @param blocklen width of visual block, or -1 for "I don't know." -/// @param str_list True if str is `char_u **`. +/// @param str_list True if str is `char **`. static void str_to_reg(yankreg_T *y_ptr, MotionType yank_type, const char *str, size_t len, colnr_T blocklen, bool str_list) FUNC_ATTR_NONNULL_ALL diff --git a/src/nvim/option.c b/src/nvim/option.c index f672b3ab6f..8fa719c3a9 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -421,7 +421,7 @@ static void set_option_default(const int opt_idx, int opt_flags) // pointer to variable for current option vimoption_T *opt = &options[opt_idx]; - char_u *varp = (char_u *)get_varp_scope(opt, both ? OPT_LOCAL : opt_flags); + char *varp = get_varp_scope(opt, both ? OPT_LOCAL : opt_flags); uint32_t flags = opt->flags; if (varp != NULL) { // skip hidden option, nothing to do for it if (flags & P_STRING) { @@ -833,7 +833,7 @@ static void do_set_num(int opt_idx, int opt_flags, char **argp, int nextchar, co if (op == OP_REMOVING) { value = *(long *)varp - value; } - *errmsg = set_num_option(opt_idx, (char_u *)varp, (long)value, + *errmsg = set_num_option(opt_idx, (char *)varp, (long)value, errbuf, errbuflen, opt_flags); } @@ -847,7 +847,7 @@ static void munge_string_opt_val(char **varp, char **oldval, char **const origva if (varp == &p_kp && (**argp == NUL || **argp == ' ')) { *save_argp = *argp; *argp = ":help"; - } else if (varp == &p_bs && ascii_isdigit(**(char_u **)varp)) { + } else if (varp == &p_bs && ascii_isdigit((uint8_t)(**varp))) { // Convert 'backspace' number to string, for // adding, prepending and removing string. const int i = getdigits_int(varp, true, 0); @@ -927,7 +927,7 @@ static void do_set_string(int opt_idx, int opt_flags, char **argp, int nextchar, // reset, use the global value here. if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0 && ((int)options[opt_idx].indir & PV_BOTH)) { - varp = (char *)options[opt_idx].var; + varp = options[opt_idx].var; } // The old value is kept until we are sure that the new value is valid. @@ -1439,7 +1439,7 @@ static void do_set_option(int opt_flags, char **argp, bool *did_show, char *errb showoneopt(&options[opt_idx], opt_flags); if (p_verbose > 0) { // Mention where the option was last set. - if (varp == (char *)options[opt_idx].var) { + if (varp == options[opt_idx].var) { option_last_set_msg(options[opt_idx].last_set); } else if ((int)options[opt_idx].indir & PV_WIN) { option_last_set_msg(curwin->w_p_script_ctx[(int)options[opt_idx].indir & PV_MASK]); @@ -1735,7 +1735,7 @@ static char *option_expand(int opt_idx, char *val) // For 'spellsuggest' expand after "file:". expand_env_esc(val, NameBuff, MAXPATHL, (char **)options[opt_idx].var == &p_tags, false, - (char_u **)options[opt_idx].var == (char_u **)&p_sps ? "file:" : + (char **)options[opt_idx].var == &p_sps ? "file:" : NULL); if (strcmp(NameBuff, val) == 0) { // they are the same return NULL; @@ -2274,7 +2274,7 @@ static char *set_bool_option(const int opt_idx, char *const varp, const int valu /// @param[in] opt_flags OPT_LOCAL, OPT_GLOBAL or OPT_MODELINE. /// /// @return NULL on success, error message on error. -static char *set_num_option(int opt_idx, char_u *varp, long value, char *errbuf, size_t errbuflen, +static char *set_num_option(int opt_idx, char *varp, long value, char *errbuf, size_t errbuflen, int opt_flags) { char *errmsg = NULL; @@ -2905,7 +2905,7 @@ getoption_T get_option_value(const char *name, long *numval, char **stringval, u return gov_unknown; } - char_u *varp = (char_u *)get_varp_scope(&(options[opt_idx]), scope); + char *varp = get_varp_scope(&(options[opt_idx]), scope); if (flagsp != NULL) { // Return the P_xxxx option flags. @@ -3010,7 +3010,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o return rv; } - char_u *varp = NULL; + char *varp = NULL; if (opt_type == SREQ_GLOBAL) { if (p->var == VAR_WIN) { @@ -3030,7 +3030,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o // only getting a pointer, no need to use aucmd_prepbuf() curbuf = (buf_T *)from; curwin->w_buffer = curbuf; - varp = (char_u *)get_varp_scope(p, OPT_LOCAL); + varp = get_varp_scope(p, OPT_LOCAL); curbuf = save_curbuf; curwin->w_buffer = curbuf; } @@ -3038,7 +3038,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o win_T *save_curwin = curwin; curwin = (win_T *)from; curbuf = curwin->w_buffer; - varp = (char_u *)get_varp_scope(p, OPT_LOCAL); + varp = get_varp_scope(p, OPT_LOCAL); curwin = save_curwin; curbuf = curwin->w_buffer; } @@ -3109,7 +3109,7 @@ char *set_option_value(const char *const name, const long number, const char *co return set_string_option(opt_idx, s, opt_flags, errbuf, sizeof(errbuf)); } - char_u *varp = (char_u *)get_varp_scope(&(options[opt_idx]), opt_flags); + char *varp = get_varp_scope(&(options[opt_idx]), opt_flags); if (varp == NULL) { // hidden option is not changed return NULL; @@ -3146,7 +3146,7 @@ char *set_option_value(const char *const name, const long number, const char *co if (flags & P_NUM) { return set_num_option(opt_idx, varp, numval, errbuf, sizeof(errbuf), opt_flags); } - return set_bool_option(opt_idx, (char *)varp, (int)numval, opt_flags); + return set_bool_option(opt_idx, varp, (int)numval, opt_flags); } /// Call set_option_value() and when an error is returned report it. @@ -3243,7 +3243,7 @@ static void showoptions(bool all, int opt_flags) varp = get_varp_scope(p, opt_flags); } } else { - varp = (char *)get_varp(p); + varp = get_varp(p); } if (varp != NULL && (all == 1 || (all == 0 && !optval_default(p, varp)))) { @@ -3349,7 +3349,7 @@ static void showoneopt(vimoption_T *p, int opt_flags) silent_mode = false; info_message = true; // use os_msg(), not os_errmsg() - char_u *varp = (char_u *)get_varp_scope(p, opt_flags); + char *varp = get_varp_scope(p, opt_flags); // for 'modified' we also need to check if 'ff' or 'fenc' changed. if ((p->flags & P_BOOL) && ((int *)varp == &curbuf->b_changed @@ -3427,12 +3427,12 @@ int makeset(FILE *fd, int opt_flags, int local_only) } if ((opt_flags & OPT_SKIPRTP) - && (p->var == (char_u *)&p_rtp || p->var == (char_u *)&p_pp)) { + && (p->var == (char *)&p_rtp || p->var == (char *)&p_pp)) { continue; } int round = 2; - char_u *varp_local = NULL; // fresh value + char *varp_local = NULL; // fresh value if (p->indir != PV_NONE) { if (p->var == VAR_WIN) { // skip window-local option when only doing globals @@ -3442,11 +3442,11 @@ int makeset(FILE *fd, int opt_flags, int local_only) // When fresh value of window-local option is not at the // default, need to write it too. if (!(opt_flags & OPT_GLOBAL) && !local_only) { - char_u *varp_fresh = (char_u *)get_varp_scope(p, OPT_GLOBAL); // local value - if (!optval_default(p, (char *)varp_fresh)) { + char *varp_fresh = get_varp_scope(p, OPT_GLOBAL); // local value + if (!optval_default(p, varp_fresh)) { round = 1; - varp_local = (char_u *)varp; - varp = (char *)varp_fresh; + varp_local = varp; + varp = varp_fresh; } } } @@ -3454,7 +3454,7 @@ int makeset(FILE *fd, int opt_flags, int local_only) // Round 1: fresh value for window-local options. // Round 2: other values - for (; round <= 2; varp = (char *)varp_local, round++) { + for (; round <= 2; varp = varp_local, round++) { char *cmd; if (round == 1 || (opt_flags & OPT_GLOBAL)) { cmd = "set"; @@ -3477,7 +3477,7 @@ int makeset(FILE *fd, int opt_flags, int local_only) // already right, avoids reloading the syntax file. if (p->indir == PV_SYN || p->indir == PV_FT) { if (fprintf(fd, "if &%s != '%s'", p->fullname, - *(char_u **)(varp)) < 0 + *(char **)(varp)) < 0 || put_eol(fd) < 0) { return FAIL; } @@ -3524,7 +3524,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_ } char *buf = NULL; - char_u *part = NULL; + char *part = NULL; if (*valuep != NULL) { if ((flags & P_EXPAND) != 0) { @@ -3552,8 +3552,8 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_ if (fprintf(fd, "%s %s+=", cmd, name) < 0) { goto fail; } - (void)copy_option_part(&p, (char *)part, size, ","); - if (put_escstr(fd, (char *)part, 2) == FAIL || put_eol(fd) == FAIL) { + (void)copy_option_part(&p, part, size, ","); + if (put_escstr(fd, part, 2) == FAIL || put_eol(fd) == FAIL) { goto fail; } } @@ -3586,9 +3586,9 @@ static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep) return FAIL; } long wc; - if (wc_use_keyname((char_u *)valuep, &wc)) { + if (wc_use_keyname((char *)valuep, &wc)) { // print 'wildchar' and 'wildcharm' as a key name - if (fputs((char *)get_special_key_name((int)wc, 0), fd) < 0) { + if (fputs(get_special_key_name((int)wc, 0), fd) < 0) { return FAIL; } } else if (fprintf(fd, "%" PRId64, (int64_t)(*valuep)) < 0) { @@ -3727,7 +3727,7 @@ char *get_varp_scope_from(vimoption_T *p, int scope, buf_T *buf, win_T *win) if (p->var == VAR_WIN) { return GLOBAL_WO(get_varp_from(p, buf, win)); } - return (char *)p->var; + return p->var; } if ((scope & OPT_LOCAL) && ((int)p->indir & PV_BOTH)) { switch ((int)p->indir) { @@ -3790,7 +3790,7 @@ char *get_varp_scope_from(vimoption_T *p, int scope, buf_T *buf, win_T *win) } return NULL; // "cannot happen" } - return (char *)get_varp_from(p, buf, win); + return get_varp_from(p, buf, win); } /// Get pointer to option variable, depending on local or global scope. @@ -3801,7 +3801,7 @@ char *get_varp_scope(vimoption_T *p, int scope) return get_varp_scope_from(p, scope, curbuf, curwin); } -static char_u *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win) +static char *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win) { // hidden option, always return NULL if (p->var == NULL) { @@ -3815,308 +3815,308 @@ static char_u *get_varp_from(vimoption_T *p, buf_T *buf, win_T *win) // global option with local value: use local value if it's been set case PV_EP: return *buf->b_p_ep != NUL - ? (char_u *)&buf->b_p_ep : p->var; + ? (char *)&buf->b_p_ep : p->var; case PV_KP: return *buf->b_p_kp != NUL - ? (char_u *)&buf->b_p_kp : p->var; + ? (char *)&buf->b_p_kp : p->var; case PV_PATH: return *buf->b_p_path != NUL - ? (char_u *)&(buf->b_p_path) : p->var; + ? (char *)&(buf->b_p_path) : p->var; case PV_AR: return buf->b_p_ar >= 0 - ? (char_u *)&(buf->b_p_ar) : p->var; + ? (char *)&(buf->b_p_ar) : p->var; case PV_TAGS: return *buf->b_p_tags != NUL - ? (char_u *)&(buf->b_p_tags) : p->var; + ? (char *)&(buf->b_p_tags) : p->var; case PV_TC: return *buf->b_p_tc != NUL - ? (char_u *)&(buf->b_p_tc) : p->var; + ? (char *)&(buf->b_p_tc) : p->var; case PV_SISO: return win->w_p_siso >= 0 - ? (char_u *)&(win->w_p_siso) : p->var; + ? (char *)&(win->w_p_siso) : p->var; case PV_SO: return win->w_p_so >= 0 - ? (char_u *)&(win->w_p_so) : p->var; + ? (char *)&(win->w_p_so) : p->var; case PV_BKC: return *buf->b_p_bkc != NUL - ? (char_u *)&(buf->b_p_bkc) : p->var; + ? (char *)&(buf->b_p_bkc) : p->var; case PV_DEF: return *buf->b_p_def != NUL - ? (char_u *)&(buf->b_p_def) : p->var; + ? (char *)&(buf->b_p_def) : p->var; case PV_INC: return *buf->b_p_inc != NUL - ? (char_u *)&(buf->b_p_inc) : p->var; + ? (char *)&(buf->b_p_inc) : p->var; case PV_DICT: return *buf->b_p_dict != NUL - ? (char_u *)&(buf->b_p_dict) : p->var; + ? (char *)&(buf->b_p_dict) : p->var; case PV_TSR: return *buf->b_p_tsr != NUL - ? (char_u *)&(buf->b_p_tsr) : p->var; + ? (char *)&(buf->b_p_tsr) : p->var; case PV_TSRFU: return *buf->b_p_tsrfu != NUL - ? (char_u *)&(buf->b_p_tsrfu) : p->var; + ? (char *)&(buf->b_p_tsrfu) : p->var; case PV_FP: return *buf->b_p_fp != NUL - ? (char_u *)&(buf->b_p_fp) : p->var; + ? (char *)&(buf->b_p_fp) : p->var; case PV_EFM: return *buf->b_p_efm != NUL - ? (char_u *)&(buf->b_p_efm) : p->var; + ? (char *)&(buf->b_p_efm) : p->var; case PV_GP: return *buf->b_p_gp != NUL - ? (char_u *)&(buf->b_p_gp) : p->var; + ? (char *)&(buf->b_p_gp) : p->var; case PV_MP: return *buf->b_p_mp != NUL - ? (char_u *)&(buf->b_p_mp) : p->var; + ? (char *)&(buf->b_p_mp) : p->var; case PV_SBR: return *win->w_p_sbr != NUL - ? (char_u *)&(win->w_p_sbr) : p->var; + ? (char *)&(win->w_p_sbr) : p->var; case PV_STL: return *win->w_p_stl != NUL - ? (char_u *)&(win->w_p_stl) : p->var; + ? (char *)&(win->w_p_stl) : p->var; case PV_WBR: return *win->w_p_wbr != NUL - ? (char_u *)&(win->w_p_wbr) : p->var; + ? (char *)&(win->w_p_wbr) : p->var; case PV_UL: return buf->b_p_ul != NO_LOCAL_UNDOLEVEL - ? (char_u *)&(buf->b_p_ul) : p->var; + ? (char *)&(buf->b_p_ul) : p->var; case PV_LW: return *buf->b_p_lw != NUL - ? (char_u *)&(buf->b_p_lw) : p->var; + ? (char *)&(buf->b_p_lw) : p->var; case PV_MENC: return *buf->b_p_menc != NUL - ? (char_u *)&(buf->b_p_menc) : p->var; + ? (char *)&(buf->b_p_menc) : p->var; case PV_FCS: return *win->w_p_fcs != NUL - ? (char_u *)&(win->w_p_fcs) : p->var; + ? (char *)&(win->w_p_fcs) : p->var; case PV_LCS: return *win->w_p_lcs != NUL - ? (char_u *)&(win->w_p_lcs) : p->var; + ? (char *)&(win->w_p_lcs) : p->var; case PV_VE: return *win->w_p_ve != NUL - ? (char_u *)&win->w_p_ve : p->var; + ? (char *)&win->w_p_ve : p->var; case PV_ARAB: - return (char_u *)&(win->w_p_arab); + return (char *)&(win->w_p_arab); case PV_LIST: - return (char_u *)&(win->w_p_list); + return (char *)&(win->w_p_list); case PV_SPELL: - return (char_u *)&(win->w_p_spell); + return (char *)&(win->w_p_spell); case PV_CUC: - return (char_u *)&(win->w_p_cuc); + return (char *)&(win->w_p_cuc); case PV_CUL: - return (char_u *)&(win->w_p_cul); + return (char *)&(win->w_p_cul); case PV_CULOPT: - return (char_u *)&(win->w_p_culopt); + return (char *)&(win->w_p_culopt); case PV_CC: - return (char_u *)&(win->w_p_cc); + return (char *)&(win->w_p_cc); case PV_DIFF: - return (char_u *)&(win->w_p_diff); + return (char *)&(win->w_p_diff); case PV_FDC: - return (char_u *)&(win->w_p_fdc); + return (char *)&(win->w_p_fdc); case PV_FEN: - return (char_u *)&(win->w_p_fen); + return (char *)&(win->w_p_fen); case PV_FDI: - return (char_u *)&(win->w_p_fdi); + return (char *)&(win->w_p_fdi); case PV_FDL: - return (char_u *)&(win->w_p_fdl); + return (char *)&(win->w_p_fdl); case PV_FDM: - return (char_u *)&(win->w_p_fdm); + return (char *)&(win->w_p_fdm); case PV_FML: - return (char_u *)&(win->w_p_fml); + return (char *)&(win->w_p_fml); case PV_FDN: - return (char_u *)&(win->w_p_fdn); + return (char *)&(win->w_p_fdn); case PV_FDE: - return (char_u *)&(win->w_p_fde); + return (char *)&(win->w_p_fde); case PV_FDT: - return (char_u *)&(win->w_p_fdt); + return (char *)&(win->w_p_fdt); case PV_FMR: - return (char_u *)&(win->w_p_fmr); + return (char *)&(win->w_p_fmr); case PV_NU: - return (char_u *)&(win->w_p_nu); + return (char *)&(win->w_p_nu); case PV_RNU: - return (char_u *)&(win->w_p_rnu); + return (char *)&(win->w_p_rnu); case PV_NUW: - return (char_u *)&(win->w_p_nuw); + return (char *)&(win->w_p_nuw); case PV_WFH: - return (char_u *)&(win->w_p_wfh); + return (char *)&(win->w_p_wfh); case PV_WFW: - return (char_u *)&(win->w_p_wfw); + return (char *)&(win->w_p_wfw); case PV_PVW: - return (char_u *)&(win->w_p_pvw); + return (char *)&(win->w_p_pvw); case PV_RL: - return (char_u *)&(win->w_p_rl); + return (char *)&(win->w_p_rl); case PV_RLC: - return (char_u *)&(win->w_p_rlc); + return (char *)&(win->w_p_rlc); case PV_SCROLL: - return (char_u *)&(win->w_p_scr); + return (char *)&(win->w_p_scr); case PV_WRAP: - return (char_u *)&(win->w_p_wrap); + return (char *)&(win->w_p_wrap); case PV_LBR: - return (char_u *)&(win->w_p_lbr); + return (char *)&(win->w_p_lbr); case PV_BRI: - return (char_u *)&(win->w_p_bri); + return (char *)&(win->w_p_bri); case PV_BRIOPT: - return (char_u *)&(win->w_p_briopt); + return (char *)&(win->w_p_briopt); case PV_SCBIND: - return (char_u *)&(win->w_p_scb); + return (char *)&(win->w_p_scb); case PV_CRBIND: - return (char_u *)&(win->w_p_crb); + return (char *)&(win->w_p_crb); case PV_COCU: - return (char_u *)&(win->w_p_cocu); + return (char *)&(win->w_p_cocu); case PV_COLE: - return (char_u *)&(win->w_p_cole); + return (char *)&(win->w_p_cole); case PV_AI: - return (char_u *)&(buf->b_p_ai); + return (char *)&(buf->b_p_ai); case PV_BIN: - return (char_u *)&(buf->b_p_bin); + return (char *)&(buf->b_p_bin); case PV_BOMB: - return (char_u *)&(buf->b_p_bomb); + return (char *)&(buf->b_p_bomb); case PV_BH: - return (char_u *)&(buf->b_p_bh); + return (char *)&(buf->b_p_bh); case PV_BT: - return (char_u *)&(buf->b_p_bt); + return (char *)&(buf->b_p_bt); case PV_BL: - return (char_u *)&(buf->b_p_bl); + return (char *)&(buf->b_p_bl); case PV_CHANNEL: - return (char_u *)&(buf->b_p_channel); + return (char *)&(buf->b_p_channel); case PV_CI: - return (char_u *)&(buf->b_p_ci); + return (char *)&(buf->b_p_ci); case PV_CIN: - return (char_u *)&(buf->b_p_cin); + return (char *)&(buf->b_p_cin); case PV_CINK: - return (char_u *)&(buf->b_p_cink); + return (char *)&(buf->b_p_cink); case PV_CINO: - return (char_u *)&(buf->b_p_cino); + return (char *)&(buf->b_p_cino); case PV_CINSD: - return (char_u *)&(buf->b_p_cinsd); + return (char *)&(buf->b_p_cinsd); case PV_CINW: - return (char_u *)&(buf->b_p_cinw); + return (char *)&(buf->b_p_cinw); case PV_COM: - return (char_u *)&(buf->b_p_com); + return (char *)&(buf->b_p_com); case PV_CMS: - return (char_u *)&(buf->b_p_cms); + return (char *)&(buf->b_p_cms); case PV_CPT: - return (char_u *)&(buf->b_p_cpt); + return (char *)&(buf->b_p_cpt); #ifdef BACKSLASH_IN_FILENAME case PV_CSL: - return (char_u *)&(buf->b_p_csl); + return (char *)&(buf->b_p_csl); #endif case PV_CFU: - return (char_u *)&(buf->b_p_cfu); + return (char *)&(buf->b_p_cfu); case PV_OFU: - return (char_u *)&(buf->b_p_ofu); + return (char *)&(buf->b_p_ofu); case PV_EOF: - return (char_u *)&(buf->b_p_eof); + return (char *)&(buf->b_p_eof); case PV_EOL: - return (char_u *)&(buf->b_p_eol); + return (char *)&(buf->b_p_eol); case PV_FIXEOL: - return (char_u *)&(buf->b_p_fixeol); + return (char *)&(buf->b_p_fixeol); case PV_ET: - return (char_u *)&(buf->b_p_et); + return (char *)&(buf->b_p_et); case PV_FENC: - return (char_u *)&(buf->b_p_fenc); + return (char *)&(buf->b_p_fenc); case PV_FF: - return (char_u *)&(buf->b_p_ff); + return (char *)&(buf->b_p_ff); case PV_FT: - return (char_u *)&(buf->b_p_ft); + return (char *)&(buf->b_p_ft); case PV_FO: - return (char_u *)&(buf->b_p_fo); + return (char *)&(buf->b_p_fo); case PV_FLP: - return (char_u *)&(buf->b_p_flp); + return (char *)&(buf->b_p_flp); case PV_IMI: - return (char_u *)&(buf->b_p_iminsert); + return (char *)&(buf->b_p_iminsert); case PV_IMS: - return (char_u *)&(buf->b_p_imsearch); + return (char *)&(buf->b_p_imsearch); case PV_INF: - return (char_u *)&(buf->b_p_inf); + return (char *)&(buf->b_p_inf); case PV_ISK: - return (char_u *)&(buf->b_p_isk); + return (char *)&(buf->b_p_isk); case PV_INEX: - return (char_u *)&(buf->b_p_inex); + return (char *)&(buf->b_p_inex); case PV_INDE: - return (char_u *)&(buf->b_p_inde); + return (char *)&(buf->b_p_inde); case PV_INDK: - return (char_u *)&(buf->b_p_indk); + return (char *)&(buf->b_p_indk); case PV_FEX: - return (char_u *)&(buf->b_p_fex); + return (char *)&(buf->b_p_fex); case PV_LISP: - return (char_u *)&(buf->b_p_lisp); + return (char *)&(buf->b_p_lisp); case PV_LOP: - return (char_u *)&(buf->b_p_lop); + return (char *)&(buf->b_p_lop); case PV_ML: - return (char_u *)&(buf->b_p_ml); + return (char *)&(buf->b_p_ml); case PV_MPS: - return (char_u *)&(buf->b_p_mps); + return (char *)&(buf->b_p_mps); case PV_MA: - return (char_u *)&(buf->b_p_ma); + return (char *)&(buf->b_p_ma); case PV_MOD: - return (char_u *)&(buf->b_changed); + return (char *)&(buf->b_changed); case PV_NF: - return (char_u *)&(buf->b_p_nf); + return (char *)&(buf->b_p_nf); case PV_PI: - return (char_u *)&(buf->b_p_pi); + return (char *)&(buf->b_p_pi); case PV_QE: - return (char_u *)&(buf->b_p_qe); + return (char *)&(buf->b_p_qe); case PV_RO: - return (char_u *)&(buf->b_p_ro); + return (char *)&(buf->b_p_ro); case PV_SCBK: - return (char_u *)&(buf->b_p_scbk); + return (char *)&(buf->b_p_scbk); case PV_SI: - return (char_u *)&(buf->b_p_si); + return (char *)&(buf->b_p_si); case PV_STS: - return (char_u *)&(buf->b_p_sts); + return (char *)&(buf->b_p_sts); case PV_SUA: - return (char_u *)&(buf->b_p_sua); + return (char *)&(buf->b_p_sua); case PV_SWF: - return (char_u *)&(buf->b_p_swf); + return (char *)&(buf->b_p_swf); case PV_SMC: - return (char_u *)&(buf->b_p_smc); + return (char *)&(buf->b_p_smc); case PV_SYN: - return (char_u *)&(buf->b_p_syn); + return (char *)&(buf->b_p_syn); case PV_SPC: - return (char_u *)&(win->w_s->b_p_spc); + return (char *)&(win->w_s->b_p_spc); case PV_SPF: - return (char_u *)&(win->w_s->b_p_spf); + return (char *)&(win->w_s->b_p_spf); case PV_SPL: - return (char_u *)&(win->w_s->b_p_spl); + return (char *)&(win->w_s->b_p_spl); case PV_SPO: - return (char_u *)&(win->w_s->b_p_spo); + return (char *)&(win->w_s->b_p_spo); case PV_SW: - return (char_u *)&(buf->b_p_sw); + return (char *)&(buf->b_p_sw); case PV_TFU: - return (char_u *)&(buf->b_p_tfu); + return (char *)&(buf->b_p_tfu); case PV_TS: - return (char_u *)&(buf->b_p_ts); + return (char *)&(buf->b_p_ts); case PV_TW: - return (char_u *)&(buf->b_p_tw); + return (char *)&(buf->b_p_tw); case PV_UDF: - return (char_u *)&(buf->b_p_udf); + return (char *)&(buf->b_p_udf); case PV_WM: - return (char_u *)&(buf->b_p_wm); + return (char *)&(buf->b_p_wm); case PV_VSTS: - return (char_u *)&(buf->b_p_vsts); + return (char *)&(buf->b_p_vsts); case PV_VTS: - return (char_u *)&(buf->b_p_vts); + return (char *)&(buf->b_p_vts); case PV_KMAP: - return (char_u *)&(buf->b_p_keymap); + return (char *)&(buf->b_p_keymap); case PV_SCL: - return (char_u *)&(win->w_p_scl); + return (char *)&(win->w_p_scl); case PV_WINHL: - return (char_u *)&(win->w_p_winhl); + return (char *)&(win->w_p_winhl); case PV_WINBL: - return (char_u *)&(win->w_p_winbl); + return (char *)&(win->w_p_winbl); case PV_STC: - return (char_u *)&(win->w_p_stc); + return (char *)&(win->w_p_stc); default: iemsg(_("E356: get_varp ERROR")); } // always return a valid pointer to avoid a crash! - return (char_u *)&(buf->b_p_wm); + return (char *)&(buf->b_p_wm); } /// Get pointer to option variable. -static inline char_u *get_varp(vimoption_T *p) +static inline char *get_varp(vimoption_T *p) { return get_varp_from(p, curbuf, curwin); } @@ -4608,7 +4608,7 @@ void set_imsearch_global(buf_T *buf) } static int expand_option_idx = -1; -static char_u expand_option_name[5] = { 't', '_', NUL, NUL, NUL }; +static char expand_option_name[5] = { 't', '_', NUL, NUL, NUL }; static int expand_option_flags = 0; /// @param opt_flags OPT_GLOBAL and/or OPT_LOCAL @@ -4670,8 +4670,8 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags) } nextchar = *++p; is_term_option = true; - expand_option_name[2] = (char_u)KEY2TERMCAP0(key); - expand_option_name[3] = KEY2TERMCAP1(key); + expand_option_name[2] = (char)(uint8_t)KEY2TERMCAP0(key); + expand_option_name[3] = (char)(uint8_t)KEY2TERMCAP1(key); } else { if (p[0] == 't' && p[1] == '_') { p += 2; @@ -4683,8 +4683,8 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags) } nextchar = *++p; is_term_option = true; - expand_option_name[2] = (char_u)p[-2]; - expand_option_name[3] = (char_u)p[-1]; + expand_option_name[2] = p[-2]; + expand_option_name[3] = p[-1]; } else { // Allow * wildcard. while (ASCII_ISALNUM(*p) || *p == '_' || *p == '*') { @@ -4734,7 +4734,7 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags) xp->xp_pattern = p + 1; if (flags & P_EXPAND) { - p = (char *)options[opt_idx].var; + p = options[opt_idx].var; if (p == (char *)&p_bdir || p == (char *)&p_dir || p == (char *)&p_path @@ -4778,7 +4778,7 @@ void set_context_in_set_cmd(expand_T *xp, char *arg, int opt_flags) } // for 'spellsuggest' start at "file:" - if (options[opt_idx].var == (char_u *)&p_sps + if (options[opt_idx].var == (char *)&p_sps && strncmp(p, "file:", 5) == 0) { xp->xp_pattern = p + 5; break; @@ -4915,7 +4915,7 @@ void ExpandOldSetting(int *numMatches, char ***matches) // For a terminal key code expand_option_idx is < 0. if (expand_option_idx < 0) { - expand_option_idx = findoption((const char *)expand_option_name); + expand_option_idx = findoption(expand_option_name); } if (expand_option_idx >= 0) { @@ -4959,8 +4959,8 @@ static void option_value2string(vimoption_T *opp, int scope) if (opp->flags & P_NUM) { long wc = 0; - if (wc_use_keyname((char_u *)varp, &wc)) { - xstrlcpy(NameBuff, (char *)get_special_key_name((int)wc, 0), sizeof(NameBuff)); + if (wc_use_keyname(varp, &wc)) { + xstrlcpy(NameBuff, get_special_key_name((int)wc, 0), sizeof(NameBuff)); } else if (wc != 0) { xstrlcpy(NameBuff, transchar((int)wc), sizeof(NameBuff)); } else { @@ -4984,7 +4984,7 @@ static void option_value2string(vimoption_T *opp, int scope) /// Return true if "varp" points to 'wildchar' or 'wildcharm' and it can be /// printed as a keyname. /// "*wcp" is set to the value of the option if it's 'wildchar' or 'wildcharm'. -static int wc_use_keyname(const char_u *varp, long *wcp) +static int wc_use_keyname(const char *varp, long *wcp) { if (((long *)varp == &p_wc) || ((long *)varp == &p_wcm)) { *wcp = *(long *)varp; @@ -5198,7 +5198,7 @@ void fill_breakat_flags(void) int fill_culopt_flags(char *val, win_T *wp) { char *p; - char_u culopt_flags_new = 0; + uint8_t culopt_flags_new = 0; if (val == NULL) { p = wp->w_p_culopt; @@ -5568,7 +5568,7 @@ dict_T *get_winbuf_options(const int bufopt) if ((bufopt && (opt->indir & PV_BUF)) || (!bufopt && (opt->indir & PV_WIN))) { - char_u *varp = get_varp(opt); + char *varp = get_varp(opt); if (varp != NULL) { if (opt->flags & P_STRING) { @@ -5673,7 +5673,7 @@ static Dictionary vimoption2dict(vimoption_T *opt, int req_scope, buf_T *buf, wi const char *type; Object def; // TODO(bfredl): do you even nocp? - char_u *def_val = (char_u *)opt->def_val; + char *def_val = opt->def_val; if (opt->flags & P_STRING) { type = "string"; def = CSTR_TO_OBJ(def_val ? (char *)def_val : ""); diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h index de289fe54e..b7ea8cd2c2 100644 --- a/src/nvim/option_defs.h +++ b/src/nvim/option_defs.h @@ -993,7 +993,7 @@ typedef struct vimoption { char *fullname; // full option name char *shortname; // permissible abbreviation uint32_t flags; // see below - char_u *var; // global option: pointer to variable; + char *var; // global option: pointer to variable; // window-local option: VAR_WIN; // buffer-local option: global value idopt_T indir; // global option: PV_NONE; @@ -1018,6 +1018,6 @@ typedef struct vimoption { // Options local to a window have a value local to a buffer and global to all // buffers. Indicate this by setting "var" to VAR_WIN. -#define VAR_WIN ((char_u *)-1) +#define VAR_WIN ((char *)-1) #endif // NVIM_OPTION_DEFS_H diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c index 30092b9142..5b8c060e7a 100644 --- a/src/nvim/os/env.c +++ b/src/nvim/os/env.c @@ -494,7 +494,7 @@ void init_homedir(void) // links. Don't do it when we can't return. if (os_dirname(os_buf, MAXPATHL) == OK && os_chdir(os_buf) == 0) { if (!os_chdir(var) && os_dirname(IObuff, IOSIZE) == OK) { - var = (char *)IObuff; + var = IObuff; } if (os_chdir(os_buf) != 0) { emsg(_(e_prev_dir)); diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c index 122f3e2020..0b9a9bbdec 100644 --- a/src/nvim/regexp.c +++ b/src/nvim/regexp.c @@ -2304,10 +2304,10 @@ static uint8_t regname[][30] = { // Returns the program in allocated memory. // Use vim_regfree() to free the memory. // Returns NULL for an error. -regprog_T *vim_regcomp(char *expr_arg, int re_flags) +regprog_T *vim_regcomp(const char *expr_arg, int re_flags) { regprog_T *prog = NULL; - char *expr = expr_arg; + const char *expr = expr_arg; regexp_engine = (int)p_re; @@ -2403,7 +2403,7 @@ void free_regexp_stuff(void) #endif -static void report_re_switch(char *pat) +static void report_re_switch(const char *pat) { if (p_verbose > 0) { verbose_enter(); @@ -2425,7 +2425,7 @@ static void report_re_switch(char *pat) /// @param nl /// /// @return true if there is a match, false if not. -static bool vim_regexec_string(regmatch_T *rmp, char *line, colnr_T col, bool nl) +static bool vim_regexec_string(regmatch_T *rmp, const char *line, colnr_T col, bool nl) { regexec_T rex_save; bool rex_in_use_save = rex_in_use; @@ -2482,7 +2482,7 @@ static bool vim_regexec_string(regmatch_T *rmp, char *line, colnr_T col, bool nl // Note: "*prog" may be freed and changed. // Return true if there is a match, false if not. -bool vim_regexec_prog(regprog_T **prog, bool ignore_case, char *line, colnr_T col) +bool vim_regexec_prog(regprog_T **prog, bool ignore_case, const char *line, colnr_T col) { regmatch_T regmatch = { .regprog = *prog, .rm_ic = ignore_case }; bool r = vim_regexec_string(®match, line, col, false); @@ -2492,7 +2492,7 @@ bool vim_regexec_prog(regprog_T **prog, bool ignore_case, char *line, colnr_T co // Note: "rmp->regprog" may be freed and changed. // Return true if there is a match, false if not. -bool vim_regexec(regmatch_T *rmp, char *line, colnr_T col) +bool vim_regexec(regmatch_T *rmp, const char *line, colnr_T col) { return vim_regexec_string(rmp, line, col, false); } @@ -2500,7 +2500,7 @@ bool vim_regexec(regmatch_T *rmp, char *line, colnr_T col) // Like vim_regexec(), but consider a "\n" in "line" to be a line break. // Note: "rmp->regprog" may be freed and changed. // Return true if there is a match, false if not. -bool vim_regexec_nl(regmatch_T *rmp, char *line, colnr_T col) +bool vim_regexec_nl(regmatch_T *rmp, const char *line, colnr_T col) { return vim_regexec_string(rmp, line, col, true); } diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c index c9667d58ed..5d1c104dc5 100644 --- a/src/nvim/runtime.c +++ b/src/nvim/runtime.c @@ -914,19 +914,6 @@ static int add_pack_dir_to_rtp(char *fname, bool is_pack) const char *cur_entry = entry; copy_option_part((char **)&entry, buf, MAXPATHL, ","); - if (insp == NULL) { - add_pathsep(buf); - char *const rtp_ffname = fix_fname(buf); - if (rtp_ffname == NULL) { - goto theend; - } - bool match = path_fnamencmp(rtp_ffname, ffname, fname_len) == 0; - xfree(rtp_ffname); - if (match) { - // Insert "ffname" after this entry (and comma). - insp = entry; - } - } if ((p = strstr(buf, "after")) != NULL && p > buf @@ -940,6 +927,20 @@ static int add_pack_dir_to_rtp(char *fname, bool is_pack) after_insp = cur_entry; break; } + + if (insp == NULL) { + add_pathsep(buf); + char *const rtp_ffname = fix_fname(buf); + if (rtp_ffname == NULL) { + goto theend; + } + bool match = path_fnamencmp(rtp_ffname, ffname, fname_len) == 0; + xfree(rtp_ffname); + if (match) { + // Insert "ffname" after this entry (and comma). + insp = entry; + } + } } if (insp == NULL) { diff --git a/src/nvim/search.c b/src/nvim/search.c index 67b6f5e6a6..525cec8b02 100644 --- a/src/nvim/search.c +++ b/src/nvim/search.c @@ -4159,10 +4159,10 @@ static void show_pat_in_path(char *line, int type, bool did_show, int action, FI } if (action == ACTION_SHOW_ALL) { snprintf(IObuff, IOSIZE, "%3ld: ", count); // Show match nr. - msg_puts((const char *)IObuff); + msg_puts(IObuff); snprintf(IObuff, IOSIZE, "%4" PRIdLINENR, *lnum); // Show line nr. // Highlight line numbers. - msg_puts_attr((const char *)IObuff, HL_ATTR(HLF_N)); + msg_puts_attr(IObuff, HL_ATTR(HLF_N)); msg_puts(" "); } msg_prt_line(line, false); diff --git a/src/nvim/spell.c b/src/nvim/spell.c index c65f822080..9108059b4d 100644 --- a/src/nvim/spell.c +++ b/src/nvim/spell.c @@ -150,7 +150,7 @@ typedef struct matchinf_S { // for when checking a compound word int mi_compoff; // start of following word offset - char_u mi_compflags[MAXWLEN]; // flags for compound words used + uint8_t mi_compflags[MAXWLEN]; // flags for compound words used int mi_complen; // nr of compound words used int mi_compextra; // nr of COMPOUNDROOT words @@ -961,7 +961,7 @@ bool can_compound(slang_T *slang, const char *word, const uint8_t *flags) // compound rule. This is used to stop trying a compound if the flags // collected so far can't possibly match any compound rule. // Caller must check that slang->sl_comprules is not NULL. -bool match_compoundrule(slang_T *slang, const char_u *compflags) +bool match_compoundrule(slang_T *slang, const uint8_t *compflags) { // loop over all the COMPOUNDRULE entries for (char *p = (char *)slang->sl_comprules; *p != NUL; p++) { @@ -1748,7 +1748,7 @@ void count_common_word(slang_T *lp, char *word, int len, uint8_t count) wc = xmalloc(offsetof(wordcount_T, wc_word) + p_len + 1); memcpy(wc->wc_word, p, p_len + 1); wc->wc_count = count; - hash_add_item(&lp->sl_wordcount, hi, (char *)wc->wc_word, hash); + hash_add_item(&lp->sl_wordcount, hi, wc->wc_word, hash); } else { wc = HI2WC(hi); wc->wc_count = (uint16_t)(wc->wc_count + count); diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h index 1c163071c5..0b95cfed8e 100644 --- a/src/nvim/spell_defs.h +++ b/src/nvim/spell_defs.h @@ -243,7 +243,7 @@ typedef enum { typedef struct wordcount_S { uint16_t wc_count; ///< nr of times word was seen - char_u wc_word[]; ///< word + char wc_word[]; ///< word } wordcount_T; #define WC_KEY_OFF offsetof(wordcount_T, wc_word) diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c index 8927b599d0..aa76dcbd32 100644 --- a/src/nvim/spellfile.c +++ b/src/nvim/spellfile.c @@ -404,14 +404,14 @@ typedef struct sblock_S sblock_T; struct sblock_S { int sb_used; // nr of bytes already in use sblock_T *sb_next; // next block in list - char_u sb_data[]; // data + char sb_data[]; // data }; // A node in the tree. typedef struct wordnode_S wordnode_T; struct wordnode_S { union { // shared to save space - char_u hashkey[6]; // the hash key, only used while compressing + uint8_t hashkey[6]; // the hash key, only used while compressing int index; // index in written nodes (valid after first // round) } wn_u1; @@ -422,17 +422,17 @@ struct wordnode_S { wordnode_T *wn_child; // child (next byte in word) wordnode_T *wn_sibling; // next sibling (alternate byte in word, // always sorted) - int wn_refs; // Nr. of references to this node. Only - // relevant for first node in a list of - // siblings, in following siblings it is - // always one. - char_u wn_byte; // Byte for this node. NUL for word end + int wn_refs; // Nr. of references to this node. Only + // relevant for first node in a list of + // siblings, in following siblings it is + // always one. + uint8_t wn_byte; // Byte for this node. NUL for word end // Info for when "wn_byte" is NUL. // In PREFIXTREE "wn_region" is used for the prefcondnr. // In the soundfolded word tree "wn_flags" has the MSW of the wordnr and // "wn_region" the LSW of the wordnr. - char_u wn_affixID; // supported/required prefix ID or 0 + uint8_t wn_affixID; // supported/required prefix ID or 0 uint16_t wn_flags; // WF_ flags int16_t wn_region; // region mask @@ -482,7 +482,7 @@ typedef struct spellinfo_S { char *si_info; // info text chars or NULL int si_region_count; // number of regions supported (1 when there // are no regions) - char_u si_region_name[MAXREGIONS * 2 + 1]; + char si_region_name[MAXREGIONS * 2 + 1]; // region names; used only if // si_region_count > 1) @@ -508,7 +508,7 @@ typedef struct spellinfo_S { garray_T si_comppat; // CHECKCOMPOUNDPATTERN items, each stored as // a string char *si_compflags; // flags used for compounding - char_u si_nobreak; // NOBREAK + char si_nobreak; // NOBREAK char *si_syllable; // syllable string garray_T si_prefcond; // table with conditions for postponed // prefixes, each stored as a string @@ -608,7 +608,7 @@ slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent) semsg(_(e_notopen), fname); } else if (p_verbose > 2) { verbose_enter(); - smsg((char *)e_notopen, fname); + smsg(e_notopen, fname); verbose_leave(); } goto endFAIL; @@ -985,7 +985,7 @@ someerror: if (c < 0) { goto someerror; } - GA_APPEND(char_u, &ga, (char_u)c); + GA_APPEND(uint8_t, &ga, (uint8_t)c); if (c == NUL) { break; } @@ -1060,7 +1060,7 @@ static int read_region_section(FILE *fd, slang_T *lp, int len) static int read_charflags_section(FILE *fd) { char *flags; - char_u *fol; + char *fol; int flagslen, follen; // <charflagslen> <charflags> @@ -1070,7 +1070,7 @@ static int read_charflags_section(FILE *fd) } // <folcharslen> <folchars> - fol = (char_u *)read_cnt_string(fd, 2, &follen); + fol = read_cnt_string(fd, 2, &follen); if (follen < 0) { xfree(flags); return follen; @@ -1078,7 +1078,7 @@ static int read_charflags_section(FILE *fd) // Set the word-char flags and fill SPELL_ISUPPER() table. if (flags != NULL && fol != NULL) { - set_spell_charflags(flags, flagslen, (char *)fol); + set_spell_charflags(flags, flagslen, fol); } xfree(flags); @@ -2538,9 +2538,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname) if (idx < 0) { // Not found, add a new condition. idx = spin->si_prefcond.ga_len; - char_u **pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond); + char **pp = GA_APPEND_VIA_PTR(char *, &spin->si_prefcond); *pp = (aff_entry->ae_cond == NULL) ? - NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond); + NULL : getroom_save(spin, aff_entry->ae_cond); } // Add the prefix to the prefix tree. @@ -2565,7 +2565,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char *fname) if (aff_entry->ae_compforbid) { n |= WFP_COMPFORBID; } - tree_add_word(spin, (char_u *)p, spin->si_prefroot, n, + tree_add_word(spin, p, spin->si_prefroot, n, idx, cur_aff->ah_newID); did_postpone_prefix = true; } @@ -3232,7 +3232,7 @@ static int spell_read_dic(spellinfo_T *spin, char *fname, afffile_T *affile) if (spin->si_compflags != NULL) { // Need to store the list of compound flags with the word. // Concatenate them to the list of prefix IDs. - get_compflags(affile, afflist, (char_u *)store_afflist + pfxlen); + get_compflags(affile, afflist, store_afflist + pfxlen); } } @@ -3349,7 +3349,7 @@ static int get_pfxlist(afffile_T *affile, char *afflist, char *store_afflist) // Get the list of compound IDs from the affix list "afflist" that are used // for compound words. // Puts the flags in "store_afflist[]". -static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflist) +static void get_compflags(afffile_T *affile, char *afflist, char *store_afflist) { int cnt = 0; char key[AH_KEY_LEN]; @@ -3362,7 +3362,7 @@ static void get_compflags(afffile_T *affile, char *afflist, char_u *store_afflis xstrlcpy(key, prevp, (size_t)(p - prevp) + 1); hi = hash_find(&affile->af_comp, (char *)key); if (!HASHITEM_EMPTY(hi)) { - store_afflist[cnt++] = (char_u)HI2CI(hi)->ci_newID; + store_afflist[cnt++] = (char)(uint8_t)HI2CI(hi)->ci_newID; } } if (affile->af_flagtype == AFT_NUM && *p == ',') { @@ -3530,7 +3530,7 @@ static int store_aff_word(spellinfo_T *spin, char *word, char *afflist, afffile_ if (spin->si_compflags != NULL) { // Get compound IDS from the affix list. get_compflags(affile, ae->ae_flags, - (char_u *)use_pfxlist + use_pfxlen); + use_pfxlist + use_pfxlen); } else { use_pfxlist[use_pfxlen] = NUL; } @@ -3835,7 +3835,7 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align) spin->si_blocks_cnt++; } - p = (char *)bl->sb_data + bl->sb_used; + p = bl->sb_data + bl->sb_used; bl->sb_used += (int)len; return p; @@ -3913,7 +3913,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons (void)spell_casefold(curwin, word, len, foldword, MAXWLEN); for (const char *p = pfxlist; res == OK; p++) { if (!need_affix || (p != NULL && *p != NUL)) { - res = tree_add_word(spin, (char_u *)foldword, spin->si_foldroot, ct | flags, + res = tree_add_word(spin, foldword, spin->si_foldroot, ct | flags, region, p == NULL ? 0 : *p); } if (p == NULL || *p == NUL) { @@ -3925,7 +3925,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) { for (const char *p = pfxlist; res == OK; p++) { if (!need_affix || (p != NULL && *p != NUL)) { - res = tree_add_word(spin, (char_u *)word, spin->si_keeproot, flags, + res = tree_add_word(spin, word, spin->si_keeproot, flags, region, p == NULL ? 0 : *p); } if (p == NULL || *p == NUL) { @@ -3941,7 +3941,7 @@ static int store_word(spellinfo_T *spin, char *word, int flags, int region, cons // When "flags" < 0 we are adding to the prefix tree where "flags" is used for // "rare" and "region" is the condition nr. // Returns FAIL when out of memory. -static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root, int flags, +static int tree_add_word(spellinfo_T *spin, const char *word, wordnode_T *root, int flags, int region, int affixID) { wordnode_T *node = root; @@ -3993,7 +3993,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root // higher byte value. For zero bytes (end of word) the sorting is // done on flags and then on affixID. while (node != NULL - && (node->wn_byte < word[i] + && (node->wn_byte < (uint8_t)word[i] || (node->wn_byte == NUL && (flags < 0 ? node->wn_affixID < (unsigned)affixID @@ -4007,7 +4007,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root node = *prev; } if (node == NULL - || node->wn_byte != word[i] + || node->wn_byte != (uint8_t)word[i] || (word[i] == NUL && (flags < 0 || spin->si_sugtree @@ -4018,7 +4018,7 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root if (np == NULL) { return FAIL; } - np->wn_byte = word[i]; + np->wn_byte = (uint8_t)word[i]; // If "node" is NULL this is a new child or the end of the sibling // list: ref count is one. Otherwise use ref count of sibling and @@ -4040,14 +4040,14 @@ static int tree_add_word(spellinfo_T *spin, const char_u *word, wordnode_T *root if (word[i] == NUL) { node->wn_flags = (uint16_t)flags; node->wn_region |= (int16_t)region; - node->wn_affixID = (char_u)affixID; + node->wn_affixID = (uint8_t)affixID; break; } prev = &node->wn_child; node = *prev; } #ifdef SPELL_PRINTTREE - smsg((char_u *)"Added \"%s\"", word); + smsg("Added \"%s\"", word); spell_print_tree(root->wn_sibling); #endif @@ -4266,7 +4266,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo // Make a hash key for the node and its siblings, so that we can quickly // find a lookalike node. This must be done after compressing the sibling // list, otherwise the hash key would become invalid by the compression. - node->wn_u1.hashkey[0] = (char_u)len; + node->wn_u1.hashkey[0] = (uint8_t)len; nr = 0; for (np = node; np != NULL; np = np->wn_sibling) { if (np->wn_byte == NUL) { @@ -4281,13 +4281,13 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo // Avoid NUL bytes, it terminates the hash key. n = nr & 0xff; - node->wn_u1.hashkey[1] = n == 0 ? 1 : (char_u)n; + node->wn_u1.hashkey[1] = n == 0 ? 1 : (uint8_t)n; n = (nr >> 8) & 0xff; - node->wn_u1.hashkey[2] = n == 0 ? 1 : (char_u)n; + node->wn_u1.hashkey[2] = n == 0 ? 1 : (uint8_t)n; n = (nr >> 16) & 0xff; - node->wn_u1.hashkey[3] = n == 0 ? 1 : (char_u)n; + node->wn_u1.hashkey[3] = n == 0 ? 1 : (uint8_t)n; n = (nr >> 24) & 0xff; - node->wn_u1.hashkey[4] = n == 0 ? 1 : (char_u)n; + node->wn_u1.hashkey[4] = n == 0 ? 1 : (uint8_t)n; node->wn_u1.hashkey[5] = NUL; // Check for CTRL-C pressed now and then. @@ -4957,8 +4957,8 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang) int depth; idx_T arridx[MAXWLEN]; int curi[MAXWLEN]; - char_u tword[MAXWLEN]; - char_u tsalword[MAXWLEN]; + char tword[MAXWLEN]; + char tsalword[MAXWLEN]; int c; idx_T n; unsigned words_done = 0; @@ -4999,7 +4999,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang) if (c == 0) { // Sound-fold the word. tword[depth] = NUL; - spell_soundfold(slang, (char *)tword, true, (char *)tsalword); + spell_soundfold(slang, tword, true, tsalword); // We use the "flags" field for the MSB of the wordnr, // "region" for the LSB of the wordnr. @@ -5024,7 +5024,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang) } } else { // Normal char, go one level deeper. - tword[depth++] = (char_u)c; + tword[depth++] = (char)(uint8_t)c; arridx[depth] = idxs[n]; curi[depth] = 1; wordcount[depth] = 0; @@ -5090,12 +5090,11 @@ static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, g // following bytes. nr -= prev_nr; prev_nr += nr; - gap->ga_len += offset2bytes(nr, - (char_u *)gap->ga_data + gap->ga_len); + gap->ga_len += offset2bytes(nr, (char *)gap->ga_data + gap->ga_len); } // add the NUL byte - ((char_u *)gap->ga_data)[gap->ga_len++] = NUL; + ((char *)gap->ga_data)[gap->ga_len++] = NUL; if (ml_append_buf(spin->si_spellbuf, (linenr_T)wordnr, gap->ga_data, gap->ga_len, true) == FAIL) { @@ -5126,8 +5125,9 @@ static int sug_filltable(spellinfo_T *spin, wordnode_T *node, int startwordnr, g // Convert an offset into a minimal number of bytes. // Similar to utf_char2byters, but use 8 bits in followup bytes and avoid NUL // bytes. -static int offset2bytes(int nr, char_u *buf) +static int offset2bytes(int nr, char *buf_in) { + uint8_t *buf = (uint8_t *)buf_in; int rem; int b1, b2, b3, b4; @@ -5140,25 +5140,25 @@ static int offset2bytes(int nr, char_u *buf) b4 = rem / 255 + 1; if (b4 > 1 || b3 > 0x1f) { // 4 bytes - buf[0] = (char_u)(0xe0 + b4); - buf[1] = (char_u)b3; - buf[2] = (char_u)b2; - buf[3] = (char_u)b1; + buf[0] = (uint8_t)(0xe0 + b4); + buf[1] = (uint8_t)b3; + buf[2] = (uint8_t)b2; + buf[3] = (uint8_t)b1; return 4; } if (b3 > 1 || b2 > 0x3f) { // 3 bytes - buf[0] = (char_u)(0xc0 + b3); - buf[1] = (char_u)b2; - buf[2] = (char_u)b1; + buf[0] = (uint8_t)(0xc0 + b3); + buf[1] = (uint8_t)b2; + buf[2] = (uint8_t)b1; return 3; } if (b2 > 1 || b1 > 0x7f) { // 2 bytes - buf[0] = (char_u)(0x80 + b2); - buf[1] = (char_u)b1; + buf[0] = (uint8_t)(0x80 + b2); + buf[1] = (uint8_t)b1; return 2; } // 1 byte - buf[0] = (char_u)b1; + buf[0] = (uint8_t)b1; return 1; } @@ -5342,8 +5342,8 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool semsg(_("E755: Invalid region in %s"), innames[i]); goto theend; } - spin.si_region_name[i * 2] = (char_u)TOLOWER_ASC(innames[i][len - 2]); - spin.si_region_name[i * 2 + 1] = (char_u)TOLOWER_ASC(innames[i][len - 1]); + spin.si_region_name[i * 2] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 2]); + spin.si_region_name[i * 2 + 1] = (char)(uint8_t)TOLOWER_ASC(innames[i][len - 1]); } } spin.si_region_count = incount; @@ -5599,21 +5599,21 @@ void spell_add_word(char *word, int len, SpellAddType what, int idx, bool undo) if (!undo) { fd = os_fopen(fname, "a"); if (fd == NULL && new_spf) { - char_u *p; + char *p; // We just initialized the 'spellfile' option and can't open the // file. We may need to create the "spell" directory first. We // already checked the runtime directory is writable in // init_spellfile(). if (!dir_of_file_exists(fname) - && (p = (char_u *)path_tail_with_sep(fname)) != (char_u *)fname) { - int c = *p; + && (p = path_tail_with_sep(fname)) != fname) { + char c = *p; // The directory doesn't exist. Try creating it and opening // the file again. *p = NUL; os_mkdir(fname, 0755); - *p = (char_u)c; + *p = c; fd = os_fopen(fname, "a"); } } diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c index 705e215dfa..d28460a63d 100644 --- a/src/nvim/spellsuggest.c +++ b/src/nvim/spellsuggest.c @@ -551,7 +551,7 @@ void spell_suggest(int count) vim_snprintf(IObuff, IOSIZE, ":ot \"%.*s\" egnahC", sug.su_badlen, sug.su_badptr); } - msg_puts((const char *)IObuff); + msg_puts(IObuff); msg_clr_eos(); msg_putchar('\n'); @@ -570,16 +570,16 @@ void spell_suggest(int count) if (cmdmsg_rl) { rl_mirror_ascii(IObuff); } - msg_puts((const char *)IObuff); + msg_puts(IObuff); vim_snprintf(IObuff, IOSIZE, " \"%s\"", wcopy); - msg_puts((const char *)IObuff); + msg_puts(IObuff); // The word may replace more than "su_badlen". if (sug.su_badlen < stp->st_orglen) { vim_snprintf(IObuff, IOSIZE, _(" < \"%.*s\""), stp->st_orglen, sug.su_badptr); - msg_puts((const char *)IObuff); + msg_puts(IObuff); } if (p_verbose > 0) { @@ -597,7 +597,7 @@ void spell_suggest(int count) rl_mirror_ascii(IObuff + 1); } msg_advance(30); - msg_puts((const char *)IObuff); + msg_puts(IObuff); } msg_putchar('\n'); } diff --git a/src/nvim/state.c b/src/nvim/state.c index d02ea46d31..160bc3cd69 100644 --- a/src/nvim/state.c +++ b/src/nvim/state.c @@ -92,7 +92,7 @@ getkey: } #ifdef NVIM_LOG_DEBUG - char *keyname = key == K_EVENT ? "K_EVENT" : (char *)get_special_key_name(key, mod_mask); + char *keyname = key == K_EVENT ? "K_EVENT" : get_special_key_name(key, mod_mask); DLOG("input: %s", keyname); #endif diff --git a/src/nvim/tag.c b/src/nvim/tag.c index 852e7e6e7c..2d9d0de951 100644 --- a/src/nvim/tag.c +++ b/src/nvim/tag.c @@ -726,7 +726,7 @@ void do_tag(char *tag, int type, int count, int forceit, int verbose) if ((num_matches > prev_num_matches || new_tag) && num_matches > 1) { if (ic) { - msg_attr((const char *)IObuff, HL_ATTR(HLF_W)); + msg_attr(IObuff, HL_ATTR(HLF_W)); } else { msg(IObuff); } diff --git a/src/nvim/types.h b/src/nvim/types.h index d90c623955..0bc2f76078 100644 --- a/src/nvim/types.h +++ b/src/nvim/types.h @@ -7,10 +7,6 @@ // dummy to pass an ACL to a function typedef void *vim_acl_T; -// Shorthand for unsigned variables. Many systems, but not all, have u_char -// already defined, so we use char_u to avoid trouble. -typedef unsigned char char_u; - // Can hold one decoded UTF-8 character. typedef uint32_t u8char_T; diff --git a/test/functional/api/extmark_spec.lua b/test/functional/api/extmark_spec.lua index 3882fc90ca..4bd8f51904 100644 --- a/test/functional/api/extmark_spec.lua +++ b/test/functional/api/extmark_spec.lua @@ -1463,6 +1463,7 @@ describe('API/extmarks', function() end_line = 1 }) eq({ {1, 0, 0, { + ns_id = 1, end_col = 0, end_row = 1, right_gravity = true, @@ -1480,20 +1481,27 @@ describe('API/extmarks', function() it('can get details', function() set_extmark(ns, marks[1], 0, 0, { + conceal = "c", + cursorline_hl_group = "Statement", end_col = 0, - end_row = 1, - right_gravity = false, end_right_gravity = true, - priority = 0, + end_row = 1, hl_eol = true, - hl_mode = "blend", hl_group = "String", - virt_text = { { "text", "Statement" } }, - virt_text_pos = "right_align", - virt_text_hide = true, + hl_mode = "blend", + line_hl_group = "Statement", + number_hl_group = "Statement", + priority = 0, + right_gravity = false, + sign_hl_group = "Statement", + sign_text = ">>", + spell = true, virt_lines = { { { "lines", "Statement" } }}, virt_lines_above = true, virt_lines_leftcol = true, + virt_text = { { "text", "Statement" } }, + virt_text_hide = true, + virt_text_pos = "right_align", }) set_extmark(ns, marks[2], 0, 0, { priority = 0, @@ -1501,22 +1509,31 @@ describe('API/extmarks', function() virt_text_win_col = 1, }) eq({0, 0, { + conceal = "c", + cursorline_hl_group = "Statement", end_col = 0, - end_row = 1, - right_gravity = false, end_right_gravity = true, - priority = 0, + end_row = 1, hl_eol = true, - hl_mode = "blend", hl_group = "String", - virt_text = { { "text", "Statement" } }, - virt_text_pos = "right_align", - virt_text_hide = true, + hl_mode = "blend", + line_hl_group = "Statement", + ns_id = 1, + number_hl_group = "Statement", + priority = 0, + right_gravity = false, + sign_hl_group = "Statement", + sign_text = ">>", + spell = true, virt_lines = { { { "lines", "Statement" } }}, virt_lines_above = true, virt_lines_leftcol = true, + virt_text = { { "text", "Statement" } }, + virt_text_hide = true, + virt_text_pos = "right_align", } }, get_extmark_by_id(ns, marks[1], { details = true })) eq({0, 0, { + ns_id = 1, right_gravity = true, priority = 0, virt_text = { { "text", "Statement" } }, @@ -1525,6 +1542,29 @@ describe('API/extmarks', function() virt_text_win_col = 1, } }, get_extmark_by_id(ns, marks[2], { details = true })) end) + + it('can get marks from anonymous namespaces', function() + ns = request('nvim_create_namespace', "") + ns2 = request('nvim_create_namespace', "") + set_extmark(ns, 1, 0, 0, {}) + set_extmark(ns2, 2, 1, 0, {}) + eq({{ 1, 0, 0, { ns_id = ns, right_gravity = true }}, + { 2, 1, 0, { ns_id = ns2, right_gravity = true }}}, + get_extmarks(-1, 0, -1, { details = true })) + end) + + it('can filter by extmark properties', function() + set_extmark(ns, 1, 0, 0, {}) + set_extmark(ns, 2, 0, 0, { hl_group = 'Normal' }) + set_extmark(ns, 3, 0, 0, { sign_text = '>>' }) + set_extmark(ns, 4, 0, 0, { virt_text = {{'text', 'Normal'}}}) + set_extmark(ns, 5, 0, 0, { virt_lines = {{{ 'line', 'Normal' }}}}) + eq(5, #get_extmarks(-1, 0, -1, { details = true })) + eq({{ 2, 0, 0 }}, get_extmarks(-1, 0, -1, { type = 'highlight' })) + eq({{ 3, 0, 0 }}, get_extmarks(-1, 0, -1, { type = 'sign' })) + eq({{ 4, 0, 0 }}, get_extmarks(-1, 0, -1, { type = 'virt_text' })) + eq({{ 5, 0, 0 }}, get_extmarks(-1, 0, -1, { type = 'virt_lines' })) + end) end) describe('Extmarks buffer api with many marks', function() diff --git a/test/functional/lua/ffi_spec.lua b/test/functional/lua/ffi_spec.lua index c492c1e765..3a37b18cd1 100644 --- a/test/functional/lua/ffi_spec.lua +++ b/test/functional/lua/ffi_spec.lua @@ -25,7 +25,6 @@ describe('ffi.cdef', function() local ffi = require('ffi') ffi.cdef[[ - typedef unsigned char char_u; typedef struct window_S win_T; typedef struct {} stl_hlrec_t; typedef struct {} StlClickRecord; diff --git a/test/functional/lua/vim_spec.lua b/test/functional/lua/vim_spec.lua index a0428ed933..4f401eed8f 100644 --- a/test/functional/lua/vim_spec.lua +++ b/test/functional/lua/vim_spec.lua @@ -2915,6 +2915,15 @@ describe('lua stdlib', function() return a ]]) end) + + it('accepts the key name', function() + eq({ b = 'b', c = 'c' }, exec_lua [[ + local a = vim.defaulttable(function(k) return k end) + local _ = a.b + local _ = a.c + return a + ]]) + end) end) it('vim.lua_omnifunc', function() diff --git a/test/functional/treesitter/highlight_spec.lua b/test/functional/treesitter/highlight_spec.lua index 44e6500008..4e1efec404 100644 --- a/test/functional/treesitter/highlight_spec.lua +++ b/test/functional/treesitter/highlight_spec.lua @@ -413,7 +413,7 @@ describe('treesitter highlighting', function() it("supports injected languages", function() insert([[ int x = INT_MAX; - #define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) + #define READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) #define foo void main() { \ return 42; \ } @@ -421,7 +421,7 @@ describe('treesitter highlighting', function() screen:expect{grid=[[ int x = INT_MAX; | - #define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y))| + #define READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) | #define foo void main() { \ | return 42; \ | } | @@ -450,7 +450,7 @@ describe('treesitter highlighting', function() screen:expect{grid=[[ {3:int} x = {5:INT_MAX}; | - #define {5:READ_STRING}(x, y) ({3:char_u} *)read_string((x), ({3:size_t})(y))| + #define {5:READ_STRING}(x, y) ({3:char} *)read_string((x), ({3:size_t})(y)) | #define foo {3:void} main() { \ | {4:return} {5:42}; \ | } | @@ -473,7 +473,7 @@ describe('treesitter highlighting', function() it("supports overriding queries, like ", function() insert([[ int x = INT_MAX; - #define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) + #define READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) #define foo void main() { \ return 42; \ } @@ -489,7 +489,7 @@ describe('treesitter highlighting', function() screen:expect{grid=[[ {3:int} x = {5:INT_MAX}; | - #define {5:READ_STRING}(x, y) ({3:char_u} *)read_string((x), ({3:size_t})(y))| + #define {5:READ_STRING}(x, y) ({3:char} *)read_string((x), ({3:size_t})(y)) | #define foo {3:void} main() { \ | {4:return} {5:42}; \ | } | @@ -567,7 +567,7 @@ describe('treesitter highlighting', function() it("supports highlighting with priority", function() insert([[ int x = INT_MAX; - #define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) + #define READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) #define foo void main() { \ return 42; \ } @@ -575,14 +575,14 @@ describe('treesitter highlighting', function() exec_lua [[ local parser = vim.treesitter.get_parser(0, "c") - test_hl = vim.treesitter.highlighter.new(parser, {queries = {c = hl_query..'\n((translation_unit) @Error (set! "priority" 101))\n'}}) + test_hl = vim.treesitter.highlighter.new(parser, {queries = {c = hl_query..'\n((translation_unit) @constant (#set! "priority" 101))\n'}}) ]] - -- expect everything to have Error highlight + -- expect everything to have Constant highlight screen:expect{grid=[[ {12:int}{8: x = INT_MAX;} | - {8:#define READ_STRING(x, y) (}{12:char_u}{8: *)read_string((x), (}{12:size_t}{8:)(y))}| - {8:#define foo }{12:void}{8: main() { \} | - {8: }{12:return}{8: 42; \} | + {8:#define READ_STRING(x, y) (char *)read_string((x), (size_t)(y))} | + {8:#define foo void main() { \} | + {8: return 42; \} | {8: }} | ^ | {1:~ }| @@ -599,13 +599,13 @@ describe('treesitter highlighting', function() | ]], attr_ids={ [1] = {bold = true, foreground = Screen.colors.Blue1}; - [8] = {foreground = Screen.colors.Grey100, background = Screen.colors.Red}; + [8] = {foreground = Screen.colors.Magenta1}; -- bold will not be overwritten at the moment - [12] = {background = Screen.colors.Red, bold = true, foreground = Screen.colors.Grey100}; + [12] = {bold = true, foreground = Screen.colors.Magenta1}; }} eq({ - {capture='Error', metadata = { priority='101' }, lang='c' }; + {capture='constant', metadata = { priority='101' }, lang='c' }; {capture='type', metadata = { }, lang='c' }; }, exec_lua [[ return vim.treesitter.get_captures_at_pos(0, 0, 2) ]]) end) diff --git a/test/functional/treesitter/parser_spec.lua b/test/functional/treesitter/parser_spec.lua index 72a8cd9e9b..ea9958b12a 100644 --- a/test/functional/treesitter/parser_spec.lua +++ b/test/functional/treesitter/parser_spec.lua @@ -627,8 +627,8 @@ end]] before_each(function() insert([[ int x = INT_MAX; -#define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) -#define READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) +#define READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) +#define READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) #define VALUE 123 #define VALUE1 123 #define VALUE2 123 @@ -650,8 +650,8 @@ int x = INT_MAX; {3, 14, 3, 17}, -- VALUE 123 {4, 15, 4, 18}, -- VALUE1 123 {5, 15, 5, 18}, -- VALUE2 123 - {1, 26, 1, 65}, -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - {2, 29, 2, 68} -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {1, 26, 1, 63}, -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + {2, 29, 2, 66} -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) helpers.feed('ggo<esc>') @@ -661,8 +661,8 @@ int x = INT_MAX; {4, 14, 4, 17}, -- VALUE 123 {5, 15, 5, 18}, -- VALUE1 123 {6, 15, 6, 18}, -- VALUE2 123 - {2, 26, 2, 65}, -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - {3, 29, 3, 68} -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {2, 26, 2, 63}, -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + {3, 29, 3, 66} -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) end) end) @@ -682,8 +682,8 @@ int x = INT_MAX; {3, 14, 5, 18}, -- VALUE 123 -- VALUE1 123 -- VALUE2 123 - {1, 26, 2, 68} -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {1, 26, 2, 66} -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) helpers.feed('ggo<esc>') @@ -694,8 +694,8 @@ int x = INT_MAX; {4, 14, 6, 18}, -- VALUE 123 -- VALUE1 123 -- VALUE2 123 - {2, 26, 3, 68} -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {2, 26, 3, 66} -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) end) end) @@ -722,8 +722,8 @@ int x = INT_MAX; {3, 14, 5, 18}, -- VALUE 123 -- VALUE1 123 -- VALUE2 123 - {1, 26, 2, 68} -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {1, 26, 2, 66} -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) helpers.feed('ggo<esc>') @@ -734,8 +734,8 @@ int x = INT_MAX; {4, 14, 6, 18}, -- VALUE 123 -- VALUE1 123 -- VALUE2 123 - {2, 26, 3, 68} -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {2, 26, 3, 66} -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) end) @@ -768,8 +768,8 @@ int x = INT_MAX; {3, 15, 3, 16}, -- VALUE 123 {4, 16, 4, 17}, -- VALUE1 123 {5, 16, 5, 17}, -- VALUE2 123 - {1, 26, 1, 65}, -- READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y)) - {2, 29, 2, 68} -- READ_STRING_OK(x, y) (char_u *)read_string((x), (size_t)(y)) + {1, 26, 1, 63}, -- READ_STRING(x, y) (char *)read_string((x), (size_t)(y)) + {2, 29, 2, 66} -- READ_STRING_OK(x, y) (char *)read_string((x), (size_t)(y)) }, get_ranges()) end) it("should list all directives", function() diff --git a/test/functional/ui/bufhl_spec.lua b/test/functional/ui/bufhl_spec.lua index adec0770de..5263fb4c24 100644 --- a/test/functional/ui/bufhl_spec.lua +++ b/test/functional/ui/bufhl_spec.lua @@ -766,6 +766,7 @@ describe('Buffer highlighting', function() -- an existing virtual text. We might add a prioritation system. set_virtual_text(id1, 0, s1, {}) eq({{1, 0, 0, { + ns_id = 1, priority = 0, virt_text = s1, -- other details @@ -778,6 +779,7 @@ describe('Buffer highlighting', function() local lastline = line_count() set_virtual_text(id1, line_count(), s2, {}) eq({{3, lastline, 0, { + ns_id = 1, priority = 0, virt_text = s2, -- other details diff --git a/test/old/testdir/test_packadd.vim b/test/old/testdir/test_packadd.vim index 3121b3b4d1..64c8fd8659 100644 --- a/test/old/testdir/test_packadd.vim +++ b/test/old/testdir/test_packadd.vim @@ -20,6 +20,13 @@ func Test_packadd() call mkdir(s:plugdir . '/plugin/also', 'p') call mkdir(s:plugdir . '/ftdetect', 'p') call mkdir(s:plugdir . '/after', 'p') + + " This used to crash Vim + let &rtp = 'nosuchdir,' . s:plugdir . '/after' + packadd mytest + " plugdir should be inserted before plugdir/after + call assert_match('^nosuchdir,' . s:plugdir . ',', &rtp) + set rtp& let rtp = &rtp filetype on diff --git a/test/symbolic/klee/nvim/charset.c b/test/symbolic/klee/nvim/charset.c deleted file mode 100644 index fd1c5ee4b9..0000000000 --- a/test/symbolic/klee/nvim/charset.c +++ /dev/null @@ -1,172 +0,0 @@ -#include <stdbool.h> - -#include "nvim/ascii.h" -#include "nvim/macros.h" -#include "nvim/charset.h" -#include "nvim/eval/typval.h" -#include "nvim/vim.h" - -int hex2nr(int c) -{ - if ((c >= 'a') && (c <= 'f')) { - return c - 'a' + 10; - } - - if ((c >= 'A') && (c <= 'F')) { - return c - 'A' + 10; - } - return c - '0'; -} - -void vim_str2nr(const char_u *const start, int *const prep, int *const len, - const int what, varnumber_T *const nptr, - uvarnumber_T *const unptr, const int maxlen) -{ - const char *ptr = (const char *)start; -#define STRING_ENDED(ptr) \ - (!(maxlen == 0 || (int)((ptr) - (const char *)start) < maxlen)) - int pre = 0; // default is decimal - const bool negative = (ptr[0] == '-'); - uvarnumber_T un = 0; - - if (negative) { - ptr++; - } - - if (what & STR2NR_FORCE) { - // When forcing main consideration is skipping the prefix. Octal and decimal - // numbers have no prefixes to skip. pre is not set. - switch ((unsigned)what & (~(unsigned)STR2NR_FORCE)) { - case STR2NR_HEX: { - if (!STRING_ENDED(ptr + 2) - && ptr[0] == '0' - && (ptr[1] == 'x' || ptr[1] == 'X') - && ascii_isxdigit(ptr[2])) { - ptr += 2; - } - goto vim_str2nr_hex; - } - case STR2NR_BIN: { - if (!STRING_ENDED(ptr + 2) - && ptr[0] == '0' - && (ptr[1] == 'b' || ptr[1] == 'B') - && ascii_isbdigit(ptr[2])) { - ptr += 2; - } - goto vim_str2nr_bin; - } - case STR2NR_OCT: { - goto vim_str2nr_oct; - } - case 0: { - goto vim_str2nr_dec; - } - default: { - abort(); - } - } - } else if ((what & (STR2NR_HEX|STR2NR_OCT|STR2NR_BIN)) - && !STRING_ENDED(ptr + 1) - && ptr[0] == '0' && ptr[1] != '8' && ptr[1] != '9') { - pre = ptr[1]; - // Detect hexadecimal: 0x or 0X followed by hex digit - if ((what & STR2NR_HEX) - && !STRING_ENDED(ptr + 2) - && (pre == 'X' || pre == 'x') - && ascii_isxdigit(ptr[2])) { - ptr += 2; - goto vim_str2nr_hex; - } - // Detect binary: 0b or 0B followed by 0 or 1 - if ((what & STR2NR_BIN) - && !STRING_ENDED(ptr + 2) - && (pre == 'B' || pre == 'b') - && ascii_isbdigit(ptr[2])) { - ptr += 2; - goto vim_str2nr_bin; - } - // Detect octal number: zero followed by octal digits without '8' or '9' - pre = 0; - if (!(what & STR2NR_OCT)) { - goto vim_str2nr_dec; - } - for (int i = 2; !STRING_ENDED(ptr + i) && ascii_isdigit(ptr[i]); i++) { - if (ptr[i] > '7') { - goto vim_str2nr_dec; - } - } - pre = '0'; - goto vim_str2nr_oct; - } else { - goto vim_str2nr_dec; - } - - // Do the string-to-numeric conversion "manually" to avoid sscanf quirks. - abort(); // Should’ve used goto earlier. -#define PARSE_NUMBER(base, cond, conv) \ - do { \ - while (!STRING_ENDED(ptr) && (cond)) { \ - /* avoid ubsan error for overflow */ \ - if (un < UVARNUMBER_MAX / base) { \ - un = base * un + (uvarnumber_T)(conv); \ - } else { \ - un = UVARNUMBER_MAX; \ - } \ - ptr++; \ - } \ - } while (0) - switch (pre) { - case 'b': - case 'B': { -vim_str2nr_bin: - PARSE_NUMBER(2, (*ptr == '0' || *ptr == '1'), (*ptr - '0')); - break; - } - case '0': { -vim_str2nr_oct: - PARSE_NUMBER(8, ('0' <= *ptr && *ptr <= '7'), (*ptr - '0')); - break; - } - case 0: { -vim_str2nr_dec: - PARSE_NUMBER(10, (ascii_isdigit(*ptr)), (*ptr - '0')); - break; - } - case 'x': - case 'X': { -vim_str2nr_hex: - PARSE_NUMBER(16, (ascii_isxdigit(*ptr)), (hex2nr(*ptr))); - break; - } - } -#undef PARSE_NUMBER - - if (prep != NULL) { - *prep = pre; - } - - if (len != NULL) { - *len = (int)(ptr - (const char *)start); - } - - if (nptr != NULL) { - if (negative) { // account for leading '-' for decimal numbers - // avoid ubsan error for overflow - if (un > VARNUMBER_MAX) { - *nptr = VARNUMBER_MIN; - } else { - *nptr = -(varnumber_T)un; - } - } else { - if (un > VARNUMBER_MAX) { - un = VARNUMBER_MAX; - } - *nptr = (varnumber_T)un; - } - } - - if (unptr != NULL) { - *unptr = un; - } -#undef STRING_ENDED -} diff --git a/test/symbolic/klee/nvim/garray.c b/test/symbolic/klee/nvim/garray.c deleted file mode 100644 index 260870c3c2..0000000000 --- a/test/symbolic/klee/nvim/garray.c +++ /dev/null @@ -1,195 +0,0 @@ -// 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 - -/// @file garray.c -/// -/// Functions for handling growing arrays. - -#include <string.h> -#include <inttypes.h> - -#include "nvim/vim.h" -#include "nvim/ascii.h" -#include "nvim/log.h" -#include "nvim/memory.h" -#include "nvim/path.h" -#include "nvim/garray.h" -#include "nvim/strings.h" - -// #include "nvim/globals.h" -#include "nvim/memline.h" - -#ifdef INCLUDE_GENERATED_DECLARATIONS -# include "garray.c.generated.h" -#endif - -/// Clear an allocated growing array. -void ga_clear(garray_T *gap) -{ - xfree(gap->ga_data); - - // Initialize growing array without resetting itemsize or growsize - gap->ga_data = NULL; - gap->ga_maxlen = 0; - gap->ga_len = 0; -} - -/// Clear a growing array that contains a list of strings. -/// -/// @param gap -void ga_clear_strings(garray_T *gap) -{ - GA_DEEP_CLEAR_PTR(gap); -} - -/// Initialize a growing array. -/// -/// @param gap -/// @param itemsize -/// @param growsize -void ga_init(garray_T *gap, int itemsize, int growsize) -{ - gap->ga_data = NULL; - gap->ga_maxlen = 0; - gap->ga_len = 0; - gap->ga_itemsize = itemsize; - ga_set_growsize(gap, growsize); -} - -/// A setter for the growsize that guarantees it will be at least 1. -/// -/// @param gap -/// @param growsize -void ga_set_growsize(garray_T *gap, int growsize) -{ - if (growsize < 1) { - WLOG("trying to set an invalid ga_growsize: %d", growsize); - gap->ga_growsize = 1; - } else { - gap->ga_growsize = growsize; - } -} - -/// Make room in growing array "gap" for at least "n" items. -/// -/// @param gap -/// @param n -void ga_grow(garray_T *gap, int n) -{ - if (gap->ga_maxlen - gap->ga_len >= n) { - // the garray still has enough space, do nothing - return; - } - - if (gap->ga_growsize < 1) { - WLOG("ga_growsize(%d) is less than 1", gap->ga_growsize); - } - - // the garray grows by at least growsize - if (n < gap->ga_growsize) { - n = gap->ga_growsize; - } - int new_maxlen = gap->ga_len + n; - - size_t new_size = (size_t)(gap->ga_itemsize * new_maxlen); - size_t old_size = (size_t)(gap->ga_itemsize * gap->ga_maxlen); - - // reallocate and clear the new memory - char *pp = xrealloc(gap->ga_data, new_size); - memset(pp + old_size, 0, new_size - old_size); - - gap->ga_maxlen = new_maxlen; - gap->ga_data = pp; -} - -/// For a growing array that contains a list of strings: concatenate all the -/// strings with sep as separator. -/// -/// @param gap -/// @param sep -/// -/// @returns the concatenated strings -char_u *ga_concat_strings_sep(const garray_T *gap, const char *sep) - FUNC_ATTR_NONNULL_RET -{ - const size_t nelem = (size_t) gap->ga_len; - const char **strings = gap->ga_data; - - if (nelem == 0) { - return (char_u *) xstrdup(""); - } - - size_t len = 0; - for (size_t i = 0; i < nelem; i++) { - len += strlen(strings[i]); - } - - // add some space for the (num - 1) separators - len += (nelem - 1) * strlen(sep); - char *const ret = xmallocz(len); - - char *s = ret; - for (size_t i = 0; i < nelem - 1; i++) { - s = xstpcpy(s, strings[i]); - s = xstpcpy(s, sep); - } - strcpy(s, strings[nelem - 1]); - - return (char_u *) ret; -} - -/// For a growing array that contains a list of strings: concatenate all the -/// strings with a separating comma. -/// -/// @param gap -/// -/// @returns the concatenated strings -char_u* ga_concat_strings(const garray_T *gap) FUNC_ATTR_NONNULL_RET -{ - return ga_concat_strings_sep(gap, ","); -} - -/// Concatenate a string to a growarray which contains characters. -/// When "s" is NULL does not do anything. -/// -/// WARNING: -/// - Does NOT copy the NUL at the end! -/// - The parameter may not overlap with the growing array -/// -/// @param gap -/// @param s -void ga_concat(garray_T *gap, const char_u *restrict s) -{ - if (s == NULL) { - return; - } - - ga_concat_len(gap, (const char *restrict) s, strlen((char *) s)); -} - -/// Concatenate a string to a growarray which contains characters -/// -/// @param[out] gap Growarray to modify. -/// @param[in] s String to concatenate. -/// @param[in] len String length. -void ga_concat_len(garray_T *const gap, const char *restrict s, - const size_t len) - FUNC_ATTR_NONNULL_ALL -{ - if (len) { - ga_grow(gap, (int) len); - char *data = gap->ga_data; - memcpy(data + gap->ga_len, s, len); - gap->ga_len += (int) len; - } -} - -/// Append one byte to a growarray which contains bytes. -/// -/// @param gap -/// @param c -void ga_append(garray_T *gap, char c) -{ - GA_APPEND(char, gap, c); -} - diff --git a/test/symbolic/klee/nvim/gettext.c b/test/symbolic/klee/nvim/gettext.c deleted file mode 100644 index b9cc98d770..0000000000 --- a/test/symbolic/klee/nvim/gettext.c +++ /dev/null @@ -1,4 +0,0 @@ -char *gettext(const char *s) -{ - return (char *)s; -} diff --git a/test/symbolic/klee/nvim/keymap.c b/test/symbolic/klee/nvim/keymap.c deleted file mode 100644 index 1f7f0e0911..0000000000 --- a/test/symbolic/klee/nvim/keymap.c +++ /dev/null @@ -1,559 +0,0 @@ -#include <stdbool.h> - -#include "nvim/types.h" -#include "nvim/keycodes.h" -#include "nvim/ascii.h" -#include "nvim/eval/typval.h" - -#define MOD_KEYS_ENTRY_SIZE 5 - -static char_u modifier_keys_table[] = -{ - MOD_MASK_SHIFT, '&', '9', '@', '1', - MOD_MASK_SHIFT, '&', '0', '@', '2', - MOD_MASK_SHIFT, '*', '1', '@', '4', - MOD_MASK_SHIFT, '*', '2', '@', '5', - MOD_MASK_SHIFT, '*', '3', '@', '6', - MOD_MASK_SHIFT, '*', '4', 'k', 'D', - MOD_MASK_SHIFT, '*', '5', 'k', 'L', - MOD_MASK_SHIFT, '*', '7', '@', '7', - MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', - MOD_MASK_SHIFT, '*', '9', '@', '9', - MOD_MASK_SHIFT, '*', '0', '@', '0', - MOD_MASK_SHIFT, '#', '1', '%', '1', - MOD_MASK_SHIFT, '#', '2', 'k', 'h', - MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', - MOD_MASK_SHIFT, '#', '3', 'k', 'I', - MOD_MASK_SHIFT, '#', '4', 'k', 'l', - MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', - MOD_MASK_SHIFT, '%', 'a', '%', '3', - MOD_MASK_SHIFT, '%', 'b', '%', '4', - MOD_MASK_SHIFT, '%', 'c', '%', '5', - MOD_MASK_SHIFT, '%', 'd', '%', '7', - MOD_MASK_SHIFT, '%', 'e', '%', '8', - MOD_MASK_SHIFT, '%', 'f', '%', '9', - MOD_MASK_SHIFT, '%', 'g', '%', '0', - MOD_MASK_SHIFT, '%', 'h', '&', '3', - MOD_MASK_SHIFT, '%', 'i', 'k', 'r', - MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', - MOD_MASK_SHIFT, '%', 'j', '&', '5', - MOD_MASK_SHIFT, '!', '1', '&', '6', - MOD_MASK_SHIFT, '!', '2', '&', '7', - MOD_MASK_SHIFT, '!', '3', '&', '8', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', - - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1, KS_EXTRA, (int)KE_XF1, - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2, KS_EXTRA, (int)KE_XF2, - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3, KS_EXTRA, (int)KE_XF3, - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4, KS_EXTRA, (int)KE_XF4, - - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1, 'k', '1', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2, 'k', '2', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3, 'k', '3', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4, 'k', '4', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5, 'k', '5', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6, 'k', '6', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7, 'k', '7', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8, 'k', '8', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9, 'k', '9', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10, 'k', ';', - - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11, 'F', '1', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12, 'F', '2', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13, 'F', '3', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14, 'F', '4', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15, 'F', '5', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16, 'F', '6', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17, 'F', '7', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18, 'F', '8', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19, 'F', '9', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20, 'F', 'A', - - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21, 'F', 'B', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22, 'F', 'C', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23, 'F', 'D', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24, 'F', 'E', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25, 'F', 'F', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26, 'F', 'G', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27, 'F', 'H', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28, 'F', 'I', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29, 'F', 'J', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30, 'F', 'K', - - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31, 'F', 'L', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32, 'F', 'M', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33, 'F', 'N', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34, 'F', 'O', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35, 'F', 'P', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36, 'F', 'Q', - MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37, 'F', 'R', - - MOD_MASK_SHIFT, 'k', 'B', KS_EXTRA, (int)KE_TAB, - - NUL -}; - -int simplify_key(const int key, int *modifiers) -{ - if (*modifiers & (MOD_MASK_SHIFT | MOD_MASK_CTRL | MOD_MASK_ALT)) { - // TAB is a special case. - if (key == TAB && (*modifiers & MOD_MASK_SHIFT)) { - *modifiers &= ~MOD_MASK_SHIFT; - return K_S_TAB; - } - const int key0 = KEY2TERMCAP0(key); - const int key1 = KEY2TERMCAP1(key); - for (int i = 0; modifier_keys_table[i] != NUL; i += MOD_KEYS_ENTRY_SIZE) { - if (key0 == modifier_keys_table[i + 3] - && key1 == modifier_keys_table[i + 4] - && (*modifiers & modifier_keys_table[i])) { - *modifiers &= ~modifier_keys_table[i]; - return TERMCAP2KEY(modifier_keys_table[i + 1], - modifier_keys_table[i + 2]); - } - } - } - return key; -} - -int handle_x_keys(const int key) - FUNC_ATTR_CONST FUNC_ATTR_WARN_UNUSED_RESULT -{ - switch (key) { - case K_XUP: return K_UP; - case K_XDOWN: return K_DOWN; - case K_XLEFT: return K_LEFT; - case K_XRIGHT: return K_RIGHT; - case K_XHOME: return K_HOME; - case K_ZHOME: return K_HOME; - case K_XEND: return K_END; - case K_ZEND: return K_END; - case K_XF1: return K_F1; - case K_XF2: return K_F2; - case K_XF3: return K_F3; - case K_XF4: return K_F4; - case K_S_XF1: return K_S_F1; - case K_S_XF2: return K_S_F2; - case K_S_XF3: return K_S_F3; - case K_S_XF4: return K_S_F4; - } - return key; -} - -static const struct key_name_entry { - int key; // Special key code or ascii value - const char *name; // Name of key -} key_names_table[] = { - { ' ', "Space" }, - { TAB, "Tab" }, - { K_TAB, "Tab" }, - { NL, "NL" }, - { NL, "NewLine" }, // Alternative name - { NL, "LineFeed" }, // Alternative name - { NL, "LF" }, // Alternative name - { CAR, "CR" }, - { CAR, "Return" }, // Alternative name - { CAR, "Enter" }, // Alternative name - { K_BS, "BS" }, - { K_BS, "BackSpace" }, // Alternative name - { ESC, "Esc" }, - { CSI, "CSI" }, - { K_CSI, "xCSI" }, - { '|', "Bar" }, - { '\\', "Bslash" }, - { K_DEL, "Del" }, - { K_DEL, "Delete" }, // Alternative name - { K_KDEL, "kDel" }, - { K_KDEL, "KPPeriod" }, // termkey KPPeriod value - { K_UP, "Up" }, - { K_DOWN, "Down" }, - { K_LEFT, "Left" }, - { K_RIGHT, "Right" }, - { K_XUP, "xUp" }, - { K_XDOWN, "xDown" }, - { K_XLEFT, "xLeft" }, - { K_XRIGHT, "xRight" }, - { K_KUP, "kUp" }, - { K_KUP, "KP8" }, - { K_KDOWN, "kDown" }, - { K_KDOWN, "KP2" }, - { K_KLEFT, "kLeft" }, - { K_KLEFT, "KP4" }, - { K_KRIGHT, "kRight" }, - { K_KRIGHT, "KP6" }, - - { K_F1, "F1" }, - { K_F2, "F2" }, - { K_F3, "F3" }, - { K_F4, "F4" }, - { K_F5, "F5" }, - { K_F6, "F6" }, - { K_F7, "F7" }, - { K_F8, "F8" }, - { K_F9, "F9" }, - { K_F10, "F10" }, - - { K_F11, "F11" }, - { K_F12, "F12" }, - { K_F13, "F13" }, - { K_F14, "F14" }, - { K_F15, "F15" }, - { K_F16, "F16" }, - { K_F17, "F17" }, - { K_F18, "F18" }, - { K_F19, "F19" }, - { K_F20, "F20" }, - - { K_F21, "F21" }, - { K_F22, "F22" }, - { K_F23, "F23" }, - { K_F24, "F24" }, - { K_F25, "F25" }, - { K_F26, "F26" }, - { K_F27, "F27" }, - { K_F28, "F28" }, - { K_F29, "F29" }, - { K_F30, "F30" }, - - { K_F31, "F31" }, - { K_F32, "F32" }, - { K_F33, "F33" }, - { K_F34, "F34" }, - { K_F35, "F35" }, - { K_F36, "F36" }, - { K_F37, "F37" }, - - { K_XF1, "xF1" }, - { K_XF2, "xF2" }, - { K_XF3, "xF3" }, - { K_XF4, "xF4" }, - - { K_HELP, "Help" }, - { K_UNDO, "Undo" }, - { K_INS, "Insert" }, - { K_INS, "Ins" }, // Alternative name - { K_KINS, "kInsert" }, - { K_KINS, "KP0" }, - { K_HOME, "Home" }, - { K_KHOME, "kHome" }, - { K_KHOME, "KP7" }, - { K_XHOME, "xHome" }, - { K_ZHOME, "zHome" }, - { K_END, "End" }, - { K_KEND, "kEnd" }, - { K_XEND, "xEnd" }, - { K_ZEND, "zEnd" }, - { K_PAGEUP, "PageUp" }, - { K_PAGEDOWN, "PageDown" }, - { K_KPAGEUP, "kPageUp" }, - { K_KPAGEUP, "KP9" }, - { K_KPAGEDOWN, "kPageDown" }, - { K_KPAGEDOWN, "KP3" }, - { K_KORIGIN, "kOrigin" }, - { K_KORIGIN, "KP5" }, - - { K_KPLUS, "kPlus" }, - { K_KPLUS, "KPPlus" }, - { K_KMINUS, "kMinus" }, - { K_KMINUS, "KPMinus" }, - { K_KDIVIDE, "kDivide" }, - { K_KDIVIDE, "KPDiv" }, - { K_KMULTIPLY, "kMultiply" }, - { K_KMULTIPLY, "KPMult" }, - { K_KENTER, "kEnter" }, - { K_KENTER, "KPEnter" }, - { K_KPOINT, "kPoint" }, - - { K_K0, "k0" }, - { K_K1, "k1" }, - { K_K2, "k2" }, - { K_K3, "k3" }, - { K_K4, "k4" }, - { K_K5, "k5" }, - { K_K6, "k6" }, - { K_K7, "k7" }, - { K_K8, "k8" }, - { K_K9, "k9" }, - - { '<', "lt" }, - - { K_MOUSE, "Mouse" }, - { K_LEFTMOUSE, "LeftMouse" }, - { K_LEFTMOUSE_NM, "LeftMouseNM" }, - { K_LEFTDRAG, "LeftDrag" }, - { K_LEFTRELEASE, "LeftRelease" }, - { K_LEFTRELEASE_NM, "LeftReleaseNM" }, - { K_MIDDLEMOUSE, "MiddleMouse" }, - { K_MIDDLEDRAG, "MiddleDrag" }, - { K_MIDDLERELEASE, "MiddleRelease" }, - { K_RIGHTMOUSE, "RightMouse" }, - { K_RIGHTDRAG, "RightDrag" }, - { K_RIGHTRELEASE, "RightRelease" }, - { K_MOUSEDOWN, "ScrollWheelUp" }, - { K_MOUSEUP, "ScrollWheelDown" }, - { K_MOUSELEFT, "ScrollWheelRight" }, - { K_MOUSERIGHT, "ScrollWheelLeft" }, - { K_MOUSEDOWN, "MouseDown" }, // OBSOLETE: Use - { K_MOUSEUP, "MouseUp" }, // ScrollWheelXXX instead - { K_X1MOUSE, "X1Mouse" }, - { K_X1DRAG, "X1Drag" }, - { K_X1RELEASE, "X1Release" }, - { K_X2MOUSE, "X2Mouse" }, - { K_X2DRAG, "X2Drag" }, - { K_X2RELEASE, "X2Release" }, - { K_DROP, "Drop" }, - { K_ZERO, "Nul" }, - { K_SNR, "SNR" }, - { K_PLUG, "Plug" }, - { K_PASTE, "Paste" }, - { 0, NULL } -}; - -int get_special_key_code(const char_u *name) -{ - for (int i = 0; key_names_table[i].name != NULL; i++) { - const char *const table_name = key_names_table[i].name; - int j; - for (j = 0; ascii_isident(name[j]) && table_name[j] != NUL; j++) { - if (TOLOWER_ASC(table_name[j]) != TOLOWER_ASC(name[j])) { - break; - } - } - if (!ascii_isident(name[j]) && table_name[j] == NUL) { - return key_names_table[i].key; - } - } - - return 0; -} - - -static const struct modmasktable { - short mod_mask; ///< Bit-mask for particular key modifier. - short mod_flag; ///< Bit(s) for particular key modifier. - char_u name; ///< Single letter name of modifier. -} mod_mask_table[] = { - {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'M'}, - {MOD_MASK_META, MOD_MASK_META, (char_u)'T'}, - {MOD_MASK_CTRL, MOD_MASK_CTRL, (char_u)'C'}, - {MOD_MASK_SHIFT, MOD_MASK_SHIFT, (char_u)'S'}, - {MOD_MASK_MULTI_CLICK, MOD_MASK_2CLICK, (char_u)'2'}, - {MOD_MASK_MULTI_CLICK, MOD_MASK_3CLICK, (char_u)'3'}, - {MOD_MASK_MULTI_CLICK, MOD_MASK_4CLICK, (char_u)'4'}, - {MOD_MASK_CMD, MOD_MASK_CMD, (char_u)'D'}, - // 'A' must be the last one - {MOD_MASK_ALT, MOD_MASK_ALT, (char_u)'A'}, - {0, 0, NUL} -}; - -int name_to_mod_mask(int c) -{ - c = TOUPPER_ASC(c); - for (size_t i = 0; mod_mask_table[i].mod_mask != 0; i++) { - if (c == mod_mask_table[i].name) { - return mod_mask_table[i].mod_flag; - } - } - return 0; -} - -static int extract_modifiers(int key, int *modp) -{ - int modifiers = *modp; - - if (!(modifiers & MOD_MASK_CMD)) { // Command-key is special - if ((modifiers & MOD_MASK_SHIFT) && ASCII_ISALPHA(key)) { - key = TOUPPER_ASC(key); - modifiers &= ~MOD_MASK_SHIFT; - } - } - if ((modifiers & MOD_MASK_CTRL) - && ((key >= '?' && key <= '_') || ASCII_ISALPHA(key))) { - key = Ctrl_chr(key); - modifiers &= ~MOD_MASK_CTRL; - if (key == 0) { // <C-@> is <Nul> - key = K_ZERO; - } - } - - *modp = modifiers; - return key; -} - -int find_special_key(const char_u **srcp, const size_t src_len, int *const modp, - const bool keycode, const bool keep_x_key, - const bool in_string) -{ - const char_u *last_dash; - const char_u *end_of_name; - const char_u *src; - const char_u *bp; - const char_u *const end = *srcp + src_len - 1; - int modifiers; - int bit; - int key; - uvarnumber_T n; - int l; - - if (src_len == 0) { - return 0; - } - - src = *srcp; - if (src[0] != '<') { - return 0; - } - - // Find end of modifier list - last_dash = src; - for (bp = src + 1; bp <= end && (*bp == '-' || ascii_isident(*bp)); bp++) { - if (*bp == '-') { - last_dash = bp; - if (bp + 1 <= end) { - l = utfc_ptr2len_len(bp + 1, (int)(end - bp) + 1); - // Anything accepted, like <C-?>. - // <C-"> or <M-"> are not special in strings as " is - // the string delimiter. With a backslash it works: <M-\"> - if (end - bp > l && !(in_string && bp[1] == '"') && bp[2] == '>') { - bp += l; - } else if (end - bp > 2 && in_string && bp[1] == '\\' - && bp[2] == '"' && bp[3] == '>') { - bp += 2; - } - } - } - if (end - bp > 3 && bp[0] == 't' && bp[1] == '_') { - bp += 3; // skip t_xx, xx may be '-' or '>' - } else if (end - bp > 4 && STRNICMP(bp, "char-", 5) == 0) { - vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0); - bp += l + 5; - break; - } - } - - if (bp <= end && *bp == '>') { // found matching '>' - end_of_name = bp + 1; - - /* Which modifiers are given? */ - modifiers = 0x0; - for (bp = src + 1; bp < last_dash; bp++) { - if (*bp != '-') { - bit = name_to_mod_mask(*bp); - if (bit == 0x0) { - break; // Illegal modifier name - } - modifiers |= bit; - } - } - - // Legal modifier name. - if (bp >= last_dash) { - if (STRNICMP(last_dash + 1, "char-", 5) == 0 - && ascii_isdigit(last_dash[6])) { - // <Char-123> or <Char-033> or <Char-0x33> - vim_str2nr(last_dash + 6, NULL, NULL, STR2NR_ALL, NULL, &n, 0); - key = (int)n; - } else { - int off = 1; - - // Modifier with single letter, or special key name. - if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') { - off = 2; - } - l = mb_ptr2len(last_dash + 1); - if (modifiers != 0 && last_dash[l + 1] == '>') { - key = PTR2CHAR(last_dash + off); - } else { - key = get_special_key_code(last_dash + off); - if (!keep_x_key) { - key = handle_x_keys(key); - } - } - } - - // get_special_key_code() may return NUL for invalid - // special key name. - if (key != NUL) { - // Only use a modifier when there is no special key code that - // includes the modifier. - key = simplify_key(key, &modifiers); - - if (!keycode) { - // don't want keycode, use single byte code - if (key == K_BS) { - key = BS; - } else if (key == K_DEL || key == K_KDEL) { - key = DEL; - } - } - - // Normal Key with modifier: - // Try to make a single byte code (except for Alt/Meta modifiers). - if (!IS_SPECIAL(key)) { - key = extract_modifiers(key, &modifiers); - } - - *modp = modifiers; - *srcp = end_of_name; - return key; - } - } - } - return 0; -} - -char_u *add_char2buf(int c, char_u *s) -{ - char_u temp[MB_MAXBYTES + 1]; - const int len = utf_char2bytes(c, temp); - for (int i = 0; i < len; ++i) { - c = temp[i]; - // Need to escape K_SPECIAL and CSI like in the typeahead buffer. - if (c == K_SPECIAL) { - *s++ = K_SPECIAL; - *s++ = KS_SPECIAL; - *s++ = KE_FILLER; - } else { - *s++ = c; - } - } - return s; -} - -unsigned int trans_special(const char_u **srcp, const size_t src_len, - char_u *const dst, const bool keycode, - const bool in_string) -{ - int modifiers = 0; - int key; - unsigned int dlen = 0; - - key = find_special_key(srcp, src_len, &modifiers, keycode, false, in_string); - if (key == 0) { - return 0; - } - - // Put the appropriate modifier in a string. - if (modifiers != 0) { - dst[dlen++] = K_SPECIAL; - dst[dlen++] = KS_MODIFIER; - dst[dlen++] = (char_u)modifiers; - } - - if (IS_SPECIAL(key)) { - dst[dlen++] = K_SPECIAL; - dst[dlen++] = (char_u)KEY2TERMCAP0(key); - dst[dlen++] = KEY2TERMCAP1(key); - } else if (!keycode) { - dlen += (unsigned int)(*mb_char2bytes)(key, dst + dlen); - } else if (keycode) { - char_u *after = add_char2buf(key, dst + dlen); - assert(after >= dst && (uintmax_t)(after - dst) <= UINT_MAX); - dlen = (unsigned int)(after - dst); - } else { - dst[dlen++] = (char_u)key; - } - - return dlen; -} diff --git a/test/symbolic/klee/nvim/mbyte.c b/test/symbolic/klee/nvim/mbyte.c deleted file mode 100644 index f98a531206..0000000000 --- a/test/symbolic/klee/nvim/mbyte.c +++ /dev/null @@ -1,266 +0,0 @@ -#include <stddef.h> -#include <inttypes.h> -#include <assert.h> -#include <stdbool.h> - -#include "nvim/types.h" -#include "nvim/mbyte.h" -#include "nvim/ascii.h" - -const uint8_t utf8len_tab_zero[] = { - //1 2 3 4 5 6 7 8 9 A B C D E F 0 1 2 3 4 5 6 7 8 9 A B C D E F - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 2 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 4 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 6 - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 8 - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // A - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // C - 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,0,0, // E -}; - -const uint8_t utf8len_tab[] = { - // ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9 ?A ?B ?C ?D ?E ?F - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A? - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B? - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C? - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // D? - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // E? - 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1, // F? -}; - -int utf_ptr2char(const char_u *const p) -{ - if (p[0] < 0x80) { // Be quick for ASCII. - return p[0]; - } - - const uint8_t len = utf8len_tab_zero[p[0]]; - if (len > 1 && (p[1] & 0xc0) == 0x80) { - if (len == 2) { - return ((p[0] & 0x1f) << 6) + (p[1] & 0x3f); - } - if ((p[2] & 0xc0) == 0x80) { - if (len == 3) { - return (((p[0] & 0x0f) << 12) + ((p[1] & 0x3f) << 6) - + (p[2] & 0x3f)); - } - if ((p[3] & 0xc0) == 0x80) { - if (len == 4) { - return (((p[0] & 0x07) << 18) + ((p[1] & 0x3f) << 12) - + ((p[2] & 0x3f) << 6) + (p[3] & 0x3f)); - } - if ((p[4] & 0xc0) == 0x80) { - if (len == 5) { - return (((p[0] & 0x03) << 24) + ((p[1] & 0x3f) << 18) - + ((p[2] & 0x3f) << 12) + ((p[3] & 0x3f) << 6) - + (p[4] & 0x3f)); - } - if ((p[5] & 0xc0) == 0x80 && len == 6) { - return (((p[0] & 0x01) << 30) + ((p[1] & 0x3f) << 24) - + ((p[2] & 0x3f) << 18) + ((p[3] & 0x3f) << 12) - + ((p[4] & 0x3f) << 6) + (p[5] & 0x3f)); - } - } - } - } - } - // Illegal value: just return the first byte. - return p[0]; -} - -bool utf_composinglike(const char_u *p1, const char_u *p2) -{ - return false; -} - -char_u *string_convert(const vimconv_T *conv, char_u *data, size_t *size) -{ - return NULL; -} - -int utf_ptr2len_len(const char_u *p, int size) -{ - int len; - int i; - int m; - - len = utf8len_tab[*p]; - if (len == 1) - return 1; /* NUL, ascii or illegal lead byte */ - if (len > size) - m = size; /* incomplete byte sequence. */ - else - m = len; - for (i = 1; i < m; ++i) - if ((p[i] & 0xc0) != 0x80) - return 1; - return len; -} - -int utfc_ptr2len_len(const char_u *p, int size) -{ - int len; - int prevlen; - - if (size < 1 || *p == NUL) - return 0; - if (p[0] < 0x80 && (size == 1 || p[1] < 0x80)) /* be quick for ASCII */ - return 1; - - /* Skip over first UTF-8 char, stopping at a NUL byte. */ - len = utf_ptr2len_len(p, size); - - /* Check for illegal byte and incomplete byte sequence. */ - if ((len == 1 && p[0] >= 0x80) || len > size) - return 1; - - /* - * Check for composing characters. We can handle only the first six, but - * skip all of them (otherwise the cursor would get stuck). - */ - prevlen = 0; - while (len < size) { - int len_next_char; - - if (p[len] < 0x80) - break; - - /* - * Next character length should not go beyond size to ensure that - * UTF_COMPOSINGLIKE(...) does not read beyond size. - */ - len_next_char = utf_ptr2len_len(p + len, size - len); - if (len_next_char > size - len) - break; - - if (!UTF_COMPOSINGLIKE(p + prevlen, p + len)) - break; - - /* Skip over composing char */ - prevlen = len; - len += len_next_char; - } - return len; -} - -int utf_char2len(const int c) -{ - if (c < 0x80) { - return 1; - } else if (c < 0x800) { - return 2; - } else if (c < 0x10000) { - return 3; - } else if (c < 0x200000) { - return 4; - } else if (c < 0x4000000) { - return 5; - } else { - return 6; - } -} - -int utf_char2bytes(const int c, char_u *const buf) -{ - if (c < 0x80) { // 7 bits - buf[0] = c; - return 1; - } else if (c < 0x800) { // 11 bits - buf[0] = 0xc0 + ((unsigned)c >> 6); - buf[1] = 0x80 + (c & 0x3f); - return 2; - } else if (c < 0x10000) { // 16 bits - buf[0] = 0xe0 + ((unsigned)c >> 12); - buf[1] = 0x80 + (((unsigned)c >> 6) & 0x3f); - buf[2] = 0x80 + (c & 0x3f); - return 3; - } else if (c < 0x200000) { // 21 bits - buf[0] = 0xf0 + ((unsigned)c >> 18); - buf[1] = 0x80 + (((unsigned)c >> 12) & 0x3f); - buf[2] = 0x80 + (((unsigned)c >> 6) & 0x3f); - buf[3] = 0x80 + (c & 0x3f); - return 4; - } else if (c < 0x4000000) { // 26 bits - buf[0] = 0xf8 + ((unsigned)c >> 24); - buf[1] = 0x80 + (((unsigned)c >> 18) & 0x3f); - buf[2] = 0x80 + (((unsigned)c >> 12) & 0x3f); - buf[3] = 0x80 + (((unsigned)c >> 6) & 0x3f); - buf[4] = 0x80 + (c & 0x3f); - return 5; - } else { // 31 bits - buf[0] = 0xfc + ((unsigned)c >> 30); - buf[1] = 0x80 + (((unsigned)c >> 24) & 0x3f); - buf[2] = 0x80 + (((unsigned)c >> 18) & 0x3f); - buf[3] = 0x80 + (((unsigned)c >> 12) & 0x3f); - buf[4] = 0x80 + (((unsigned)c >> 6) & 0x3f); - buf[5] = 0x80 + (c & 0x3f); - return 6; - } -} - -int utf_ptr2len(const char_u *const p) -{ - if (*p == NUL) { - return 0; - } - const int len = utf8len_tab[*p]; - for (int i = 1; i < len; i++) { - if ((p[i] & 0xc0) != 0x80) { - return 1; - } - } - return len; -} - -int utfc_ptr2len(const char_u *const p) -{ - uint8_t b0 = (uint8_t)(*p); - - if (b0 == NUL) { - return 0; - } - if (b0 < 0x80 && p[1] < 0x80) { // be quick for ASCII - return 1; - } - - // Skip over first UTF-8 char, stopping at a NUL byte. - int len = utf_ptr2len(p); - - // Check for illegal byte. - if (len == 1 && b0 >= 0x80) { - return 1; - } - - // Check for composing characters. We can handle only the first six, but - // skip all of them (otherwise the cursor would get stuck). - int prevlen = 0; - for (;;) { - if (p[len] < 0x80 || !UTF_COMPOSINGLIKE(p + prevlen, p + len)) { - return len; - } - - // Skip over composing char. - prevlen = len; - len += utf_ptr2len(p + len); - } -} - -void mb_copy_char(const char_u **fp, char_u **tp) -{ - const size_t l = utfc_ptr2len(*fp); - - memmove(*tp, *fp, (size_t)l); - *tp += l; - *fp += l; -} diff --git a/test/symbolic/klee/nvim/memory.c b/test/symbolic/klee/nvim/memory.c deleted file mode 100644 index 1614f813d7..0000000000 --- a/test/symbolic/klee/nvim/memory.c +++ /dev/null @@ -1,101 +0,0 @@ -#include <stdlib.h> -#include <assert.h> - -#include "nvim/lib/ringbuf.h" - -enum { RB_SIZE = 1024 }; - -typedef struct { - void *ptr; - size_t size; -} AllocRecord; - -RINGBUF_TYPEDEF(AllocRecords, AllocRecord) -RINGBUF_INIT(AllocRecords, arecs, AllocRecord, RINGBUF_DUMMY_FREE) -RINGBUF_STATIC(static, AllocRecords, AllocRecord, arecs, RB_SIZE) - -size_t allocated_memory = 0; -size_t ever_allocated_memory = 0; - -size_t allocated_memory_limit = SIZE_MAX; - -void *xmalloc(const size_t size) -{ - void *ret = malloc(size); - allocated_memory += size; - ever_allocated_memory += size; - assert(allocated_memory <= allocated_memory_limit); - assert(arecs_rb_length(&arecs) < RB_SIZE); - arecs_rb_push(&arecs, (AllocRecord) { - .ptr = ret, - .size = size, - }); - return ret; -} - -void xfree(void *const p) -{ - if (p == NULL) { - return; - } - RINGBUF_FORALL(&arecs, AllocRecord, arec) { - if (arec->ptr == p) { - allocated_memory -= arec->size; - arecs_rb_remove(&arecs, arecs_rb_find_idx(&arecs, arec)); - return; - } - } - abort(); -} - -void *xrealloc(void *const p, size_t new_size) -{ - void *ret = realloc(p, new_size); - RINGBUF_FORALL(&arecs, AllocRecord, arec) { - if (arec->ptr == p) { - allocated_memory -= arec->size; - allocated_memory += new_size; - if (new_size > arec->size) { - ever_allocated_memory += (new_size - arec->size); - } - arec->ptr = ret; - arec->size = new_size; - return ret; - } - } - abort(); - return (void *)(intptr_t)1; -} - -char *xstrdup(const char *str) - FUNC_ATTR_MALLOC FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_RET - FUNC_ATTR_NONNULL_ALL -{ - return xmemdupz(str, strlen(str)); -} - -void *xmallocz(size_t size) - FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT -{ - size_t total_size = size + 1; - assert(total_size > size); - - void *ret = xmalloc(total_size); - ((char *)ret)[size] = 0; - - return ret; -} - -char *xstpcpy(char *restrict dst, const char *restrict src) - FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL -{ - const size_t len = strlen(src); - return (char *)memcpy(dst, src, len + 1) + len; -} - -void *xmemdupz(const void *data, size_t len) - FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_RET FUNC_ATTR_WARN_UNUSED_RESULT - FUNC_ATTR_NONNULL_ALL -{ - return memcpy(xmallocz(len), data, len); -} diff --git a/test/symbolic/klee/run.sh b/test/symbolic/klee/run.sh deleted file mode 100755 index d022fccb02..0000000000 --- a/test/symbolic/klee/run.sh +++ /dev/null @@ -1,101 +0,0 @@ -#!/bin/sh - -set -e -set -x -test -z "$POSH_VERSION" && set -u - -PROJECT_SOURCE_DIR=. -PROJECT_BINARY_DIR="$PROJECT_SOURCE_DIR/build" -KLEE_TEST_DIR="$PROJECT_SOURCE_DIR/test/symbolic/klee" -KLEE_BIN_DIR="$PROJECT_BINARY_DIR/klee" -KLEE_OUT_DIR="$KLEE_BIN_DIR/out" - -help() { - echo "Usage:" - echo - echo " $0 -c fname" - echo " $0 fname" - echo " $0 -s" - echo - echo "First form compiles executable out of test/symbolic/klee/{fname}.c." - echo "Compiled executable is placed into build/klee/{fname}. Must first" - echo "successfully compile Neovim in order to generate declarations." - echo - echo "Second form runs KLEE in a docker container using file " - echo "test/symbolic/klee/{fname.c}. Bitcode is placed into build/klee/a.bc," - echo "results are placed into build/klee/out/. The latter is first deleted if" - echo "it exists." - echo - echo "Third form runs ktest-tool which prints errors found by KLEE via " - echo "the same container used to run KLEE." -} - -main() { - local compile= - local print_errs= - if test "$1" = "--help" ; then - help - return - fi - if test "$1" = "-s" ; then - print_errs=1 - shift - elif test "$1" = "-c" ; then - compile=1 - shift - fi - if test -z "$print_errs" ; then - local test="$1" ; shift - fi - - local includes= - includes="$includes -I$KLEE_TEST_DIR" - includes="$includes -I/home/klee/klee_src/include" - includes="$includes -I$PROJECT_SOURCE_DIR/src" - includes="$includes -I$PROJECT_BINARY_DIR/src/nvim/auto" - includes="$includes -I$PROJECT_BINARY_DIR/include" - includes="$includes -I$PROJECT_BINARY_DIR/cmake.config" - includes="$includes -I/host-includes" - - local defines= - defines="$defines -DINCLUDE_GENERATED_DECLARATIONS" - - test -z "$compile" && defines="$defines -DUSE_KLEE" - - test -d "$KLEE_BIN_DIR" || mkdir -p "$KLEE_BIN_DIR" - - if test -z "$compile" ; then - local line1='cd /image' - if test -z "$print_errs" ; then - test -d "$KLEE_OUT_DIR" && rm -r "$KLEE_OUT_DIR" - - line1="$line1 && $(echo clang \ - $includes $defines \ - -o "$KLEE_BIN_DIR/a.bc" -emit-llvm -g -c \ - "$KLEE_TEST_DIR/$test.c")" - line1="$line1 && klee --libc=uclibc --posix-runtime " - line1="$line1 '--output-dir=$KLEE_OUT_DIR' '$KLEE_BIN_DIR/a.bc'" - fi - local line2="for t in '$KLEE_OUT_DIR'/*.err" - line2="$line2 ; do ktest-tool --write-ints" - line2="$line2 \"\$(printf '%s' \"\$t\" | sed -e 's@\\.[^/]*\$@.ktest@')\"" - line2="$line2 ; done" - printf '%s\n%s\n' "$line1" "$line2" | \ - docker run \ - --volume "$(cd "$PROJECT_SOURCE_DIR" && pwd)":/image \ - --volume "/usr/include":/host-includes \ - --interactive \ - --rm \ - --ulimit='stack=-1:-1' \ - klee/klee \ - /bin/sh -x - else - clang \ - $includes $defines \ - -o "$KLEE_BIN_DIR/$test" \ - -O0 -g \ - "$KLEE_TEST_DIR/$test.c" - fi -} - -main "$@" diff --git a/test/symbolic/klee/viml_expressions_lexer.c b/test/symbolic/klee/viml_expressions_lexer.c deleted file mode 100644 index 03c9d66ca4..0000000000 --- a/test/symbolic/klee/viml_expressions_lexer.c +++ /dev/null @@ -1,105 +0,0 @@ -#ifdef USE_KLEE -# include <klee/klee.h> -#else -# include <string.h> -# include <stdio.h> -#endif -#include <stddef.h> -#include <stdint.h> -#include <assert.h> - -#include "nvim/viml/parser/expressions.h" -#include "nvim/viml/parser/parser.h" -#include "nvim/mbyte.h" - -#include "nvim/memory.c" -#include "nvim/mbyte.c" -#include "nvim/charset.c" -#include "nvim/garray.c" -#include "nvim/gettext.c" -#include "nvim/keycodes.c" -#include "nvim/viml/parser/expressions.c" - -#define INPUT_SIZE 7 - -uint8_t avoid_optimizing_out; - -void simple_get_line(void *cookie, ParserLine *ret_pline) -{ - ParserLine **plines_p = (ParserLine **)cookie; - *ret_pline = **plines_p; - (*plines_p)++; -} - -int main(const int argc, const char *const *const argv, - const char *const *const environ) -{ - char input[INPUT_SIZE]; - uint8_t shift; - int flags; - avoid_optimizing_out = argc; - -#ifndef USE_KLEE - sscanf(argv[2], "%d", &flags); -#endif - -#ifdef USE_KLEE - klee_make_symbolic(input, sizeof(input), "input"); - klee_make_symbolic(&shift, sizeof(shift), "shift"); - klee_make_symbolic(&flags, sizeof(flags), "flags"); - klee_assume(shift < INPUT_SIZE); - klee_assume(flags <= (kELFlagPeek|kELFlagAllowFloat|kELFlagForbidEOC - |kELFlagForbidScope|kELFlagIsNotCmp)); -#endif - - ParserLine plines[] = { - { -#ifdef USE_KLEE - .data = &input[shift], - .size = sizeof(input) - shift, -#else - .data = (const char *)argv[1], - .size = strlen(argv[1]), -#endif - .allocated = false, - }, - { - .data = NULL, - .size = 0, - .allocated = false, - }, - }; -#ifdef USE_KLEE - assert(plines[0].size <= INPUT_SIZE); - assert((plines[0].data[0] != 5) | (plines[0].data[0] != argc)); -#endif - ParserLine *cur_pline = &plines[0]; - - ParserState pstate = { - .reader = { - .get_line = simple_get_line, - .cookie = &cur_pline, - .lines = KV_INITIAL_VALUE, - .conv.vc_type = CONV_NONE, - }, - .pos = { 0, 0 }, - .colors = NULL, - .can_continuate = false, - }; - kvi_init(pstate.reader.lines); - - allocated_memory_limit = 0; - LexExprToken token = viml_pexpr_next_token(&pstate, flags); - if (flags & kELFlagPeek) { - assert(pstate.pos.line == 0 && pstate.pos.col == 0); - } else { - assert((pstate.pos.line == 0) - ? (pstate.pos.col > 0) - : (pstate.pos.line == 1 && pstate.pos.col == 0)); - } - assert(allocated_memory == 0); - assert(ever_allocated_memory == 0); -#ifndef USE_KLEE - fprintf(stderr, "tkn: %s\n", viml_pexpr_repr_token(&pstate, token, NULL)); -#endif -} diff --git a/test/symbolic/klee/viml_expressions_parser.c b/test/symbolic/klee/viml_expressions_parser.c deleted file mode 100644 index b0e1d71127..0000000000 --- a/test/symbolic/klee/viml_expressions_parser.c +++ /dev/null @@ -1,117 +0,0 @@ -#ifdef USE_KLEE -# include <klee/klee.h> -#else -# include <string.h> -#endif -#include <stddef.h> -#include <stdint.h> -#include <assert.h> - -#include "nvim/viml/parser/expressions.h" -#include "nvim/viml/parser/parser.h" -#include "nvim/mbyte.h" - -#include "nvim/memory.c" -#include "nvim/mbyte.c" -#include "nvim/charset.c" -#include "nvim/garray.c" -#include "nvim/gettext.c" -#include "nvim/viml/parser/expressions.c" -#include "nvim/keycodes.c" - -#define INPUT_SIZE 50 - -uint8_t avoid_optimizing_out; - -void simple_get_line(void *cookie, ParserLine *ret_pline) -{ - ParserLine **plines_p = (ParserLine **)cookie; - *ret_pline = **plines_p; - (*plines_p)++; -} - -int main(const int argc, const char *const *const argv, - const char *const *const environ) -{ - char input[INPUT_SIZE]; - uint8_t shift; - unsigned flags; - const bool peek = false; - avoid_optimizing_out = argc; - -#ifndef USE_KLEE - sscanf(argv[2], "%d", &flags); -#endif - -#ifdef USE_KLEE - klee_make_symbolic(input, sizeof(input), "input"); - klee_make_symbolic(&shift, sizeof(shift), "shift"); - klee_make_symbolic(&flags, sizeof(flags), "flags"); - klee_assume(shift < INPUT_SIZE); - klee_assume( - flags <= (kExprFlagsMulti|kExprFlagsDisallowEOC|kExprFlagsParseLet)); -#endif - - ParserLine plines[] = { - { -#ifdef USE_KLEE - .data = &input[shift], - .size = sizeof(input) - shift, -#else - .data = argv[1], - .size = strlen(argv[1]), -#endif - .allocated = false, - }, - { - .data = NULL, - .size = 0, - .allocated = false, - }, - }; -#ifdef USE_KLEE - assert(plines[0].size <= INPUT_SIZE); - assert((plines[0].data[0] != 5) | (plines[0].data[0] != argc)); -#endif - ParserLine *cur_pline = &plines[0]; - - ParserHighlight colors; - kvi_init(colors); - - ParserState pstate = { - .reader = { - .get_line = simple_get_line, - .cookie = &cur_pline, - .lines = KV_INITIAL_VALUE, - .conv.vc_type = CONV_NONE, - }, - .pos = { 0, 0 }, - .colors = &colors, - .can_continuate = false, - }; - kvi_init(pstate.reader.lines); - - const ExprAST ast = viml_pexpr_parse(&pstate, (int)flags); - assert(ast.root != NULL || ast.err.msg); - if (flags & kExprFlagsParseLet) { - assert(ast.err.msg != NULL - || ast.root->type == kExprNodeAssignment - || (ast.root->type == kExprNodeListLiteral - && ast.root->children != NULL) - || ast.root->type == kExprNodeComplexIdentifier - || ast.root->type == kExprNodeCurlyBracesIdentifier - || ast.root->type == kExprNodePlainIdentifier - || ast.root->type == kExprNodeRegister - || ast.root->type == kExprNodeEnvironment - || ast.root->type == kExprNodeOption - || ast.root->type == kExprNodeSubscript - || ast.root->type == kExprNodeConcatOrSubscript); - } - // Can’t possibly have more highlight tokens then there are bytes in string. - assert(kv_size(colors) <= INPUT_SIZE - shift); - kvi_destroy(colors); - // Not destroying pstate.reader.lines because there is no way it could exceed - // its limits in the current circumstances. - viml_pexpr_free_ast(ast); - assert(allocated_memory == 0); -} diff --git a/test/unit/eval/helpers.lua b/test/unit/eval/helpers.lua index b600f01ab2..9dd6b76de2 100644 --- a/test/unit/eval/helpers.lua +++ b/test/unit/eval/helpers.lua @@ -349,7 +349,7 @@ local special_vals = nil lua2typvalt = function(l, processed) if not special_vals then special_vals = { - [null_string] = {'VAR_STRING', {v_string=ffi.cast('char_u*', nil)}}, + [null_string] = {'VAR_STRING', {v_string=ffi.cast('char*', nil)}}, [null_list] = {'VAR_LIST', {v_list=ffi.cast('list_T*', nil)}}, [null_dict] = {'VAR_DICT', {v_dict=ffi.cast('dict_T*', nil)}}, [nil_value] = {'VAR_SPECIAL', {v_special=eval.kSpecialVarNull}}, diff --git a/test/unit/message_spec.lua b/test/unit/message_spec.lua index 549eff6e03..0d5268d199 100644 --- a/test/unit/message_spec.lua +++ b/test/unit/message_spec.lua @@ -12,7 +12,7 @@ describe('trunc_string', function() local buflen = 40 local function test_inplace(s, expected, room) room = room and room or 20 - local buf = cimp.xmalloc(ffi.sizeof('char_u') * buflen) + local buf = cimp.xmalloc(ffi.sizeof('char') * buflen) ffi.C.strcpy(buf, s) cimp.trunc_string(buf, buf, room, buflen) eq(expected, ffi.string(buf)) @@ -21,7 +21,7 @@ describe('trunc_string', function() local function test_copy(s, expected, room) room = room and room or 20 - local buf = cimp.xmalloc(ffi.sizeof('char_u') * buflen) + local buf = cimp.xmalloc(ffi.sizeof('char') * buflen) local str = cimp.xstrdup(to_cstr(s)) cimp.trunc_string(str, buf, room, buflen) eq(expected, ffi.string(buf)) diff --git a/test/unit/undo_spec.lua b/test/unit/undo_spec.lua index f7f8d26d58..cdc5d3a99e 100644 --- a/test/unit/undo_spec.lua +++ b/test/unit/undo_spec.lua @@ -37,7 +37,7 @@ child_call_once(function() -- requires refactor of UNDO_HASH_SIZE into constant/enum for ffi -- -- compute a hash for this undofile - buffer_hash = ffi.new('char_u[32]') + buffer_hash = ffi.new('char[32]') undo.u_compute_hash(file_buffer, buffer_hash) end) |