GitHub/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim synced 2025-07-16 01:01:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: reformat with uncrustify #15736

Browse Source 
* fix function parameter comments
* remove space after star in function names
This commit is contained in:
dundargoc
2021-09-20 18:35:41 +02:00
committed by GitHub
parent 1f8c91bf72
commit f4ca3a29dd
27 changed files with 1412 additions and 1262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
contrib/uncrustify.cfg
View File

@ -208,7 +208,7 @@ sp_after_ptr_star_qualifier = ignore # ignore/add/remove/force/not_defined
# prototype or function definition.
#
# Overrides sp_after_ptr_star and sp_type_func.
sp_after_ptr_star_func = ignore # ignore/add/remove/force/not_defined
sp_after_ptr_star_func = remove # ignore/add/remove/force/not_defined
# Add or remove space after a pointer star '*' in the trailing return of a
# function prototype or function definition.
@ -3279,5 +3279,5 @@ set PREPROC REAL_FATTR_CONST
set PREPROC REAL_FATTR_NONNULL_ALL
set PREPROC REAL_FATTR_PURE
set PREPROC REAL_FATTR_WARN_UNUSED_RESULT
# option(s) with 'not default' value: 61
# option(s) with 'not default' value: 62
#

4
src/nvim/ex_getln.c
View File

@ -5218,8 +5218,8 @@ static void expand_shellcmd(char_u *filepat, int *num_file, char_u ***file, int
/// Call "user_expand_func()" to invoke a user defined Vim script function and
/// return the result (either a string, a List or NULL).
static void * call_user_expand_func(user_expand_func_T user_expand_func, expand_T *xp,
int *num_file, char_u ***file)
static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T *xp, int *num_file,
char_u ***file)
FUNC_ATTR_NONNULL_ALL
{
char_u keep = 0;

537
src/nvim/file_search.c
View File

File diff suppressed because it is too large Load Diff

9
src/nvim/garray.c
View File

@ -5,16 +5,16 @@
///
/// Functions for handling growing arrays.
#include <string.h>
#include <inttypes.h>
#include <string.h>
#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/garray.h"
#include "nvim/log.h"
#include "nvim/memory.h"
#include "nvim/path.h"
#include "nvim/garray.h"
#include "nvim/strings.h"
#include "nvim/vim.h"
// #include "nvim/globals.h"
#include "nvim/memline.h"
@ -206,8 +206,7 @@ void ga_concat(garray_T *gap, const char_u *restrict s)
/// @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)
void ga_concat_len(garray_T *const gap, const char *restrict s, const size_t len)
FUNC_ATTR_NONNULL_ALL
{
if (len) {

541
src/nvim/getchar.c
View File

File diff suppressed because it is too large Load Diff

350
src/nvim/hardcopy.c
View File

@ -6,35 +6,35 @@
*/
#include <assert.h>
#include <string.h>
#include <inttypes.h>
#include <string.h>
#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/vim.h"
#ifdef HAVE_LOCALE_H
# include <locale.h>
#endif
#include "nvim/hardcopy.h"
#include "nvim/buffer.h"
#include "nvim/charset.h"
#include "nvim/eval.h"
#include "nvim/ex_cmds2.h"
#include "nvim/ex_docmd.h"
#include "nvim/fileio.h"
#include "nvim/garray.h"
#include "nvim/hardcopy.h"
#include "nvim/mbyte.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/garray.h"
#include "nvim/option.h"
#include "nvim/os/input.h"
#include "nvim/os/os.h"
#include "nvim/path.h"
#include "nvim/screen.h"
#include "nvim/strings.h"
#include "nvim/syntax.h"
#include "nvim/ui.h"
#include "nvim/version.h"
#include "nvim/os/os.h"
#include "nvim/os/input.h"
/*
* To implement printing on a platform, the following functions must be
@ -286,8 +286,7 @@ char_u *parse_printmbfont(void)
* Returns an error message for an illegal option, NULL otherwise.
* Only used for the printer at the moment...
*/
static char_u *parse_list_options(char_u *option_str, option_table_T *table,
size_t table_size)
static char_u *parse_list_options(char_u *option_str, option_table_T *table, size_t table_size)
{
option_table_T *old_opts;
char_u *ret = NULL;
@ -317,14 +316,17 @@ static char_u *parse_list_options(char_u *option_str, option_table_T *table,
break;
}
commap = vim_strchr(stringp, ',');
if (commap == NULL)
if (commap == NULL) {
commap = option_str + STRLEN(option_str);
}
len = (int)(colonp - stringp);
for (idx = 0; idx < table_size; ++idx)
if (STRNICMP(stringp, table[idx].name, len) == 0)
for (idx = 0; idx < table_size; ++idx) {
if (STRNICMP(stringp, table[idx].name, len) == 0) {
break;
}
}
if (idx == table_size) {
ret = (char_u *)N_("E551: Illegal component");
@ -347,9 +349,10 @@ static char_u *parse_list_options(char_u *option_str, option_table_T *table,
table[idx].strlen = (int)(commap - p);
stringp = commap;
if (*stringp == ',')
if (*stringp == ',') {
++stringp;
}
}
if (ret != NULL) {
// Restore old options in case of error
@ -401,16 +404,18 @@ static void prt_get_attr(int hl_id, prt_text_attr_T *pattr, int modec)
colorindex = atoi(color);
}
if (colorindex >= 0 && colorindex < t_colors)
if (colorindex >= 0 && colorindex < t_colors) {
fg_color = prt_get_term_color(colorindex);
else
} else {
fg_color = PRCOLOR_BLACK;
}
}
if (fg_color == PRCOLOR_WHITE)
if (fg_color == PRCOLOR_WHITE) {
fg_color = PRCOLOR_BLACK;
else if (*p_bg == 'd')
} else if (*p_bg == 'd') {
fg_color = darken_rgb(fg_color);
}
pattr->fg_color = fg_color;
pattr->bg_color = PRCOLOR_WHITE;
@ -432,8 +437,7 @@ static void prt_set_bg(uint32_t bg)
}
}
static void prt_set_font(const TriState bold, const TriState italic,
const TriState underline)
static void prt_set_font(const TriState bold, const TriState italic, const TriState underline)
{
if (curr_bold != bold
|| curr_italic != italic
@ -446,8 +450,8 @@ static void prt_set_font(const TriState bold, const TriState italic,
}
// Print the line number in the left margin.
static void prt_line_number(prt_settings_T *const psettings,
const int page_line, const linenr_T lnum)
static void prt_line_number(prt_settings_T *const psettings, const int page_line,
const linenr_T lnum)
{
prt_set_fg(psettings->number.fg_color);
prt_set_bg(psettings->number.bg_color);
@ -504,18 +508,19 @@ int prt_get_unit(int idx)
int i;
static char *(units[4]) = PRT_UNIT_NAMES;
if (printer_opts[idx].present)
for (i = 0; i < 4; ++i)
if (printer_opts[idx].present) {
for (i = 0; i < 4; ++i) {
if (STRNICMP(printer_opts[idx].string, units[i], 2) == 0) {
u = i;
break;
}
}
}
return u;
}
// Print the page header.
static void prt_header(prt_settings_T *const psettings, const int pagenum,
const linenr_T lnum)
static void prt_header(prt_settings_T *const psettings, const int pagenum, const linenr_T lnum)
{
int width = psettings->chars_per_line;
@ -620,13 +625,15 @@ void ex_hardcopy(exarg_T *eap)
// Expand things like "%.ps".
if (expand_filename(eap, eap->cmdlinep, &errormsg) == FAIL) {
if (errormsg != NULL)
if (errormsg != NULL) {
EMSG(errormsg);
}
return;
}
settings.outfile = skipwhite(eap->arg + 1);
} else if (*eap->arg != NUL)
} else if (*eap->arg != NUL) {
settings.arguments = eap->arg;
}
/*
* Initialise for printing. Ask the user for settings, unless forceit is
@ -641,19 +648,21 @@ void ex_hardcopy(exarg_T *eap)
: curbuf->b_sfname == NULL
? curbuf->b_fname
: curbuf->b_sfname,
eap->forceit) == FAIL)
eap->forceit) == FAIL) {
return;
}
settings.modec = 'c';
if (!syntax_present(curwin))
if (!syntax_present(curwin)) {
settings.do_syntax = FALSE;
else if (printer_opts[OPT_PRINT_SYNTAX].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) != 'a')
} else if (printer_opts[OPT_PRINT_SYNTAX].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) != 'a') {
settings.do_syntax =
(TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) == 'y');
else
} else {
settings.do_syntax = settings.has_color;
}
// Set up printing attributes for line numbers
settings.number.fg_color = PRCOLOR_BLACK;
@ -675,8 +684,9 @@ void ex_hardcopy(exarg_T *eap)
/*
* Estimate the total lines to be printed
*/
for (lnum = eap->line1; lnum <= eap->line2; lnum++)
for (lnum = eap->line1; lnum <= eap->line2; lnum++) {
bytes_to_print += STRLEN(skipwhite(ml_get(lnum)));
}
if (bytes_to_print == 0) {
MSG(_("No text to be printed"));
goto print_fail_no_begin;
@ -697,8 +707,9 @@ void ex_hardcopy(exarg_T *eap)
jobsplit = (printer_opts[OPT_PRINT_JOBSPLIT].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_JOBSPLIT].string[0]) == 'y');
if (!mch_print_begin(&settings))
if (!mch_print_begin(&settings)) {
goto print_fail_no_begin;
}
/*
* Loop over collated copies: 1 2 3, 1 2 3, ...
@ -718,9 +729,10 @@ void ex_hardcopy(exarg_T *eap)
if (jobsplit && collated_copies > 0) {
// Splitting jobs: Stop a previous job and start a new one.
mch_print_end(&settings);
if (!mch_print_begin(&settings))
if (!mch_print_begin(&settings)) {
goto print_fail_no_begin;
}
}
/*
* Loop over all pages in the print job: 1 2 3 ...
@ -746,29 +758,33 @@ void ex_hardcopy(exarg_T *eap)
// Check for interrupt character every page.
os_breakcheck();
if (got_int || settings.user_abort)
if (got_int || settings.user_abort) {
goto print_fail;
}
assert(prtpos.bytes_printed <= SIZE_MAX / 100);
sprintf((char *)IObuff, _("Printing page %d (%zu%%)"),
page_count + 1 + side,
prtpos.bytes_printed * 100 / bytes_to_print);
if (!mch_print_begin_page(IObuff))
if (!mch_print_begin_page(IObuff)) {
goto print_fail;
}
if (settings.n_collated_copies > 1)
if (settings.n_collated_copies > 1) {
sprintf((char *)IObuff + STRLEN(IObuff),
_(" Copy %d of %d"),
collated_copies + 1,
settings.n_collated_copies);
}
prt_message(IObuff);
/*
* Output header if required
*/
if (prt_header_height() > 0)
if (prt_header_height() > 0) {
prt_header(&settings, page_count + 1 + side,
prtpos.file_line);
}
for (page_line = 0; page_line < settings.lines_per_page;
++page_line) {
@ -803,12 +819,14 @@ void ex_hardcopy(exarg_T *eap)
if (prtpos.file_line > eap->line2 && settings.duplex
&& side == 0
&& uncollated_copies + 1 < settings.n_uncollated_copies) {
if (!mch_print_blank_page())
if (!mch_print_blank_page()) {
goto print_fail;
}
}
if (settings.duplex && prtpos.file_line <= eap->line2)
}
if (settings.duplex && prtpos.file_line <= eap->line2) {
++page_count;
}
// Remember the position where the next page starts.
page_prtpos = prtpos;
@ -848,8 +866,9 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
if (ppos->column == 0 || ppos->ff) {
print_pos = 0;
tab_spaces = 0;
if (!ppos->ff && prt_use_number())
if (!ppos->ff && prt_use_number()) {
prt_line_number(psettings, page_line, ppos->file_line);
}
ppos->ff = FALSE;
} else {
// left over from wrap halfway through a tab
@ -870,10 +889,11 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
// syntax highlighting stuff.
if (psettings->do_syntax) {
id = syn_get_id(curwin, ppos->file_line, col, 1, NULL, FALSE);
if (id > 0)
if (id > 0) {
id = syn_get_final_id(id);
else
} else {
id = 0;
}
// Get the line again, a multi-line regexp may invalidate it.
line = ml_get(ppos->file_line);
@ -900,9 +920,10 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
need_break = mch_print_text_out((char_u *)" ", 1);
print_pos++;
tab_spaces--;
if (need_break)
if (need_break) {
break;
}
}
// Keep the TAB if we didn't finish it.
if (need_break && tab_spaces > 0) {
break;
@ -930,8 +951,9 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
&& (line[col] == NUL
|| (printer_opts[OPT_PRINT_WRAP].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_WRAP].string[0])
== 'n')))
== 'n'))) {
return 0;
}
return col;
}
@ -1361,12 +1383,13 @@ static void prt_def_font(char *new_name, char *encoding, int height, char *font)
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/_%s /VIM-%s /%s ref\n", new_name, encoding, font);
prt_write_file(prt_line_buffer);
if (prt_out_mbyte)
if (prt_out_mbyte) {
sprintf((char *)prt_line_buffer, "/%s %d %f /_%s sffs\n",
new_name, height, 500./prt_ps_courier_font.wx, new_name);
else
} else {
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s %d /_%s ffs\n", new_name, height, new_name);
}
prt_write_file(prt_line_buffer);
}
@ -1402,10 +1425,12 @@ static void prt_real_bits(double real, int precision, int *pinteger, int *pfract
{
int integer = (int)real;
double fraction = real - integer;
if (real < integer)
if (real < integer) {
fraction = -fraction;
for (int i = 0; i < precision; i++)
}
for (int i = 0; i < precision; i++) {
fraction *= 10.0;
}
*pinteger = integer;
*pfraction = (int)(fraction + 0.5);
@ -1500,16 +1525,18 @@ static void prt_flush_buffer(void)
prt_write_string("ul\n");
}
// Draw the text
if (prt_out_mbyte)
if (prt_out_mbyte) {
prt_write_string("<");
else
} else {
prt_write_string("(");
}
assert(prt_ps_buffer.ga_len >= 0);
prt_write_file_raw_len(prt_ps_buffer.ga_data, (size_t)prt_ps_buffer.ga_len);
if (prt_out_mbyte)
if (prt_out_mbyte) {
prt_write_string(">");
else
} else {
prt_write_string(")");
}
// Add a moveto if need be and use the appropriate show procedure
if (prt_do_moveto) {
prt_write_real(prt_pos_x_moveto, 2);
@ -1529,11 +1556,12 @@ static void prt_resource_name(char_u *filename, void *cookie)
{
char_u *resource_filename = cookie;
if (STRLEN(filename) >= MAXPATHL)
if (STRLEN(filename) >= MAXPATHL) {
*resource_filename = NUL;
else
} else {
STRCPY(resource_filename, filename);
}
}
static int prt_find_resource(char *name, struct prt_ps_resource_S *resource)
{
@ -1568,15 +1596,17 @@ static int prt_resfile_next_line(void)
// Move to start of next line and then find end of line
idx = prt_resfile.line_end + 1;
while (idx < prt_resfile.len) {
if (prt_resfile.buffer[idx] != PSLF && prt_resfile.buffer[idx] != PSCR)
if (prt_resfile.buffer[idx] != PSLF && prt_resfile.buffer[idx] != PSCR) {
break;
}
idx++;
}
prt_resfile.line_start = idx;
while (idx < prt_resfile.len) {
if (prt_resfile.buffer[idx] == PSLF || prt_resfile.buffer[idx] == PSCR)
if (prt_resfile.buffer[idx] == PSLF || prt_resfile.buffer[idx] == PSCR) {
break;
}
idx++;
}
prt_resfile.line_end = idx;
@ -1601,8 +1631,9 @@ static int prt_resfile_skip_nonws(int offset)
idx = prt_resfile.line_start + offset;
while (idx < prt_resfile.line_end) {
if (isspace(prt_resfile.buffer[idx]))
if (isspace(prt_resfile.buffer[idx])) {
return idx - prt_resfile.line_start;
}
idx++;
}
return -1;
@ -1614,8 +1645,9 @@ static int prt_resfile_skip_ws(int offset)
idx = prt_resfile.line_start + offset;
while (idx < prt_resfile.line_end) {
if (!isspace(prt_resfile.buffer[idx]))
if (!isspace(prt_resfile.buffer[idx])) {
return idx - prt_resfile.line_start;
}
idx++;
}
return -1;
@ -1786,8 +1818,7 @@ static bool prt_open_resource(struct prt_ps_resource_S *resource)
return true;
}
static bool prt_check_resource(const struct prt_ps_resource_S *resource,
const char_u *version)
static bool prt_check_resource(const struct prt_ps_resource_S *resource, const char_u *version)
FUNC_ATTR_NONNULL_ALL
{
// Version number m.n should match, the revision number does not matter
@ -1846,19 +1877,17 @@ static void prt_dsc_ints(char *comment, int count, int *ints)
prt_write_string("\n");
}
static void prt_dsc_resources(
const char *comment, // if NULL add to previous
const char *type,
const char *string
)
/// @param comment if NULL add to previous
static void prt_dsc_resources(const char *comment, const char *type, const char *string)
FUNC_ATTR_NONNULL_ARG(2, 3)
{
if (comment != NULL)
if (comment != NULL) {
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: %s", comment, type);
else
} else {
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%+ %s", type);
}
prt_write_file(prt_line_buffer);
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
@ -1872,31 +1901,37 @@ static void prt_dsc_font_resource(char *resource, struct prt_ps_font_S *ps_font)
prt_dsc_resources(resource, "font",
ps_font->ps_fontname[PRT_PS_FONT_ROMAN]);
for (i = PRT_PS_FONT_BOLD; i <= PRT_PS_FONT_BOLDOBLIQUE; i++)
if (ps_font->ps_fontname[i] != NULL)
for (i = PRT_PS_FONT_BOLD; i <= PRT_PS_FONT_BOLDOBLIQUE; i++) {
if (ps_font->ps_fontname[i] != NULL) {
prt_dsc_resources(NULL, "font", ps_font->ps_fontname[i]);
}
}
}
static void prt_dsc_requirements(int duplex, int tumble, int collate, int color, int num_copies)
{
/* Only output the comment if we need to.
* Note: tumble is ignored if we are not duplexing
*/
if (!(duplex || collate || color || (num_copies > 1)))
if (!(duplex || collate || color || (num_copies > 1))) {
return;
}
sprintf((char *)prt_line_buffer, "%%%%Requirements:");
prt_write_file(prt_line_buffer);
if (duplex) {
prt_write_string(" duplex");
if (tumble)
if (tumble) {
prt_write_string("(tumble)");
}
if (collate)
}
if (collate) {
prt_write_string(" collate");
if (color)
}
if (color) {
prt_write_string(" color");
}
if (num_copies > 1) {
prt_write_string(" numcopies(");
// Note: no space wanted so don't use prt_write_int()
@ -1908,7 +1943,8 @@ static void prt_dsc_requirements(int duplex, int tumble, int collate, int color,
prt_write_string("\n");
}
static void prt_dsc_docmedia(char *paper_name, double width, double height, double weight, char *colour, char *type)
static void prt_dsc_docmedia(char *paper_name, double width, double height, double weight,
char *colour, char *type)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%DocumentMedia: %s ", paper_name);
@ -1916,15 +1952,17 @@ static void prt_dsc_docmedia(char *paper_name, double width, double height, doub
prt_write_real(width, 2);
prt_write_real(height, 2);
prt_write_real(weight, 2);
if (colour == NULL)
if (colour == NULL) {
prt_write_string("()");
else
} else {
prt_write_string(colour);
}
prt_write_string(" ");
if (type == NULL)
if (type == NULL) {
prt_write_string("()");
else
} else {
prt_write_string(type);
}
prt_write_string("\n");
}
@ -1938,8 +1976,9 @@ void mch_print_cleanup(void)
* one style).
*/
for (i = PRT_PS_FONT_ROMAN; i <= PRT_PS_FONT_BOLDOBLIQUE; i++) {
if (prt_ps_mb_font.ps_fontname[i] != NULL)
if (prt_ps_mb_font.ps_fontname[i] != NULL) {
xfree(prt_ps_mb_font.ps_fontname[i]);
}
prt_ps_mb_font.ps_fontname[i] = NULL;
}
}
@ -1993,7 +2032,8 @@ static double to_device_units(int idx, double physsize, int def_number)
/*
* Calculate margins for given width and height from printoptions settings.
*/
static void prt_page_margins(double width, double height, double *left, double *right, double *top, double *bottom)
static void prt_page_margins(double width, double height, double *left, double *right, double *top,
double *bottom)
{
*left = to_device_units(OPT_PRINT_LEFT, width, 10);
*right = width - to_device_units(OPT_PRINT_RIGHT, width, 5);
@ -2015,11 +2055,13 @@ static int prt_get_cpl(void)
/* If we are outputting multi-byte characters then line numbers will be
* printed with half width characters
*/
if (prt_out_mbyte)
if (prt_out_mbyte) {
prt_number_width /= 2;
}
prt_left_margin += prt_number_width;
} else
} else {
prt_number_width = 0.0;
}
return (int)((prt_right_margin - prt_left_margin) / prt_char_width);
}
@ -2063,7 +2105,8 @@ static int prt_get_lpp(void)
return lpp - prt_header_height();
}
static int prt_match_encoding(char *p_encoding, struct prt_ps_mbfont_S *p_cmap, struct prt_ps_encoding_S **pp_mbenc)
static int prt_match_encoding(char *p_encoding, struct prt_ps_mbfont_S *p_cmap,
struct prt_ps_encoding_S **pp_mbenc)
{
int mbenc;
int enc_len;
@ -2083,7 +2126,8 @@ static int prt_match_encoding(char *p_encoding, struct prt_ps_mbfont_S *p_cmap,
return FALSE;
}
static int prt_match_charset(char *p_charset, struct prt_ps_mbfont_S *p_cmap, struct prt_ps_charset_S **pp_mbchar)
static int prt_match_charset(char *p_charset, struct prt_ps_mbfont_S *p_cmap,
struct prt_ps_charset_S **pp_mbchar)
{
int mbchar;
int char_len;
@ -2124,8 +2168,9 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
* Set up font and encoding.
*/
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL)
if (*p_encoding == NUL) {
p_encoding = enc_skip(p_enc);
}
/* Look for a multi-byte font that matches the encoding and character set.
* Only look if multi-byte character set is defined, or using multi-byte
@ -2136,16 +2181,18 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
if (!(props & ENC_8BIT) && ((*p_pmcs != NUL) || !(props & ENC_UNICODE))) {
p_mbenc_first = NULL;
int effective_cmap = 0;
for (cmap = 0; cmap < (int)ARRAY_SIZE(prt_ps_mbfonts); cmap++)
for (cmap = 0; cmap < (int)ARRAY_SIZE(prt_ps_mbfonts); cmap++) {
if (prt_match_encoding((char *)p_encoding, &prt_ps_mbfonts[cmap],
&p_mbenc)) {
if (p_mbenc_first == NULL) {
p_mbenc_first = p_mbenc;
effective_cmap = cmap;
}
if (prt_match_charset((char *)p_pmcs, &prt_ps_mbfonts[cmap], &p_mbchar))
if (prt_match_charset((char *)p_pmcs, &prt_ps_mbfonts[cmap], &p_mbchar)) {
break;
}
}
}
// Use first encoding matched if no charset matched
if (p_mbenc_first != NULL && p_mbchar == NULL) {
@ -2205,7 +2252,6 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
prt_build_cid_fontname(PRT_PS_FONT_BOLD,
mbfont_opts[OPT_MBFONT_BOLD].string,
mbfont_opts[OPT_MBFONT_BOLD].strlen);
}
if (mbfont_opts[OPT_MBFONT_OBLIQUE].present) {
prt_build_cid_fontname(PRT_PS_FONT_OBLIQUE,
@ -2252,13 +2298,16 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
paper_name = "A4";
paper_strlen = 2;
}
for (i = 0; i < (int)PRT_MEDIASIZE_LEN; ++i)
for (i = 0; i < (int)PRT_MEDIASIZE_LEN; ++i) {
if (STRLEN(prt_mediasize[i].name) == (unsigned)paper_strlen
&& STRNICMP(prt_mediasize[i].name, paper_name,
paper_strlen) == 0)
paper_strlen) == 0) {
break;
if (i == PRT_MEDIASIZE_LEN)
}
}
if (i == PRT_MEDIASIZE_LEN) {
i = 0;
}
prt_media = i;
/*
@ -2290,9 +2339,11 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
* Set up the font size.
*/
fontsize = PRT_PS_DEFAULT_FONTSIZE;
for (p = p_pfn; (p = vim_strchr(p, ':')) != NULL; ++p)
if (p[1] == 'h' && ascii_isdigit(p[2]))
for (p = p_pfn; (p = vim_strchr(p, ':')) != NULL; ++p) {
if (p[1] == 'h' && ascii_isdigit(p[2])) {
fontsize = atoi((char *)p + 2);
}
}
prt_font_metrics(fontsize);
/*
@ -2340,9 +2391,10 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
prt_duplex = FALSE;
psettings->duplex = 0;
} else if (STRNICMP(printer_opts[OPT_PRINT_DUPLEX].string, "short", 5)
== 0)
== 0) {
prt_tumble = TRUE;
}
}
// For now user abort not supported
psettings->user_abort = 0;
@ -2369,8 +2421,9 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
}
prt_bufsiz = psettings->chars_per_line;
if (prt_out_mbyte)
if (prt_out_mbyte) {
prt_bufsiz *= 2;
}
ga_init(&prt_ps_buffer, (int)sizeof(char), prt_bufsiz);
prt_page_num = 0;
@ -2420,8 +2473,9 @@ static int prt_add_resource(struct prt_ps_resource_S *resource)
fclose(fd_resource);
return FALSE;
}
if (bytes_read == 0)
if (bytes_read == 0) {
break;
}
prt_write_file_raw_len(resource_buffer, bytes_read);
if (prt_file_error) {
fclose(fd_resource);
@ -2468,8 +2522,9 @@ int mch_print_begin(prt_settings_T *psettings)
char *p_time = os_ctime(ctime_buf, sizeof(ctime_buf));
// Note: os_ctime() adds a \n so we have to remove it :-(
p = vim_strchr((char_u *)p_time, '\n');
if (p != NULL)
if (p != NULL) {
*p = NUL;
}
prt_dsc_textline("CreationDate", p_time);
prt_dsc_textline("DocumentData", "Clean8Bit");
prt_dsc_textline("Orientation", "Portrait");
@ -2516,30 +2571,35 @@ int mch_print_begin(prt_settings_T *psettings)
if (prt_out_mbyte) {
prt_dsc_font_resource((prt_use_courier ? NULL
: "DocumentNeededResources"), &prt_ps_mb_font);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
}
// Search for external resources VIM supplies
if (!prt_find_resource("prolog", &res_prolog)) {
EMSG(_("E456: Can't find PostScript resource file \"prolog.ps\""));
return FALSE;
}
if (!prt_open_resource(&res_prolog))
if (!prt_open_resource(&res_prolog)) {
return FALSE;
if (!prt_check_resource(&res_prolog, PRT_PROLOG_VERSION))
}
if (!prt_check_resource(&res_prolog, PRT_PROLOG_VERSION)) {
return FALSE;
}
if (prt_out_mbyte) {
// Look for required version of multi-byte printing procset
if (!prt_find_resource("cidfont", &res_cidfont)) {
EMSG(_("E456: Can't find PostScript resource file \"cidfont.ps\""));
return FALSE;
}
if (!prt_open_resource(&res_cidfont))
if (!prt_open_resource(&res_cidfont)) {
return FALSE;
if (!prt_check_resource(&res_cidfont, PRT_CID_PROLOG_VERSION))
}
if (!prt_check_resource(&res_cidfont, PRT_CID_PROLOG_VERSION)) {
return FALSE;
}
}
/* Find an encoding to use for printing.
* Check 'printencoding'. If not set or not found, then use 'encoding'. If
@ -2567,14 +2627,16 @@ int mch_print_begin(prt_settings_T *psettings)
}
}
}
if (!prt_open_resource(&res_encoding))
if (!prt_open_resource(&res_encoding)) {
return FALSE;
}
/* For the moment there are no checks on encoding resource files to
* perform */
} else {
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL)
if (*p_encoding == NUL) {
p_encoding = enc_skip(p_enc);
}
if (prt_use_courier) {
// Include ASCII range encoding vector
if (!prt_find_resource(prt_ascii_encoding, &res_encoding)) {
@ -2582,8 +2644,9 @@ int mch_print_begin(prt_settings_T *psettings)
prt_ascii_encoding);
return FALSE;
}
if (!prt_open_resource(&res_encoding))
if (!prt_open_resource(&res_encoding)) {
return FALSE;
}
/* For the moment there are no checks on encoding resource files to
* perform */
}
@ -2607,9 +2670,10 @@ int mch_print_begin(prt_settings_T *psettings)
prt_cmap);
return FALSE;
}
if (!prt_open_resource(&res_cmap))
if (!prt_open_resource(&res_cmap)) {
return FALSE;
}
}
// List resources supplied
STRCPY(buffer, res_prolog.title);
@ -2652,9 +2716,10 @@ int mch_print_begin(prt_settings_T *psettings)
if (prt_out_mbyte) {
prt_dsc_font_resource((prt_use_courier ? NULL : "PageResources"),
&prt_ps_mb_font);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
}
// Paper will be used for all pages
prt_dsc_textline("PageMedia", prt_mediasize[prt_media].name);
@ -2680,11 +2745,13 @@ int mch_print_begin(prt_settings_T *psettings)
}
}
if (!prt_out_mbyte || prt_use_courier)
if (!prt_out_mbyte || prt_use_courier) {
/* There will be only one Roman font encoding to be included in the PS
* file. */
if (!prt_add_resource(&res_encoding))
if (!prt_add_resource(&res_encoding)) {
return FALSE;
}
}
prt_dsc_noarg("EndProlog");
@ -2710,8 +2777,9 @@ int mch_print_begin(prt_settings_T *psettings)
if (!prt_out_mbyte || prt_use_courier) {
/* When using Courier for ASCII range when printing multi-byte, need to
* pick up ASCII encoding to use with it. */
if (prt_use_courier)
if (prt_use_courier) {
p_encoding = (char_u *)prt_ascii_encoding;
}
prt_dsc_resources("IncludeResource", "font",
prt_ps_courier_font.ps_fontname[PRT_PS_FONT_ROMAN]);
prt_def_font("F0", (char *)p_encoding, (int)prt_line_height,
@ -2738,16 +2806,18 @@ int mch_print_begin(prt_settings_T *psettings)
*/
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_ROMAN]);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
}
prt_def_cidfont("CF0", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_ROMAN]);
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD] != NULL) {
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD]);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
}
prt_def_cidfont("CF1", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD]);
} else {
@ -2757,8 +2827,9 @@ int mch_print_begin(prt_settings_T *psettings)
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE] != NULL) {
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
}
prt_def_cidfont("CF2", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
} else {
@ -2768,8 +2839,9 @@ int mch_print_begin(prt_settings_T *psettings)
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE] != NULL) {
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
if (!prt_custom_cmap)
if (!prt_custom_cmap) {
prt_dsc_resources("IncludeResource", "cmap", prt_cmap);
}
prt_def_cidfont("CF3", (int)prt_line_height,
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
} else {
@ -2853,10 +2925,11 @@ int mch_print_begin_page(char_u *str)
prt_write_string("sv\n0 g\n");
prt_in_ascii = !prt_out_mbyte;
if (prt_out_mbyte)
if (prt_out_mbyte) {
prt_write_string("CF0 sf\n");
else
} else {
prt_write_string("F0 sf\n");
}
prt_fgcol = PRCOLOR_BLACK;
prt_bgcol = PRCOLOR_WHITE;
prt_font = PRT_PS_FONT_ROMAN;
@ -2983,9 +3056,9 @@ int mch_print_text_out(char_u *const textp, size_t len)
b = prt_fgcol & 0xff;
prt_write_real(r / 255.0, 3);
if (r == g && g == b)
if (r == g && g == b) {
prt_write_string("g\n");
else {
} else {
prt_write_real(g / 255.0, 3);
prt_write_real(b / 255.0, 3);
prt_write_string("r\n");
@ -3003,8 +3076,9 @@ int mch_print_text_out(char_u *const textp, size_t len)
}
prt_need_bgcol = false;
if (prt_need_underline)
if (prt_need_underline) {
prt_do_underline = prt_underline;
}
prt_need_underline = false;
prt_attribute_change = false;
@ -3042,14 +3116,22 @@ int mch_print_text_out(char_u *const textp, size_t len)
*/
ga_append(&prt_ps_buffer, '\\');
switch (ch) {
case BS: ga_append(&prt_ps_buffer, 'b'); break;
case TAB: ga_append(&prt_ps_buffer, 't'); break;
case NL: ga_append(&prt_ps_buffer, 'n'); break;
case FF: ga_append(&prt_ps_buffer, 'f'); break;
case CAR: ga_append(&prt_ps_buffer, 'r'); break;
case '(': ga_append(&prt_ps_buffer, '('); break;
case ')': ga_append(&prt_ps_buffer, ')'); break;
case '\\': ga_append(&prt_ps_buffer, '\\'); break;
case BS:
ga_append(&prt_ps_buffer, 'b'); break;
case TAB:
ga_append(&prt_ps_buffer, 't'); break;
case NL:
ga_append(&prt_ps_buffer, 'n'); break;
case FF:
ga_append(&prt_ps_buffer, 'f'); break;
case CAR:
ga_append(&prt_ps_buffer, 'r'); break;
case '(':
ga_append(&prt_ps_buffer, '('); break;
case ')':
ga_append(&prt_ps_buffer, ')'); break;
case '\\':
ga_append(&prt_ps_buffer, '\\'); break;
default:
sprintf((char *)ch_buff, "%03o", (unsigned int)ch);
@ -3058,9 +3140,10 @@ int mch_print_text_out(char_u *const textp, size_t len)
ga_append(&prt_ps_buffer, (char)ch_buff[2]);
break;
}
} else
} else {
ga_append(&prt_ps_buffer, (char)ch);
}
}
// Need to free any translated characters
xfree(tofree);
@ -3080,15 +3163,16 @@ int mch_print_text_out(char_u *const textp, size_t len)
return need_break;
}
void mch_print_set_font(const TriState iBold, const TriState iItalic,
const TriState iUnderline)
void mch_print_set_font(const TriState iBold, const TriState iItalic, const TriState iUnderline)
{
int font = 0;
if (iBold)
if (iBold) {
font |= 0x01;
if (iItalic)
}
if (iItalic) {
font |= 0x02;
}
if (font != prt_font) {
prt_font = font;

12
src/nvim/hashtab.c
View File

@ -22,15 +22,15 @@
/// memory).
#include <assert.h>
#include <inttypes.h>
#include <stdbool.h>
#include <string.h>
#include <inttypes.h>
#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/hashtab.h"
#include "nvim/message.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/vim.h"
// Magic value for algorithm that walks through the array.
#define PERTURB_SHIFT 5
@ -102,8 +102,7 @@ hashitem_T *hash_find(const hashtab_T *const ht, const char_u *const key)
///
/// @warning Returned pointer becomes invalid as soon as the hash table
/// is changed in any way.
hashitem_T *hash_find_len(const hashtab_T *const ht, const char *const key,
const size_t len)
hashitem_T *hash_find_len(const hashtab_T *const ht, const char *const key, const size_t len)
{
return hash_lookup(ht, key, len, hash_hash_len(key, len));
}
@ -119,8 +118,7 @@ hashitem_T *hash_find_len(const hashtab_T *const ht, const char *const key,
/// used for that key.
/// WARNING: Returned pointer becomes invalid as soon as the hash table
/// is changed in any way.
hashitem_T *hash_lookup(const hashtab_T *const ht,
const char *const key, const size_t key_len,
hashitem_T *hash_lookup(const hashtab_T *const ht, const char *const key, const size_t key_len,
const hash_T hash)
{
#ifdef HT_DEBUG

8
src/nvim/highlight.c
View File

@ -3,9 +3,11 @@
// highlight.c: low level code for UI and syntax highlighting
#include "nvim/vim.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/highlight.h"
#include "nvim/highlight_defs.h"
#include "nvim/lua/executor.h"
#include "nvim/map.h"
#include "nvim/message.h"
#include "nvim/option.h"
@ -13,9 +15,7 @@
#include "nvim/screen.h"
#include "nvim/syntax.h"
#include "nvim/ui.h"
#include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/lua/executor.h"
#include "nvim/vim.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "highlight.c.generated.h"

11
src/nvim/indent.c
View File

@ -7,13 +7,14 @@
#include "nvim/ascii.h"
#include "nvim/assert.h"
#include "nvim/buffer.h"
#include "nvim/change.h"
#include "nvim/indent.h"
#include "nvim/eval.h"
#include "nvim/charset.h"
#include "nvim/cursor.h"
#include "nvim/mark.h"
#include "nvim/eval.h"
#include "nvim/extmark.h"
#include "nvim/indent.h"
#include "nvim/mark.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/misc1.h"
@ -25,7 +26,6 @@
#include "nvim/search.h"
#include "nvim/strings.h"
#include "nvim/undo.h"
#include "nvim/buffer.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
@ -533,8 +533,7 @@ int get_expr_indent(void)
colnr_T save_curswant;
int save_set_curswant;
int save_State;
int use_sandbox = was_set_insecurely(
curwin, (char_u *)"indentexpr", OPT_LOCAL);
int use_sandbox = was_set_insecurely(curwin, (char_u *)"indentexpr", OPT_LOCAL);
// Save and restore cursor position and curswant, in case it was changed
// * via :normal commands.

179
src/nvim/keymap.c
View File

@ -5,16 +5,16 @@
#include <inttypes.h>
#include <limits.h>
#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/keymap.h"
#include "nvim/charset.h"
#include "nvim/memory.h"
#include "nvim/edit.h"
#include "nvim/eval.h"
#include "nvim/keymap.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/strings.h"
#include "nvim/mouse.h"
#include "nvim/strings.h"
#include "nvim/vim.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "keymap.c.generated.h"
@ -51,48 +51,48 @@ static const struct modmasktable {
static char_u modifier_keys_table[] =
{
/* mod mask with modifier without modifier */
MOD_MASK_SHIFT, '&', '9', '@', '1', /* begin */
MOD_MASK_SHIFT, '&', '0', '@', '2', /* cancel */
MOD_MASK_SHIFT, '*', '1', '@', '4', /* command */
MOD_MASK_SHIFT, '*', '2', '@', '5', /* copy */
MOD_MASK_SHIFT, '*', '3', '@', '6', /* create */
MOD_MASK_SHIFT, '*', '4', 'k', 'D', /* delete char */
MOD_MASK_SHIFT, '*', '5', 'k', 'L', /* delete line */
MOD_MASK_SHIFT, '*', '7', '@', '7', /* end */
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', /* end */
MOD_MASK_SHIFT, '*', '9', '@', '9', /* exit */
MOD_MASK_SHIFT, '*', '0', '@', '0', /* find */
MOD_MASK_SHIFT, '#', '1', '%', '1', /* help */
MOD_MASK_SHIFT, '#', '2', 'k', 'h', /* home */
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', /* home */
MOD_MASK_SHIFT, '#', '3', 'k', 'I', /* insert */
MOD_MASK_SHIFT, '#', '4', 'k', 'l', /* left arrow */
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', /* left arrow */
MOD_MASK_SHIFT, '%', 'a', '%', '3', /* message */
MOD_MASK_SHIFT, '%', 'b', '%', '4', /* move */
MOD_MASK_SHIFT, '%', 'c', '%', '5', /* next */
MOD_MASK_SHIFT, '%', 'd', '%', '7', /* options */
MOD_MASK_SHIFT, '%', 'e', '%', '8', /* previous */
MOD_MASK_SHIFT, '%', 'f', '%', '9', /* print */
MOD_MASK_SHIFT, '%', 'g', '%', '0', /* redo */
MOD_MASK_SHIFT, '%', 'h', '&', '3', /* replace */
MOD_MASK_SHIFT, '%', 'i', 'k', 'r', /* right arr. */
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', /* right arr. */
MOD_MASK_SHIFT, '%', 'j', '&', '5', /* resume */
MOD_MASK_SHIFT, '!', '1', '&', '6', /* save */
MOD_MASK_SHIFT, '!', '2', '&', '7', /* suspend */
MOD_MASK_SHIFT, '!', '3', '&', '8', /* undo */
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', /* up arrow */
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', /* down arrow */
// mod mask with modifier without modifier
MOD_MASK_SHIFT, '&', '9', '@', '1', // begin
MOD_MASK_SHIFT, '&', '0', '@', '2', // cancel
MOD_MASK_SHIFT, '*', '1', '@', '4', // command
MOD_MASK_SHIFT, '*', '2', '@', '5', // copy
MOD_MASK_SHIFT, '*', '3', '@', '6', // create
MOD_MASK_SHIFT, '*', '4', 'k', 'D', // delete char
MOD_MASK_SHIFT, '*', '5', 'k', 'L', // delete line
MOD_MASK_SHIFT, '*', '7', '@', '7', // end
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_END, '@', '7', // end
MOD_MASK_SHIFT, '*', '9', '@', '9', // exit
MOD_MASK_SHIFT, '*', '0', '@', '0', // find
MOD_MASK_SHIFT, '#', '1', '%', '1', // help
MOD_MASK_SHIFT, '#', '2', 'k', 'h', // home
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_HOME, 'k', 'h', // home
MOD_MASK_SHIFT, '#', '3', 'k', 'I', // insert
MOD_MASK_SHIFT, '#', '4', 'k', 'l', // left arrow
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_LEFT, 'k', 'l', // left arrow
MOD_MASK_SHIFT, '%', 'a', '%', '3', // message
MOD_MASK_SHIFT, '%', 'b', '%', '4', // move
MOD_MASK_SHIFT, '%', 'c', '%', '5', // next
MOD_MASK_SHIFT, '%', 'd', '%', '7', // options
MOD_MASK_SHIFT, '%', 'e', '%', '8', // previous
MOD_MASK_SHIFT, '%', 'f', '%', '9', // print
MOD_MASK_SHIFT, '%', 'g', '%', '0', // redo
MOD_MASK_SHIFT, '%', 'h', '&', '3', // replace
MOD_MASK_SHIFT, '%', 'i', 'k', 'r', // right arr.
MOD_MASK_CTRL, KS_EXTRA, (int)KE_C_RIGHT, 'k', 'r', // right arr.
MOD_MASK_SHIFT, '%', 'j', '&', '5', // resume
MOD_MASK_SHIFT, '!', '1', '&', '6', // save
MOD_MASK_SHIFT, '!', '2', '&', '7', // suspend
MOD_MASK_SHIFT, '!', '3', '&', '8', // undo
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP, 'k', 'u', // up arrow
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN, 'k', 'd', // down arrow
/* vt100 F1 */
// vt100 F1
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', /* F1 */
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1, 'k', '1', // F1
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',
@ -101,7 +101,7 @@ static char_u modifier_keys_table[] =
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', ';', /* F10 */
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10, 'k', ';', // F10
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11, 'F', '1',
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12, 'F', '2',
@ -133,7 +133,7 @@ static char_u modifier_keys_table[] =
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36, 'F', 'Q',
MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37, 'F', 'R',
/* TAB pseudo code*/
// TAB pseudo code
MOD_MASK_SHIFT, 'k', 'B', KS_EXTRA, (int)KE_TAB,
NUL
@ -397,22 +397,38 @@ 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;
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;
}
@ -432,16 +448,17 @@ char_u *get_special_key_name(int c, int modifiers)
string[0] = '<';
idx = 1;
/* Key that stands for a normal character. */
if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY)
// Key that stands for a normal character.
if (IS_SPECIAL(c) && KEY2TERMCAP0(c) == KS_KEY) {
c = KEY2TERMCAP1(c);
}
/*
* Translate shifted special keys into unshifted keys and set modifier.
* Same for CTRL and ALT modifiers.
*/
if (IS_SPECIAL(c)) {
for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE)
for (i = 0; modifier_keys_table[i] != 0; i += MOD_KEYS_ENTRY_SIZE) {
if (KEY2TERMCAP0(c) == (int)modifier_keys_table[i + 1]
&& (int)KEY2TERMCAP1(c) == (int)modifier_keys_table[i + 2]) {
modifiers |= modifier_keys_table[i];
@ -450,8 +467,9 @@ char_u *get_special_key_name(int c, int modifiers)
break;
}
}
}
/* try to find the key in the special key table */
// try to find the key in the special key table
table_idx = find_special_key_in_table(c);
/*
@ -459,14 +477,13 @@ char_u *get_special_key_name(int c, int modifiers)
* extract modifiers.
*/
if (c > 0
&& (*mb_char2len)(c) == 1
) {
&& (*mb_char2len)(c) == 1) {
if (table_idx < 0
&& (!vim_isprintc(c) || (c & 0x7f) == ' ')
&& (c & 0x80)) {
c &= 0x7f;
modifiers |= MOD_MASK_ALT;
/* try again, to find the un-alted key in the special key table */
// try again, to find the un-alted key in the special key table
table_idx = find_special_key_in_table(c);
}
if (table_idx < 0 && !vim_isprintc(c) && c < ' ') {
@ -475,15 +492,16 @@ char_u *get_special_key_name(int c, int modifiers)
}
}
/* translate the modifier into a string */
for (i = 0; mod_mask_table[i].name != 'A'; i++)
// translate the modifier into a string
for (i = 0; mod_mask_table[i].name != 'A'; i++) {
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)'-';
}
}
if (table_idx < 0) { /* unknown special key, may output t_xx */
if (table_idx < 0) { // unknown special key, may output t_xx
if (IS_SPECIAL(c)) {
string[idx++] = 't';
string[idx++] = '_';
@ -497,10 +515,11 @@ char_u *get_special_key_name(int c, int modifiers)
string[idx++] = (char_u)c;
} else {
s = transchar(c);
while (*s)
while (*s) {
string[idx++] = *s++;
}
}
}
} else { // use name of special key
size_t len = STRLEN(key_names_table[table_idx].name);
@ -525,9 +544,8 @@ char_u *get_special_key_name(int c, int modifiers)
/// @param[in] in_string Inside a double quoted string
///
/// @return Number of characters added to dst, zero for no match.
unsigned int trans_special(const char_u **srcp, const size_t src_len,
char_u *const dst, const bool keycode,
const bool in_string)
unsigned int trans_special(const char_u **srcp, const size_t src_len, char_u *const dst,
const bool keycode, const bool in_string)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
{
int modifiers = 0;
@ -582,9 +600,8 @@ unsigned int special_to_buf(int key, int modifiers, bool keycode, char_u *dst)
/// @param[in] in_string In string, double quote is escaped
///
/// @return Key and modifiers or 0 if there is no match.
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)
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)
FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
{
const char_u *last_dash;
@ -641,7 +658,7 @@ int find_special_key(const char_u **srcp, const size_t src_len, int *const modp,
if (bp <= end && *bp == '>') { // found matching '>'
end_of_name = bp + 1;
/* Which modifiers are given? */
// Which modifiers are given?
modifiers = 0x0;
for (bp = src + 1; bp < last_dash; bp++) {
if (*bp != '-') {
@ -795,13 +812,14 @@ int get_mouse_button(int code, bool *is_click, bool *is_drag)
{
int i;
for (i = 0; mouse_table[i].pseudo_code; i++)
for (i = 0; mouse_table[i].pseudo_code; i++) {
if (code == mouse_table[i].pseudo_code) {
*is_click = mouse_table[i].is_click;
*is_drag = mouse_table[i].is_drag;
return mouse_table[i].button;
}
return 0; /* Shouldn't get here */
}
return 0; // Shouldn't get here
}
/// Replace any terminal code strings with the equivalent internal
@ -829,9 +847,8 @@ int get_mouse_button(int code, bool *is_click, bool *is_drag)
/// @return Pointer to an allocated memory in case of success, "from" in case of
/// failure. In case of success returned pointer is also saved to
/// "bufp".
char_u *replace_termcodes(const char_u *from, const size_t from_len,
char_u **bufp, const bool from_part, const bool do_lt,
const bool special, int cpo_flags)
char_u *replace_termcodes(const char_u *from, const size_t from_len, char_u **bufp,
const bool from_part, const bool do_lt, const bool special, int cpo_flags)
FUNC_ATTR_NONNULL_ALL
{
ssize_t i;

17
src/nvim/log.c
View File

@ -17,9 +17,9 @@
#include "auto/config.h"
#include "nvim/log.h"
#include "nvim/types.h"
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/types.h"
#define LOG_FILE_ENV "NVIM_LOG_FILE"
@ -124,8 +124,8 @@ void log_unlock(void)
/// @param line_num Source line number, or -1
/// @param eol Append linefeed "\n"
/// @param fmt printf-style format string
bool logmsg(int log_level, const char *context, const char *func_name,
int line_num, bool eol, const char *fmt, ...)
bool logmsg(int log_level, const char *context, const char *func_name, int line_num, bool eol,
const char *fmt, ...)
FUNC_ATTR_UNUSED FUNC_ATTR_PRINTF(6, 7)
{
if (log_level < MIN_LOG_LEVEL) {
@ -215,8 +215,7 @@ FILE *open_log_file(void)
}
#ifdef HAVE_EXECINFO_BACKTRACE
void log_callstack_to_file(FILE *log_file, const char *const func_name,
const int line_num)
void log_callstack_to_file(FILE *log_file, const char *const func_name, const int line_num)
{
void *trace[100];
int trace_size = backtrace(trace, ARRAY_SIZE(trace));
@ -268,8 +267,7 @@ end:
#endif
static bool do_log_to_file(FILE *log_file, int log_level, const char *context,
const char *func_name, int line_num, bool eol,
const char *fmt, ...)
const char *func_name, int line_num, bool eol, const char *fmt, ...)
FUNC_ATTR_PRINTF(7, 8)
{
va_list args;
@ -281,9 +279,8 @@ static bool do_log_to_file(FILE *log_file, int log_level, const char *context,
return ret;
}
static bool v_do_log_to_file(FILE *log_file, int log_level,
const char *context, const char *func_name,
int line_num, bool eol, const char *fmt,
static bool v_do_log_to_file(FILE *log_file, int log_level, const char *context,
const char *func_name, int line_num, bool eol, const char *fmt,
va_list args)
{
static const char *log_levels[] = {