IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Remove __ARGS macro. Close #205

Browse Source 
This is a squash of all commits sent to #81.

- Remove unused undef of __ARGS.
- Fix mch_rename declaration.
- Follow changes related to moved & extracted files.
- Properly indent function declarations of getchar.h and quickfix.c.
This commit is contained in:
Nicolas Pierron 2014-03-02 14:11:35 -03:00 committed by Thiago de Arruda
parent 2bd6d44403
commit d9283c4927
105 changed files with 4666 additions and 4712 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/arabic.c
View File

@ -20,25 +20,25 @@
* *
*/ */
static int A_is_a __ARGS((int cur_c)); static int A_is_a(int cur_c);
static int A_is_s __ARGS((int cur_c)); static int A_is_s(int cur_c);
static int A_is_f __ARGS((int cur_c)); static int A_is_f(int cur_c);
static int chg_c_a2s __ARGS((int cur_c)); static int chg_c_a2s(int cur_c);
static int chg_c_a2i __ARGS((int cur_c)); static int chg_c_a2i(int cur_c);
static int chg_c_a2m __ARGS((int cur_c)); static int chg_c_a2m(int cur_c);
static int chg_c_a2f __ARGS((int cur_c)); static int chg_c_a2f(int cur_c);
static int chg_c_i2m __ARGS((int cur_c)); static int chg_c_i2m(int cur_c);
static int chg_c_f2m __ARGS((int cur_c)); static int chg_c_f2m(int cur_c);
static int chg_c_laa2i __ARGS((int hid_c)); static int chg_c_laa2i(int hid_c);
static int chg_c_laa2f __ARGS((int hid_c)); static int chg_c_laa2f(int hid_c);
static int half_shape __ARGS((int c)); static int half_shape(int c);
static int A_firstc_laa __ARGS((int c1, int c)); static int A_firstc_laa(int c1, int c);
static int A_is_harakat __ARGS((int c)); static int A_is_harakat(int c);
static int A_is_iso __ARGS((int c)); static int A_is_iso(int c);
static int A_is_formb __ARGS((int c)); static int A_is_formb(int c);
static int A_is_ok __ARGS((int c)); static int A_is_ok(int c);
static int A_is_valid __ARGS((int c)); static int A_is_valid(int c);
static int A_is_special __ARGS((int c)); static int A_is_special(int c);
/* /*

10
src/blowfish.c
View File

@ -28,11 +28,11 @@ typedef union {
} block8; } block8;
static void bf_e_block __ARGS((UINT32_T *p_xl, UINT32_T *p_xr)); static void bf_e_block(UINT32_T *p_xl, UINT32_T *p_xr);
static void bf_e_cblock __ARGS((char_u *block)); static void bf_e_cblock(char_u *block);
static int bf_check_tables __ARGS((UINT32_T a_ipa[18], UINT32_T a_sbi[4][256], static int bf_check_tables(UINT32_T a_ipa[18], UINT32_T a_sbi[4][256],
UINT32_T val)); UINT32_T val);
static int bf_self_test __ARGS((void)); static int bf_self_test(void);
/* Blowfish code */ /* Blowfish code */
static UINT32_T pax[18]; static UINT32_T pax[18];

16
src/blowfish.h
View File

@ -1,13 +1,13 @@
#ifndef NEOVIM_BLOWFISH_H #ifndef NEOVIM_BLOWFISH_H
#define NEOVIM_BLOWFISH_H #define NEOVIM_BLOWFISH_H
/* blowfish.c */ /* blowfish.c */
void bf_key_init __ARGS((char_u *password, char_u *salt, int salt_len)); void bf_key_init(char_u *password, char_u *salt, int salt_len);
void bf_ofb_init __ARGS((char_u *iv, int iv_len)); void bf_ofb_init(char_u *iv, int iv_len);
void bf_crypt_encode __ARGS((char_u *from, size_t len, char_u *to)); void bf_crypt_encode(char_u *from, size_t len, char_u *to);
void bf_crypt_decode __ARGS((char_u *ptr, long len)); void bf_crypt_decode(char_u *ptr, long len);
void bf_crypt_init_keys __ARGS((char_u *passwd)); void bf_crypt_init_keys(char_u *passwd);
void bf_crypt_save __ARGS((void)); void bf_crypt_save(void);
void bf_crypt_restore __ARGS((void)); void bf_crypt_restore(void);
int blowfish_self_test __ARGS((void)); int blowfish_self_test(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_BLOWFISH_H */ #endif /* NEOVIM_BLOWFISH_H */

36
src/buffer.c
View File

@ -61,26 +61,24 @@
#include "undo.h" #include "undo.h"
#include "window.h" #include "window.h"
static char_u *buflist_match __ARGS((regprog_T *prog, buf_T *buf)); static char_u *buflist_match(regprog_T *prog, buf_T *buf);
# define HAVE_BUFLIST_MATCH # define HAVE_BUFLIST_MATCH
static char_u *fname_match __ARGS((regprog_T *prog, char_u *name)); static char_u *fname_match(regprog_T *prog, char_u *name);
static void buflist_setfpos __ARGS((buf_T *buf, win_T *win, linenr_T lnum, static void buflist_setfpos(buf_T *buf, win_T *win, linenr_T lnum,
colnr_T col, colnr_T col, int copy_options);
int copy_options)); static wininfo_T *find_wininfo(buf_T *buf, int skip_diff_buffer);
static wininfo_T *find_wininfo __ARGS((buf_T *buf, int skip_diff_buffer));
#ifdef UNIX #ifdef UNIX
static buf_T *buflist_findname_stat __ARGS((char_u *ffname, struct stat *st)); static buf_T *buflist_findname_stat(char_u *ffname, struct stat *st);
static int otherfile_buf __ARGS((buf_T *buf, char_u *ffname, struct stat *stp)); static int otherfile_buf(buf_T *buf, char_u *ffname, struct stat *stp);
static int buf_same_ino __ARGS((buf_T *buf, struct stat *stp)); static int buf_same_ino(buf_T *buf, struct stat *stp);
#else #else
static int otherfile_buf __ARGS((buf_T *buf, char_u *ffname)); static int otherfile_buf(buf_T *buf, char_u *ffname);
#endif #endif
static int ti_change __ARGS((char_u *str, char_u **last)); static int ti_change(char_u *str, char_u **last);
static int append_arg_number __ARGS((win_T *wp, char_u *buf, int buflen, static int append_arg_number(win_T *wp, char_u *buf, int buflen, int add_file);
int add_file)); static void free_buffer(buf_T *);
static void free_buffer __ARGS((buf_T *)); static void free_buffer_stuff(buf_T *buf, int free_options);
static void free_buffer_stuff __ARGS((buf_T *buf, int free_options)); static void clear_wininfo(buf_T *buf);
static void clear_wininfo __ARGS((buf_T *buf));
#ifdef UNIX #ifdef UNIX
# define dev_T dev_t # define dev_T dev_t
@ -787,7 +785,7 @@ do_bufdel (
#if defined(FEAT_LISTCMDS) || defined(FEAT_PYTHON) \ #if defined(FEAT_LISTCMDS) || defined(FEAT_PYTHON) \
|| defined(FEAT_PYTHON3) || defined(PROTO) || defined(FEAT_PYTHON3) || defined(PROTO)
static int empty_curbuf __ARGS((int close_others, int forceit, int action)); static int empty_curbuf(int close_others, int forceit, int action);
/* /*
* Make the current buffer empty. * Make the current buffer empty.
@ -2035,7 +2033,7 @@ static void buflist_setfpos(buf_T *buf, win_T *win, linenr_T lnum, colnr_T col,
return; return;
} }
static int wininfo_other_tab_diff __ARGS((wininfo_T *wip)); static int wininfo_other_tab_diff(wininfo_T *wip);
/* /*
* Return TRUE when "wip" has 'diff' set and the diff is only for another tab * Return TRUE when "wip" has 'diff' set and the diff is only for another tab
@ -4107,7 +4105,7 @@ void ex_buffer_all(exarg_T *eap)
} }
static int chk_modeline __ARGS((linenr_T, int)); static int chk_modeline(linenr_T, int);
/* /*
* do_modelines() - process mode lines for the current file * do_modelines() - process mode lines for the current file

150
src/buffer.h
View File

@ -1,84 +1,84 @@
#ifndef NEOVIM_BUFFER_H #ifndef NEOVIM_BUFFER_H
#define NEOVIM_BUFFER_H #define NEOVIM_BUFFER_H
/* buffer.c */ /* buffer.c */
int open_buffer __ARGS((int read_stdin, exarg_T *eap, int flags)); int open_buffer(int read_stdin, exarg_T *eap, int flags);
int buf_valid __ARGS((buf_T *buf)); int buf_valid(buf_T *buf);
void close_buffer __ARGS((win_T *win, buf_T *buf, int action, int abort_if_last)); void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last);
void buf_clear_file __ARGS((buf_T *buf)); void buf_clear_file(buf_T *buf);
void buf_freeall __ARGS((buf_T *buf, int flags)); void buf_freeall(buf_T *buf, int flags);
void goto_buffer __ARGS((exarg_T *eap, int start, int dir, int count)); void goto_buffer(exarg_T *eap, int start, int dir, int count);
void handle_swap_exists __ARGS((buf_T *old_curbuf)); void handle_swap_exists(buf_T *old_curbuf);
char_u *do_bufdel __ARGS((int command, char_u *arg, int addr_count, char_u *do_bufdel(int command, char_u *arg, int addr_count,
int start_bnr, int end_bnr, int start_bnr, int end_bnr,
int forceit)); int forceit);
int do_buffer __ARGS((int action, int start, int dir, int count, int forceit)); int do_buffer(int action, int start, int dir, int count, int forceit);
void set_curbuf __ARGS((buf_T *buf, int action)); void set_curbuf(buf_T *buf, int action);
void enter_buffer __ARGS((buf_T *buf)); void enter_buffer(buf_T *buf);
void do_autochdir __ARGS((void)); void do_autochdir(void);
buf_T *buflist_new __ARGS((char_u *ffname, char_u *sfname, linenr_T lnum, buf_T *buflist_new(char_u *ffname, char_u *sfname, linenr_T lnum,
int flags)); int flags);
void free_buf_options __ARGS((buf_T *buf, int free_p_ff)); void free_buf_options(buf_T *buf, int free_p_ff);
int buflist_getfile __ARGS((int n, linenr_T lnum, int options, int forceit)); int buflist_getfile(int n, linenr_T lnum, int options, int forceit);
void buflist_getfpos __ARGS((void)); void buflist_getfpos(void);
buf_T *buflist_findname_exp __ARGS((char_u *fname)); buf_T *buflist_findname_exp(char_u *fname);
buf_T *buflist_findname __ARGS((char_u *ffname)); buf_T *buflist_findname(char_u *ffname);
int buflist_findpat __ARGS((char_u *pattern, char_u *pattern_end, int unlisted, int buflist_findpat(char_u *pattern, char_u *pattern_end, int unlisted,
int diffmode, int diffmode,
int curtab_only)); int curtab_only);
int ExpandBufnames __ARGS((char_u *pat, int *num_file, char_u ***file, int ExpandBufnames(char_u *pat, int *num_file, char_u ***file,
int options)); int options);
buf_T *buflist_findnr __ARGS((int nr)); buf_T *buflist_findnr(int nr);
char_u *buflist_nr2name __ARGS((int n, int fullname, int helptail)); char_u *buflist_nr2name(int n, int fullname, int helptail);
void get_winopts __ARGS((buf_T *buf)); void get_winopts(buf_T *buf);
pos_T *buflist_findfpos __ARGS((buf_T *buf)); pos_T *buflist_findfpos(buf_T *buf);
linenr_T buflist_findlnum __ARGS((buf_T *buf)); linenr_T buflist_findlnum(buf_T *buf);
void buflist_list __ARGS((exarg_T *eap)); void buflist_list(exarg_T *eap);
int buflist_name_nr __ARGS((int fnum, char_u **fname, linenr_T *lnum)); int buflist_name_nr(int fnum, char_u **fname, linenr_T *lnum);
int setfname __ARGS((buf_T *buf, char_u *ffname, char_u *sfname, int message)); int setfname(buf_T *buf, char_u *ffname, char_u *sfname, int message);
void buf_set_name __ARGS((int fnum, char_u *name)); void buf_set_name(int fnum, char_u *name);
void buf_name_changed __ARGS((buf_T *buf)); void buf_name_changed(buf_T *buf);
buf_T *setaltfname __ARGS((char_u *ffname, char_u *sfname, linenr_T lnum)); buf_T *setaltfname(char_u *ffname, char_u *sfname, linenr_T lnum);
char_u *getaltfname __ARGS((int errmsg)); char_u *getaltfname(int errmsg);
int buflist_add __ARGS((char_u *fname, int flags)); int buflist_add(char_u *fname, int flags);
void buflist_slash_adjust __ARGS((void)); void buflist_slash_adjust(void);
void buflist_altfpos __ARGS((win_T *win)); void buflist_altfpos(win_T *win);
int otherfile __ARGS((char_u *ffname)); int otherfile(char_u *ffname);
void buf_setino __ARGS((buf_T *buf)); void buf_setino(buf_T *buf);
void fileinfo __ARGS((int fullname, int shorthelp, int dont_truncate)); void fileinfo(int fullname, int shorthelp, int dont_truncate);
void col_print __ARGS((char_u *buf, size_t buflen, int col, int vcol)); void col_print(char_u *buf, size_t buflen, int col, int vcol);
void maketitle __ARGS((void)); void maketitle(void);
void resettitle __ARGS((void)); void resettitle(void);
void free_titles __ARGS((void)); void free_titles(void);
int build_stl_str_hl __ARGS((win_T *wp, char_u *out, size_t outlen, char_u *fmt, int build_stl_str_hl(win_T *wp, char_u *out, size_t outlen, char_u *fmt,
int use_sandbox, int fillchar, int maxwidth, int use_sandbox, int fillchar, int maxwidth,
struct stl_hlrec *hltab, struct stl_hlrec *hltab,
struct stl_hlrec *tabtab)); struct stl_hlrec *tabtab);
void get_rel_pos __ARGS((win_T *wp, char_u *buf, int buflen)); void get_rel_pos(win_T *wp, char_u *buf, int buflen);
char_u *fix_fname __ARGS((char_u *fname)); char_u *fix_fname(char_u *fname);
void fname_expand __ARGS((buf_T *buf, char_u **ffname, char_u **sfname)); void fname_expand(buf_T *buf, char_u **ffname, char_u **sfname);
char_u *alist_name __ARGS((aentry_T *aep)); char_u *alist_name(aentry_T *aep);
void do_arg_all __ARGS((int count, int forceit, int keep_tabs)); void do_arg_all(int count, int forceit, int keep_tabs);
void ex_buffer_all __ARGS((exarg_T *eap)); void ex_buffer_all(exarg_T *eap);
void do_modelines __ARGS((int flags)); void do_modelines(int flags);
int read_viminfo_bufferlist __ARGS((vir_T *virp, int writing)); int read_viminfo_bufferlist(vir_T *virp, int writing);
void write_viminfo_bufferlist __ARGS((FILE *fp)); void write_viminfo_bufferlist(FILE *fp);
char_u *buf_spname __ARGS((buf_T *buf)); char_u *buf_spname(buf_T *buf);
int find_win_for_buf __ARGS((buf_T *buf, win_T **wp, tabpage_T **tp)); int find_win_for_buf(buf_T *buf, win_T **wp, tabpage_T **tp);
void buf_addsign __ARGS((buf_T *buf, int id, linenr_T lnum, int typenr)); void buf_addsign(buf_T *buf, int id, linenr_T lnum, int typenr);
linenr_T buf_change_sign_type __ARGS((buf_T *buf, int markId, int typenr)); linenr_T buf_change_sign_type(buf_T *buf, int markId, int typenr);
int buf_getsigntype __ARGS((buf_T *buf, linenr_T lnum, int type)); int buf_getsigntype(buf_T *buf, linenr_T lnum, int type);
linenr_T buf_delsign __ARGS((buf_T *buf, int id)); linenr_T buf_delsign(buf_T *buf, int id);
int buf_findsign __ARGS((buf_T *buf, int id)); int buf_findsign(buf_T *buf, int id);
int buf_findsign_id __ARGS((buf_T *buf, linenr_T lnum)); int buf_findsign_id(buf_T *buf, linenr_T lnum);
int buf_findsigntype_id __ARGS((buf_T *buf, linenr_T lnum, int typenr)); int buf_findsigntype_id(buf_T *buf, linenr_T lnum, int typenr);
int buf_signcount __ARGS((buf_T *buf, linenr_T lnum)); int buf_signcount(buf_T *buf, linenr_T lnum);
void buf_delete_signs __ARGS((buf_T *buf)); void buf_delete_signs(buf_T *buf);
void buf_delete_all_signs __ARGS((void)); void buf_delete_all_signs(void);
void sign_list_placed __ARGS((buf_T *rbuf)); void sign_list_placed(buf_T *rbuf);
void sign_mark_adjust __ARGS((linenr_T line1, linenr_T line2, long amount, void sign_mark_adjust(linenr_T line1, linenr_T line2, long amount,
long amount_after)); long amount_after);
void set_buflisted __ARGS((int on)); void set_buflisted(int on);
int buf_contents_changed __ARGS((buf_T *buf)); int buf_contents_changed(buf_T *buf);
void wipe_buffer __ARGS((buf_T *buf, int aucmd)); void wipe_buffer(buf_T *buf, int aucmd);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_BUFFER_H */ #endif /* NEOVIM_BUFFER_H */

8
src/charset.c
View File

@ -18,15 +18,15 @@
#include "move.h" #include "move.h"
#include "os_unix.h" #include "os_unix.h"
static int win_chartabsize __ARGS((win_T *wp, char_u *p, colnr_T col)); static int win_chartabsize(win_T *wp, char_u *p, colnr_T col);
# if defined(HAVE_WCHAR_H) # if defined(HAVE_WCHAR_H)
# include <wchar.h> /* for towupper() and towlower() */ # include <wchar.h> /* for towupper() and towlower() */
# endif # endif
static int win_nolbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, static int win_nolbr_chartabsize(win_T *wp, char_u *s, colnr_T col,
int *headp)); int *headp);
static unsigned nr2hex __ARGS((unsigned c)); static unsigned nr2hex(unsigned c);
static int chartab_initialized = FALSE; static int chartab_initialized = FALSE;

122
src/charset.h
View File

@ -1,67 +1,67 @@
#ifndef NEOVIM_CHARSET_H #ifndef NEOVIM_CHARSET_H
#define NEOVIM_CHARSET_H #define NEOVIM_CHARSET_H
/* charset.c */ /* charset.c */
int init_chartab __ARGS((void)); int init_chartab(void);
int buf_init_chartab __ARGS((buf_T *buf, int global)); int buf_init_chartab(buf_T *buf, int global);
void trans_characters __ARGS((char_u *buf, int bufsize)); void trans_characters(char_u *buf, int bufsize);
char_u *transstr __ARGS((char_u *s)); char_u *transstr(char_u *s);
char_u *str_foldcase __ARGS((char_u *str, int orglen, char_u *buf, int buflen)); char_u *str_foldcase(char_u *str, int orglen, char_u *buf, int buflen);
char_u *transchar __ARGS((int c)); char_u *transchar(int c);
char_u *transchar_byte __ARGS((int c)); char_u *transchar_byte(int c);
void transchar_nonprint __ARGS((char_u *buf, int c)); void transchar_nonprint(char_u *buf, int c);
void transchar_hex __ARGS((char_u *buf, int c)); void transchar_hex(char_u *buf, int c);
int byte2cells __ARGS((int b)); int byte2cells(int b);
int char2cells __ARGS((int c)); int char2cells(int c);
int ptr2cells __ARGS((char_u *p)); int ptr2cells(char_u *p);
int vim_strsize __ARGS((char_u *s)); int vim_strsize(char_u *s);
int vim_strnsize __ARGS((char_u *s, int len)); int vim_strnsize(char_u *s, int len);
int chartabsize __ARGS((char_u *p, colnr_T col)); int chartabsize(char_u *p, colnr_T col);
int linetabsize __ARGS((char_u *s)); int linetabsize(char_u *s);
int linetabsize_col __ARGS((int startcol, char_u *s)); int linetabsize_col(int startcol, char_u *s);
int win_linetabsize __ARGS((win_T *wp, char_u *p, colnr_T len)); int win_linetabsize(win_T *wp, char_u *p, colnr_T len);
int vim_isIDc __ARGS((int c)); int vim_isIDc(int c);
int vim_iswordc __ARGS((int c)); int vim_iswordc(int c);
int vim_iswordc_buf __ARGS((int c, buf_T *buf)); int vim_iswordc_buf(int c, buf_T *buf);
int vim_iswordp __ARGS((char_u *p)); int vim_iswordp(char_u *p);
int vim_iswordp_buf __ARGS((char_u *p, buf_T *buf)); int vim_iswordp_buf(char_u *p, buf_T *buf);
int vim_isfilec __ARGS((int c)); int vim_isfilec(int c);
int vim_isfilec_or_wc __ARGS((int c)); int vim_isfilec_or_wc(int c);
int vim_isprintc __ARGS((int c)); int vim_isprintc(int c);
int vim_isprintc_strict __ARGS((int c)); int vim_isprintc_strict(int c);
int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col)); int lbr_chartabsize(unsigned char *s, colnr_T col);
int lbr_chartabsize_adv __ARGS((char_u **s, colnr_T col)); int lbr_chartabsize_adv(char_u **s, colnr_T col);
int win_lbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp)); int win_lbr_chartabsize(win_T *wp, char_u *s, colnr_T col, int *headp);
int in_win_border __ARGS((win_T *wp, colnr_T vcol)); int in_win_border(win_T *wp, colnr_T vcol);
void getvcol __ARGS((win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor,
colnr_T *end)); colnr_T *end);
colnr_T getvcol_nolist __ARGS((pos_T *posp)); colnr_T getvcol_nolist(pos_T *posp);
void getvvcol __ARGS((win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor,
colnr_T *end)); colnr_T *end);
void getvcols __ARGS((win_T *wp, pos_T *pos1, pos_T *pos2, colnr_T *left, void getvcols(win_T *wp, pos_T *pos1, pos_T *pos2, colnr_T *left,
colnr_T *right)); colnr_T *right);
char_u *skipwhite __ARGS((char_u *q)); char_u *skipwhite(char_u *q);
char_u *skipdigits __ARGS((char_u *q)); char_u *skipdigits(char_u *q);
char_u *skiphex __ARGS((char_u *q)); char_u *skiphex(char_u *q);
char_u *skiptodigit __ARGS((char_u *q)); char_u *skiptodigit(char_u *q);
char_u *skiptohex __ARGS((char_u *q)); char_u *skiptohex(char_u *q);
int vim_isdigit __ARGS((int c)); int vim_isdigit(int c);
int vim_isxdigit __ARGS((int c)); int vim_isxdigit(int c);
int vim_islower __ARGS((int c)); int vim_islower(int c);
int vim_isupper __ARGS((int c)); int vim_isupper(int c);
int vim_toupper __ARGS((int c)); int vim_toupper(int c);
int vim_tolower __ARGS((int c)); int vim_tolower(int c);
char_u *skiptowhite __ARGS((char_u *p)); char_u *skiptowhite(char_u *p);
char_u *skiptowhite_esc __ARGS((char_u *p)); char_u *skiptowhite_esc(char_u *p);
long getdigits __ARGS((char_u **pp)); long getdigits(char_u **pp);
int vim_isblankline __ARGS((char_u *lbuf)); int vim_isblankline(char_u *lbuf);
void vim_str2nr __ARGS((char_u *start, int *hexp, int *len, int dooct, void vim_str2nr(char_u *start, int *hexp, int *len, int dooct,
int dohex, long *nptr, int dohex, long *nptr,
unsigned long *unptr)); unsigned long *unptr);
int hex2nr __ARGS((int c)); int hex2nr(int c);
int hexhex2nr __ARGS((char_u *p)); int hexhex2nr(char_u *p);
int rem_backslash __ARGS((char_u *str)); int rem_backslash(char_u *str);
void backslash_halve __ARGS((char_u *p)); void backslash_halve(char_u *p);
char_u *backslash_halve_save __ARGS((char_u *p)); char_u *backslash_halve_save(char_u *p);
void ebcdic2ascii __ARGS((char_u *buffer, int len)); void ebcdic2ascii(char_u *buffer, int len);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_CHARSET_H */ #endif /* NEOVIM_CHARSET_H */

33
src/diff.c
View File

@ -49,24 +49,23 @@ static int diff_flags = DIFF_FILLER;
static int diff_a_works = MAYBE; /* TRUE when "diff -a" works, FALSE when it static int diff_a_works = MAYBE; /* TRUE when "diff -a" works, FALSE when it
doesn't work, MAYBE when not checked yet */ doesn't work, MAYBE when not checked yet */
static int diff_buf_idx __ARGS((buf_T *buf)); static int diff_buf_idx(buf_T *buf);
static int diff_buf_idx_tp __ARGS((buf_T *buf, tabpage_T *tp)); static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp);
static void diff_mark_adjust_tp __ARGS((tabpage_T *tp, int idx, linenr_T line1, static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
linenr_T line2, long amount, linenr_T line2, long amount,
long amount_after)); long amount_after);
static void diff_check_unchanged __ARGS((tabpage_T *tp, diff_T *dp)); static void diff_check_unchanged(tabpage_T *tp, diff_T *dp);
static int diff_check_sanity __ARGS((tabpage_T *tp, diff_T *dp)); static int diff_check_sanity(tabpage_T *tp, diff_T *dp);
static void diff_redraw __ARGS((int dofold)); static void diff_redraw(int dofold);
static int diff_write __ARGS((buf_T *buf, char_u *fname)); static int diff_write(buf_T *buf, char_u *fname);
static void diff_file __ARGS((char_u *tmp_orig, char_u *tmp_new, static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff);
char_u *tmp_diff)); static int diff_equal_entry(diff_T *dp, int idx1, int idx2);
static int diff_equal_entry __ARGS((diff_T *dp, int idx1, int idx2)); static int diff_cmp(char_u *s1, char_u *s2);
static int diff_cmp __ARGS((char_u *s1, char_u *s2)); static void diff_fold_update(diff_T *dp, int skip_idx);
static void diff_fold_update __ARGS((diff_T *dp, int skip_idx)); static void diff_read(int idx_orig, int idx_new, char_u *fname);
static void diff_read __ARGS((int idx_orig, int idx_new, char_u *fname)); static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig,
static void diff_copy_entry __ARGS((diff_T *dprev, diff_T *dp, int idx_orig, int idx_new);
int idx_new)); static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp);
static diff_T *diff_alloc_new __ARGS((tabpage_T *tp, diff_T *dprev, diff_T *dp));
#ifndef USE_CR #ifndef USE_CR
# define tag_fgets vim_fgets # define tag_fgets vim_fgets

54
src/diff.h
View File

@ -1,33 +1,33 @@
#ifndef NEOVIM_DIFF_H #ifndef NEOVIM_DIFF_H
#define NEOVIM_DIFF_H #define NEOVIM_DIFF_H
/* diff.c */ /* diff.c */
void diff_buf_delete __ARGS((buf_T *buf)); void diff_buf_delete(buf_T *buf);
void diff_buf_adjust __ARGS((win_T *win)); void diff_buf_adjust(win_T *win);
void diff_buf_add __ARGS((buf_T *buf)); void diff_buf_add(buf_T *buf);
void diff_invalidate __ARGS((buf_T *buf)); void diff_invalidate(buf_T *buf);
void diff_mark_adjust __ARGS((linenr_T line1, linenr_T line2, long amount, void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount,
long amount_after)); long amount_after);
void ex_diffupdate __ARGS((exarg_T *eap)); void ex_diffupdate(exarg_T *eap);
void ex_diffpatch __ARGS((exarg_T *eap)); void ex_diffpatch(exarg_T *eap);
void ex_diffsplit __ARGS((exarg_T *eap)); void ex_diffsplit(exarg_T *eap);
void ex_diffthis __ARGS((exarg_T *eap)); void ex_diffthis(exarg_T *eap);
void diff_win_options __ARGS((win_T *wp, int addbuf)); void diff_win_options(win_T *wp, int addbuf);
void ex_diffoff __ARGS((exarg_T *eap)); void ex_diffoff(exarg_T *eap);
void diff_clear __ARGS((tabpage_T *tp)); void diff_clear(tabpage_T *tp);
int diff_check __ARGS((win_T *wp, linenr_T lnum)); int diff_check(win_T *wp, linenr_T lnum);
int diff_check_fill __ARGS((win_T *wp, linenr_T lnum)); int diff_check_fill(win_T *wp, linenr_T lnum);
void diff_set_topline __ARGS((win_T *fromwin, win_T *towin)); void diff_set_topline(win_T *fromwin, win_T *towin);
int diffopt_changed __ARGS((void)); int diffopt_changed(void);
int diffopt_horizontal __ARGS((void)); int diffopt_horizontal(void);
int diff_find_change __ARGS((win_T *wp, linenr_T lnum, int *startp, int *endp)); int diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp);
int diff_infold __ARGS((win_T *wp, linenr_T lnum)); int diff_infold(win_T *wp, linenr_T lnum);
void nv_diffgetput __ARGS((int put)); void nv_diffgetput(int put);
void ex_diffgetput __ARGS((exarg_T *eap)); void ex_diffgetput(exarg_T *eap);
int diff_mode_buf __ARGS((buf_T *buf)); int diff_mode_buf(buf_T *buf);
int diff_move_to __ARGS((int dir, long count)); int diff_move_to(int dir, long count);
linenr_T diff_get_corresponding_line __ARGS((buf_T *buf1, linenr_T lnum1, linenr_T diff_get_corresponding_line(buf_T *buf1, linenr_T lnum1,
buf_T *buf2, buf_T *buf2,
linenr_T lnum3)); linenr_T lnum3);
linenr_T diff_lnum_win __ARGS((linenr_T lnum, win_T *wp)); linenr_T diff_lnum_win(linenr_T lnum, win_T *wp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_DIFF_H */ #endif /* NEOVIM_DIFF_H */

6
src/digraph.c
View File

@ -34,8 +34,8 @@ typedef struct digraph {
result_T result; result_T result;
} digr_T; } digr_T;
static int getexactdigraph __ARGS((int, int, int)); static int getexactdigraph(int, int, int);
static void printdigraph __ARGS((digr_T *)); static void printdigraph(digr_T *);
/* digraphs added by the user */ /* digraphs added by the user */
static garray_T user_digraphs = {0, 0, (int)sizeof(digr_T), 10, NULL}; static garray_T user_digraphs = {0, 0, (int)sizeof(digr_T), 10, NULL};
@ -1922,7 +1922,7 @@ typedef struct {
#define KMAP_MAXLEN 20 /* maximum length of "from" or "to" */ #define KMAP_MAXLEN 20 /* maximum length of "from" or "to" */
static void keymap_unload __ARGS((void)); static void keymap_unload(void);
/* /*
* Set up key mapping tables for the 'keymap' option. * Set up key mapping tables for the 'keymap' option.

14
src/digraph.h
View File

@ -1,12 +1,12 @@
#ifndef NEOVIM_DIGRAPH_H #ifndef NEOVIM_DIGRAPH_H
#define NEOVIM_DIGRAPH_H #define NEOVIM_DIGRAPH_H
/* digraph.c */ /* digraph.c */
int do_digraph __ARGS((int c)); int do_digraph(int c);
int get_digraph __ARGS((int cmdline)); int get_digraph(int cmdline);
int getdigraph __ARGS((int char1, int char2, int meta_char)); int getdigraph(int char1, int char2, int meta_char);
void putdigraph __ARGS((char_u *str)); void putdigraph(char_u *str);
void listdigraphs __ARGS((void)); void listdigraphs(void);
char_u *keymap_init __ARGS((void)); char_u *keymap_init(void);
void ex_loadkeymap __ARGS((exarg_T *eap)); void ex_loadkeymap(exarg_T *eap);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_DIGRAPH_H */ #endif /* NEOVIM_DIGRAPH_H */

198
src/edit.c
View File

@ -165,113 +165,113 @@ static expand_T compl_xp;
static int compl_opt_refresh_always = FALSE; static int compl_opt_refresh_always = FALSE;
static void ins_ctrl_x __ARGS((void)); static void ins_ctrl_x(void);
static int has_compl_option __ARGS((int dict_opt)); static int has_compl_option(int dict_opt);
static int ins_compl_accept_char __ARGS((int c)); static int ins_compl_accept_char(int c);
static int ins_compl_add __ARGS((char_u *str, int len, int icase, char_u *fname, static int ins_compl_add(char_u *str, int len, int icase, char_u *fname,
char_u **cptext, int cdir, int flags, char_u **cptext, int cdir, int flags,
int adup)); int adup);
static int ins_compl_equal __ARGS((compl_T *match, char_u *str, int len)); static int ins_compl_equal(compl_T *match, char_u *str, int len);
static void ins_compl_longest_match __ARGS((compl_T *match)); static void ins_compl_longest_match(compl_T *match);
static void ins_compl_add_matches __ARGS((int num_matches, char_u **matches, static void ins_compl_add_matches(int num_matches, char_u **matches,
int icase)); int icase);
static int ins_compl_make_cyclic __ARGS((void)); static int ins_compl_make_cyclic(void);
static void ins_compl_upd_pum __ARGS((void)); static void ins_compl_upd_pum(void);
static void ins_compl_del_pum __ARGS((void)); static void ins_compl_del_pum(void);
static int pum_wanted __ARGS((void)); static int pum_wanted(void);
static int pum_enough_matches __ARGS((void)); static int pum_enough_matches(void);
static void ins_compl_dictionaries __ARGS((char_u *dict, char_u *pat, int flags, static void ins_compl_dictionaries(char_u *dict, char_u *pat, int flags,
int thesaurus)); int thesaurus);
static void ins_compl_files __ARGS((int count, char_u **files, int thesaurus, static void ins_compl_files(int count, char_u **files, int thesaurus,
int flags, regmatch_T *regmatch, char_u * int flags, regmatch_T *regmatch, char_u *
buf, buf,
int *dir)); int *dir);
static char_u *find_line_end __ARGS((char_u *ptr)); static char_u *find_line_end(char_u *ptr);
static void ins_compl_free __ARGS((void)); static void ins_compl_free(void);
static void ins_compl_clear __ARGS((void)); static void ins_compl_clear(void);
static int ins_compl_bs __ARGS((void)); static int ins_compl_bs(void);
static int ins_compl_need_restart __ARGS((void)); static int ins_compl_need_restart(void);
static void ins_compl_new_leader __ARGS((void)); static void ins_compl_new_leader(void);
static void ins_compl_addleader __ARGS((int c)); static void ins_compl_addleader(int c);
static int ins_compl_len __ARGS((void)); static int ins_compl_len(void);
static void ins_compl_restart __ARGS((void)); static void ins_compl_restart(void);
static void ins_compl_set_original_text __ARGS((char_u *str)); static void ins_compl_set_original_text(char_u *str);
static void ins_compl_addfrommatch __ARGS((void)); static void ins_compl_addfrommatch(void);
static int ins_compl_prep __ARGS((int c)); static int ins_compl_prep(int c);
static void ins_compl_fixRedoBufForLeader __ARGS((char_u *ptr_arg)); static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg);
static buf_T *ins_compl_next_buf __ARGS((buf_T *buf, int flag)); static buf_T *ins_compl_next_buf(buf_T *buf, int flag);
static void ins_compl_add_list __ARGS((list_T *list)); static void ins_compl_add_list(list_T *list);
static void ins_compl_add_dict __ARGS((dict_T *dict)); static void ins_compl_add_dict(dict_T *dict);
static int ins_compl_get_exp __ARGS((pos_T *ini)); static int ins_compl_get_exp(pos_T *ini);
static void ins_compl_delete __ARGS((void)); static void ins_compl_delete(void);
static void ins_compl_insert __ARGS((void)); static void ins_compl_insert(void);
static int ins_compl_next __ARGS((int allow_get_expansion, int count, static int ins_compl_next(int allow_get_expansion, int count,
int insert_match)); int insert_match);
static int ins_compl_key2dir __ARGS((int c)); static int ins_compl_key2dir(int c);
static int ins_compl_pum_key __ARGS((int c)); static int ins_compl_pum_key(int c);
static int ins_compl_key2count __ARGS((int c)); static int ins_compl_key2count(int c);
static int ins_compl_use_match __ARGS((int c)); static int ins_compl_use_match(int c);
static int ins_complete __ARGS((int c)); static int ins_complete(int c);
static unsigned quote_meta __ARGS((char_u *dest, char_u *str, int len)); static unsigned quote_meta(char_u *dest, char_u *str, int len);
#define BACKSPACE_CHAR 1 #define BACKSPACE_CHAR 1
#define BACKSPACE_WORD 2 #define BACKSPACE_WORD 2
#define BACKSPACE_WORD_NOT_SPACE 3 #define BACKSPACE_WORD_NOT_SPACE 3
#define BACKSPACE_LINE 4 #define BACKSPACE_LINE 4
static void ins_redraw __ARGS((int ready)); static void ins_redraw(int ready);
static void ins_ctrl_v __ARGS((void)); static void ins_ctrl_v(void);
static void undisplay_dollar __ARGS((void)); static void undisplay_dollar(void);
static void insert_special __ARGS((int, int, int)); static void insert_special(int, int, int);
static void internal_format __ARGS((int textwidth, int second_indent, int flags, static void internal_format(int textwidth, int second_indent, int flags,
int format_only, int format_only,
int c)); int c);
static void check_auto_format __ARGS((int)); static void check_auto_format(int);
static void redo_literal __ARGS((int c)); static void redo_literal(int c);
static void start_arrow __ARGS((pos_T *end_insert_pos)); static void start_arrow(pos_T *end_insert_pos);
static void check_spell_redraw __ARGS((void)); static void check_spell_redraw(void);
static void spell_back_to_badword __ARGS((void)); static void spell_back_to_badword(void);
static int spell_bad_len = 0; /* length of located bad word */ static int spell_bad_len = 0; /* length of located bad word */
static void stop_insert __ARGS((pos_T *end_insert_pos, int esc, int nomove)); static void stop_insert(pos_T *end_insert_pos, int esc, int nomove);
static int echeck_abbr __ARGS((int)); static int echeck_abbr(int);
static int replace_pop __ARGS((void)); static int replace_pop(void);
static void replace_join __ARGS((int off)); static void replace_join(int off);
static void replace_pop_ins __ARGS((void)); static void replace_pop_ins(void);
static void mb_replace_pop_ins __ARGS((int cc)); static void mb_replace_pop_ins(int cc);
static void replace_flush __ARGS((void)); static void replace_flush(void);
static void replace_do_bs __ARGS((int limit_col)); static void replace_do_bs(int limit_col);
static int del_char_after_col __ARGS((int limit_col)); static int del_char_after_col(int limit_col);
static int cindent_on __ARGS((void)); static int cindent_on(void);
static void ins_reg __ARGS((void)); static void ins_reg(void);
static void ins_ctrl_g __ARGS((void)); static void ins_ctrl_g(void);
static void ins_ctrl_hat __ARGS((void)); static void ins_ctrl_hat(void);
static int ins_esc __ARGS((long *count, int cmdchar, int nomove)); static int ins_esc(long *count, int cmdchar, int nomove);
static void ins_ctrl_ __ARGS((void)); static void ins_ctrl_(void);
static int ins_start_select __ARGS((int c)); static int ins_start_select(int c);
static void ins_insert __ARGS((int replaceState)); static void ins_insert(int replaceState);
static void ins_ctrl_o __ARGS((void)); static void ins_ctrl_o(void);
static void ins_shift __ARGS((int c, int lastc)); static void ins_shift(int c, int lastc);
static void ins_del __ARGS((void)); static void ins_del(void);
static int ins_bs __ARGS((int c, int mode, int *inserted_space_p)); static int ins_bs(int c, int mode, int *inserted_space_p);
static void ins_mouse __ARGS((int c)); static void ins_mouse(int c);
static void ins_mousescroll __ARGS((int dir)); static void ins_mousescroll(int dir);
static void ins_left __ARGS((void)); static void ins_left(void);
static void ins_home __ARGS((int c)); static void ins_home(int c);
static void ins_end __ARGS((int c)); static void ins_end(int c);
static void ins_s_left __ARGS((void)); static void ins_s_left(void);
static void ins_right __ARGS((void)); static void ins_right(void);
static void ins_s_right __ARGS((void)); static void ins_s_right(void);
static void ins_up __ARGS((int startcol)); static void ins_up(int startcol);
static void ins_pageup __ARGS((void)); static void ins_pageup(void);
static void ins_down __ARGS((int startcol)); static void ins_down(int startcol);
static void ins_pagedown __ARGS((void)); static void ins_pagedown(void);
static int ins_tab __ARGS((void)); static int ins_tab(void);
static int ins_eol __ARGS((int c)); static int ins_eol(int c);
static int ins_digraph __ARGS((void)); static int ins_digraph(void);
static int ins_ctrl_ey __ARGS((int tc)); static int ins_ctrl_ey(int tc);
static void ins_try_si __ARGS((int c)); static void ins_try_si(int c);
static colnr_T get_nolist_virtcol __ARGS((void)); static colnr_T get_nolist_virtcol(void);
static char_u *do_insert_char_pre __ARGS((int c)); static char_u *do_insert_char_pre(int c);
static colnr_T Insstart_textlen; /* length of line when insert started */ static colnr_T Insstart_textlen; /* length of line when insert started */
static colnr_T Insstart_blank_vcol; /* vcol for first inserted blank */ static colnr_T Insstart_blank_vcol; /* vcol for first inserted blank */
@ -3337,7 +3337,7 @@ static buf_T *ins_compl_next_buf(buf_T *buf, int flag)
return buf; return buf;
} }
static void expand_by_function __ARGS((int type, char_u *base)); static void expand_by_function(int type, char_u *base);
/* /*
* Execute user defined complete function 'completefunc' or 'omnifunc', and * Execute user defined complete function 'completefunc' or 'omnifunc', and
@ -6479,7 +6479,7 @@ static int cindent_on(void) {
*/ */
void fixthisline(get_the_indent) void fixthisline(get_the_indent)
int (*get_the_indent)__ARGS((void)); int (*get_the_indent)(void);
{ {
change_indent(INDENT_SET, get_the_indent(), FALSE, 0, TRUE); change_indent(INDENT_SET, get_the_indent(), FALSE, 0, TRUE);
if (linewhite(curwin->w_cursor.lnum)) if (linewhite(curwin->w_cursor.lnum))
@ -7267,7 +7267,7 @@ static void ins_del(void) {
AppendCharToRedobuff(K_DEL); AppendCharToRedobuff(K_DEL);
} }
static void ins_bs_one __ARGS((colnr_T *vcolp)); static void ins_bs_one(colnr_T *vcolp);
/* /*
* Delete one character for ins_bs(). * Delete one character for ins_bs().

88
src/edit.h
View File

@ -1,49 +1,49 @@
#ifndef NEOVIM_EDIT_H #ifndef NEOVIM_EDIT_H
#define NEOVIM_EDIT_H #define NEOVIM_EDIT_H
/* edit.c */ /* edit.c */
int edit __ARGS((int cmdchar, int startln, long count)); int edit(int cmdchar, int startln, long count);
void edit_putchar __ARGS((int c, int highlight)); void edit_putchar(int c, int highlight);
void edit_unputchar __ARGS((void)); void edit_unputchar(void);
void display_dollar __ARGS((colnr_T col)); void display_dollar(colnr_T col);
void change_indent __ARGS((int type, int amount, int round, int replaced, void change_indent(int type, int amount, int round, int replaced,
int call_changed_bytes)); int call_changed_bytes);
void truncate_spaces __ARGS((char_u *line)); void truncate_spaces(char_u *line);
void backspace_until_column __ARGS((int col)); void backspace_until_column(int col);
int vim_is_ctrl_x_key __ARGS((int c)); int vim_is_ctrl_x_key(int c);
int ins_compl_add_infercase __ARGS((char_u *str, int len, int icase, char_u * int ins_compl_add_infercase(char_u *str, int len, int icase,
fname, int dir, char_u *fname, int dir,
int flags)); int flags);
void set_completion __ARGS((colnr_T startcol, list_T *list)); void set_completion(colnr_T startcol, list_T *list);
void ins_compl_show_pum __ARGS((void)); void ins_compl_show_pum(void);
char_u *find_word_start __ARGS((char_u *ptr)); char_u *find_word_start(char_u *ptr);
char_u *find_word_end __ARGS((char_u *ptr)); char_u *find_word_end(char_u *ptr);
int ins_compl_active __ARGS((void)); int ins_compl_active(void);
int ins_compl_add_tv __ARGS((typval_T *tv, int dir)); int ins_compl_add_tv(typval_T *tv, int dir);
void ins_compl_check_keys __ARGS((int frequency)); void ins_compl_check_keys(int frequency);
int get_literal __ARGS((void)); int get_literal(void);
void insertchar __ARGS((int c, int flags, int second_indent)); void insertchar(int c, int flags, int second_indent);
void auto_format __ARGS((int trailblank, int prev_line)); void auto_format(int trailblank, int prev_line);
int comp_textwidth __ARGS((int ff)); int comp_textwidth(int ff);
int stop_arrow __ARGS((void)); int stop_arrow(void);
void set_last_insert __ARGS((int c)); void set_last_insert(int c);
void free_last_insert __ARGS((void)); void free_last_insert(void);
char_u *add_char2buf __ARGS((int c, char_u *s)); char_u *add_char2buf(int c, char_u *s);
void beginline __ARGS((int flags)); void beginline(int flags);
int oneright __ARGS((void)); int oneright(void);
int oneleft __ARGS((void)); int oneleft(void);
int cursor_up __ARGS((long n, int upd_topline)); int cursor_up(long n, int upd_topline);
int cursor_down __ARGS((long n, int upd_topline)); int cursor_down(long n, int upd_topline);
int stuff_inserted __ARGS((int c, long count, int no_esc)); int stuff_inserted(int c, long count, int no_esc);
char_u *get_last_insert __ARGS((void)); char_u *get_last_insert(void);
char_u *get_last_insert_save __ARGS((void)); char_u *get_last_insert_save(void);
void replace_push __ARGS((int c)); void replace_push(int c);
int replace_push_mb __ARGS((char_u *p)); int replace_push_mb(char_u *p);
void fixthisline __ARGS((int (*get_the_indent)(void))); void fixthisline(int (*get_the_indent)(void));
void fix_indent __ARGS((void)); void fix_indent(void);
int in_cinkeys __ARGS((int keytyped, int when, int line_is_empty)); int in_cinkeys(int keytyped, int when, int line_is_empty);
int hkmap __ARGS((int c)); int hkmap(int c);
void ins_scroll __ARGS((void)); void ins_scroll(void);
void ins_horscroll __ARGS((void)); void ins_horscroll(void);
int ins_copychar __ARGS((linenr_T lnum)); int ins_copychar(linenr_T lnum);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EDIT_H */ #endif /* NEOVIM_EDIT_H */

910
src/eval.c
View File

File diff suppressed because it is too large Load Diff

288
src/eval.h
View File

@ -1,153 +1,153 @@
#ifndef NEOVIM_EVAL_H #ifndef NEOVIM_EVAL_H
#define NEOVIM_EVAL_H #define NEOVIM_EVAL_H
/* eval.c */ /* eval.c */
void eval_init __ARGS((void)); void eval_init(void);
void eval_clear __ARGS((void)); void eval_clear(void);
char_u *func_name __ARGS((void *cookie)); char_u *func_name(void *cookie);
linenr_T *func_breakpoint __ARGS((void *cookie)); linenr_T *func_breakpoint(void *cookie);
int *func_dbg_tick __ARGS((void *cookie)); int *func_dbg_tick(void *cookie);
int func_level __ARGS((void *cookie)); int func_level(void *cookie);
int current_func_returned __ARGS((void)); int current_func_returned(void);
void set_internal_string_var __ARGS((char_u *name, char_u *value)); void set_internal_string_var(char_u *name, char_u *value);
int var_redir_start __ARGS((char_u *name, int append)); int var_redir_start(char_u *name, int append);
void var_redir_str __ARGS((char_u *value, int value_len)); void var_redir_str(char_u *value, int value_len);
void var_redir_stop __ARGS((void)); void var_redir_stop(void);
int eval_charconvert __ARGS((char_u *enc_from, char_u *enc_to, char_u * int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *
fname_from, fname_from,
char_u *fname_to)); char_u *fname_to);
int eval_printexpr __ARGS((char_u *fname, char_u *args)); int eval_printexpr(char_u *fname, char_u *args);
void eval_diff __ARGS((char_u *origfile, char_u *newfile, char_u *outfile)); void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile);
void eval_patch __ARGS((char_u *origfile, char_u *difffile, char_u *outfile)); void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile);
int eval_to_bool __ARGS((char_u *arg, int *error, char_u **nextcmd, int skip)); int eval_to_bool(char_u *arg, int *error, char_u **nextcmd, int skip);
char_u *eval_to_string_skip __ARGS((char_u *arg, char_u **nextcmd, int skip)); char_u *eval_to_string_skip(char_u *arg, char_u **nextcmd, int skip);
int skip_expr __ARGS((char_u **pp)); int skip_expr(char_u **pp);
char_u *eval_to_string __ARGS((char_u *arg, char_u **nextcmd, int convert)); char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert);
char_u *eval_to_string_safe __ARGS((char_u *arg, char_u **nextcmd, char_u *eval_to_string_safe(char_u *arg, char_u **nextcmd,
int use_sandbox)); int use_sandbox);
int eval_to_number __ARGS((char_u *expr)); int eval_to_number(char_u *expr);
list_T *eval_spell_expr __ARGS((char_u *badword, char_u *expr)); list_T *eval_spell_expr(char_u *badword, char_u *expr);
int get_spellword __ARGS((list_T *list, char_u **pp)); int get_spellword(list_T *list, char_u **pp);
typval_T *eval_expr __ARGS((char_u *arg, char_u **nextcmd)); typval_T *eval_expr(char_u *arg, char_u **nextcmd);
int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, int call_vim_function(char_u *func, int argc, char_u **argv, int safe,
int str_arg_only, int str_arg_only,
typval_T *rettv)); typval_T *rettv);
long call_func_retnr __ARGS((char_u *func, int argc, char_u **argv, int safe)); long call_func_retnr(char_u *func, int argc, char_u **argv, int safe);
void *call_func_retstr __ARGS((char_u *func, int argc, char_u **argv, int safe)); void *call_func_retstr(char_u *func, int argc, char_u **argv, int safe);
void *call_func_retlist __ARGS((char_u *func, int argc, char_u **argv, int safe)); void *call_func_retlist(char_u *func, int argc, char_u **argv, int safe);
void *save_funccal __ARGS((void)); void *save_funccal(void);
void restore_funccal __ARGS((void *vfc)); void restore_funccal(void *vfc);
void prof_child_enter __ARGS((proftime_T *tm)); void prof_child_enter(proftime_T *tm);
void prof_child_exit __ARGS((proftime_T *tm)); void prof_child_exit(proftime_T *tm);
int eval_foldexpr __ARGS((char_u *arg, int *cp)); int eval_foldexpr(char_u *arg, int *cp);
void ex_let __ARGS((exarg_T *eap)); void ex_let(exarg_T *eap);
void list_add_watch __ARGS((list_T *l, listwatch_T *lw)); void list_add_watch(list_T *l, listwatch_T *lw);
void list_rem_watch __ARGS((list_T *l, listwatch_T *lwrem)); void list_rem_watch(list_T *l, listwatch_T *lwrem);
void *eval_for_line __ARGS((char_u *arg, int *errp, char_u **nextcmdp, int skip)); void *eval_for_line(char_u *arg, int *errp, char_u **nextcmdp, int skip);
int next_for_item __ARGS((void *fi_void, char_u *arg)); int next_for_item(void *fi_void, char_u *arg);
void free_for_info __ARGS((void *fi_void)); void free_for_info(void *fi_void);
void set_context_for_expression __ARGS((expand_T *xp, char_u *arg, void set_context_for_expression(expand_T *xp, char_u *arg,
cmdidx_T cmdidx)); cmdidx_T cmdidx);
void ex_call __ARGS((exarg_T *eap)); void ex_call(exarg_T *eap);
void ex_unlet __ARGS((exarg_T *eap)); void ex_unlet(exarg_T *eap);
void ex_lockvar __ARGS((exarg_T *eap)); void ex_lockvar(exarg_T *eap);
int do_unlet __ARGS((char_u *name, int forceit)); int do_unlet(char_u *name, int forceit);
void del_menutrans_vars __ARGS((void)); void del_menutrans_vars(void);
char_u *get_user_var_name __ARGS((expand_T *xp, int idx)); char_u *get_user_var_name(expand_T *xp, int idx);
list_T *list_alloc __ARGS((void)); list_T *list_alloc(void);
void list_unref __ARGS((list_T *l)); void list_unref(list_T *l);
void list_free __ARGS((list_T *l, int recurse)); void list_free(list_T *l, int recurse);
listitem_T *listitem_alloc __ARGS((void)); listitem_T *listitem_alloc(void);
void listitem_free __ARGS((listitem_T *item)); void listitem_free(listitem_T *item);
void listitem_remove __ARGS((list_T *l, listitem_T *item)); void listitem_remove(list_T *l, listitem_T *item);
dictitem_T *dict_lookup __ARGS((hashitem_T *hi)); dictitem_T *dict_lookup(hashitem_T *hi);
listitem_T *list_find __ARGS((list_T *l, long n)); listitem_T *list_find(list_T *l, long n);
char_u *list_find_str __ARGS((list_T *l, long idx)); char_u *list_find_str(list_T *l, long idx);
void list_append __ARGS((list_T *l, listitem_T *item)); void list_append(list_T *l, listitem_T *item);
int list_append_tv __ARGS((list_T *l, typval_T *tv)); int list_append_tv(list_T *l, typval_T *tv);
int list_append_dict __ARGS((list_T *list, dict_T *dict)); int list_append_dict(list_T *list, dict_T *dict);
int list_append_string __ARGS((list_T *l, char_u *str, int len)); int list_append_string(list_T *l, char_u *str, int len);
int list_insert_tv __ARGS((list_T *l, typval_T *tv, listitem_T *item)); int list_insert_tv(list_T *l, typval_T *tv, listitem_T *item);
void list_remove __ARGS((list_T *l, listitem_T *item, listitem_T *item2)); void list_remove(list_T *l, listitem_T *item, listitem_T *item2);
void list_insert __ARGS((list_T *l, listitem_T *ni, listitem_T *item)); void list_insert(list_T *l, listitem_T *ni, listitem_T *item);
int garbage_collect __ARGS((void)); int garbage_collect(void);
void set_ref_in_ht __ARGS((hashtab_T *ht, int copyID)); void set_ref_in_ht(hashtab_T *ht, int copyID);
void set_ref_in_list __ARGS((list_T *l, int copyID)); void set_ref_in_list(list_T *l, int copyID);
void set_ref_in_item __ARGS((typval_T *tv, int copyID)); void set_ref_in_item(typval_T *tv, int copyID);
dict_T *dict_alloc __ARGS((void)); dict_T *dict_alloc(void);
void dict_unref __ARGS((dict_T *d)); void dict_unref(dict_T *d);
void dict_free __ARGS((dict_T *d, int recurse)); void dict_free(dict_T *d, int recurse);
dictitem_T *dictitem_alloc __ARGS((char_u *key)); dictitem_T *dictitem_alloc(char_u *key);
void dictitem_free __ARGS((dictitem_T *item)); void dictitem_free(dictitem_T *item);
int dict_add __ARGS((dict_T *d, dictitem_T *item)); int dict_add(dict_T *d, dictitem_T *item);
int dict_add_nr_str __ARGS((dict_T *d, char *key, long nr, char_u *str)); int dict_add_nr_str(dict_T *d, char *key, long nr, char_u *str);
int dict_add_list __ARGS((dict_T *d, char *key, list_T *list)); int dict_add_list(dict_T *d, char *key, list_T *list);
dictitem_T *dict_find __ARGS((dict_T *d, char_u *key, int len)); dictitem_T *dict_find(dict_T *d, char_u *key, int len);
char_u *get_dict_string __ARGS((dict_T *d, char_u *key, int save)); char_u *get_dict_string(dict_T *d, char_u *key, int save);
long get_dict_number __ARGS((dict_T *d, char_u *key)); long get_dict_number(dict_T *d, char_u *key);
char_u *get_function_name __ARGS((expand_T *xp, int idx)); char_u *get_function_name(expand_T *xp, int idx);
char_u *get_expr_name __ARGS((expand_T *xp, int idx)); char_u *get_expr_name(expand_T *xp, int idx);
int func_call __ARGS((char_u *name, typval_T *args, dict_T *selfdict, int func_call(char_u *name, typval_T *args, dict_T *selfdict,
typval_T *rettv)); typval_T *rettv);
void dict_extend __ARGS((dict_T *d1, dict_T *d2, char_u *action)); void dict_extend(dict_T *d1, dict_T *d2, char_u *action);
void mzscheme_call_vim __ARGS((char_u *name, typval_T *args, typval_T *rettv)); void mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv);
float_T vim_round __ARGS((float_T f)); float_T vim_round(float_T f);
long do_searchpair __ARGS((char_u *spat, char_u *mpat, char_u *epat, int dir, long do_searchpair(char_u *spat, char_u *mpat, char_u *epat, int dir,
char_u *skip, int flags, pos_T *match_pos, char_u *skip, int flags, pos_T *match_pos,
linenr_T lnum_stop, linenr_T lnum_stop,
long time_limit)); long time_limit);
void set_vim_var_nr __ARGS((int idx, long val)); void set_vim_var_nr(int idx, long val);
long get_vim_var_nr __ARGS((int idx)); long get_vim_var_nr(int idx);
char_u *get_vim_var_str __ARGS((int idx)); char_u *get_vim_var_str(int idx);
list_T *get_vim_var_list __ARGS((int idx)); list_T *get_vim_var_list(int idx);
void set_vim_var_char __ARGS((int c)); void set_vim_var_char(int c);
void set_vcount __ARGS((long count, long count1, int set_prevcount)); void set_vcount(long count, long count1, int set_prevcount);
void set_vim_var_string __ARGS((int idx, char_u *val, int len)); void set_vim_var_string(int idx, char_u *val, int len);
void set_vim_var_list __ARGS((int idx, list_T *val)); void set_vim_var_list(int idx, list_T *val);
void set_reg_var __ARGS((int c)); void set_reg_var(int c);
char_u *v_exception __ARGS((char_u *oldval)); char_u *v_exception(char_u *oldval);
char_u *v_throwpoint __ARGS((char_u *oldval)); char_u *v_throwpoint(char_u *oldval);
char_u *set_cmdarg __ARGS((exarg_T *eap, char_u *oldarg)); char_u *set_cmdarg(exarg_T *eap, char_u *oldarg);
void free_tv __ARGS((typval_T *varp)); void free_tv(typval_T *varp);
void clear_tv __ARGS((typval_T *varp)); void clear_tv(typval_T *varp);
long get_tv_number_chk __ARGS((typval_T *varp, int *denote)); long get_tv_number_chk(typval_T *varp, int *denote);
char_u *get_tv_string_chk __ARGS((typval_T *varp)); char_u *get_tv_string_chk(typval_T *varp);
char_u *get_var_value __ARGS((char_u *name)); char_u *get_var_value(char_u *name);
void new_script_vars __ARGS((scid_T id)); void new_script_vars(scid_T id);
void init_var_dict __ARGS((dict_T *dict, dictitem_T *dict_var, int scope)); void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope);
void unref_var_dict __ARGS((dict_T *dict)); void unref_var_dict(dict_T *dict);
void vars_clear __ARGS((hashtab_T *ht)); void vars_clear(hashtab_T *ht);
void copy_tv __ARGS((typval_T *from, typval_T *to)); void copy_tv(typval_T *from, typval_T *to);
void ex_echo __ARGS((exarg_T *eap)); void ex_echo(exarg_T *eap);
void ex_echohl __ARGS((exarg_T *eap)); void ex_echohl(exarg_T *eap);
void ex_execute __ARGS((exarg_T *eap)); void ex_execute(exarg_T *eap);
void ex_function __ARGS((exarg_T *eap)); void ex_function(exarg_T *eap);
void free_all_functions __ARGS((void)); void free_all_functions(void);
int translated_function_exists __ARGS((char_u *name)); int translated_function_exists(char_u *name);
char_u *get_expanded_name __ARGS((char_u *name, int check)); char_u *get_expanded_name(char_u *name, int check);
void func_dump_profile __ARGS((FILE *fd)); void func_dump_profile(FILE *fd);
char_u *get_user_func_name __ARGS((expand_T *xp, int idx)); char_u *get_user_func_name(expand_T *xp, int idx);
void ex_delfunction __ARGS((exarg_T *eap)); void ex_delfunction(exarg_T *eap);
void func_unref __ARGS((char_u *name)); void func_unref(char_u *name);
void func_ref __ARGS((char_u *name)); void func_ref(char_u *name);
void ex_return __ARGS((exarg_T *eap)); void ex_return(exarg_T *eap);
int do_return __ARGS((exarg_T *eap, int reanimate, int is_cmd, void *rettv)); int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv);
void discard_pending_return __ARGS((void *rettv)); void discard_pending_return(void *rettv);
char_u *get_return_cmd __ARGS((void *rettv)); char_u *get_return_cmd(void *rettv);
char_u *get_func_line __ARGS((int c, void *cookie, int indent)); char_u *get_func_line(int c, void *cookie, int indent);
void func_line_start __ARGS((void *cookie)); void func_line_start(void *cookie);
void func_line_exec __ARGS((void *cookie)); void func_line_exec(void *cookie);
void func_line_end __ARGS((void *cookie)); void func_line_end(void *cookie);
int func_has_ended __ARGS((void *cookie)); int func_has_ended(void *cookie);
int func_has_abort __ARGS((void *cookie)); int func_has_abort(void *cookie);
int read_viminfo_varlist __ARGS((vir_T *virp, int writing)); int read_viminfo_varlist(vir_T *virp, int writing);
void write_viminfo_varlist __ARGS((FILE *fp)); void write_viminfo_varlist(FILE *fp);
int store_session_globals __ARGS((FILE *fd)); int store_session_globals(FILE *fd);
void last_set_msg __ARGS((scid_T scriptID)); void last_set_msg(scid_T scriptID);
void ex_oldfiles __ARGS((exarg_T *eap)); void ex_oldfiles(exarg_T *eap);
int modify_fname __ARGS((char_u *src, int *usedlen, char_u **fnamep, char_u * int modify_fname(char_u *src, int *usedlen, char_u **fnamep,
*bufp, char_u **bufp,
int *fnamelen)); int *fnamelen);
char_u *do_string_sub __ARGS((char_u *str, char_u *pat, char_u *sub, char_u *do_string_sub(char_u *str, char_u *pat, char_u *sub,
char_u *flags)); char_u *flags);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EVAL_H */ #endif /* NEOVIM_EVAL_H */

31
src/ex_cmds.c
View File

@ -52,20 +52,19 @@
#include "undo.h" #include "undo.h"
#include "window.h" #include "window.h"
static int linelen __ARGS((int *has_tab)); static int linelen(int *has_tab);
static void do_filter __ARGS((linenr_T line1, linenr_T line2, exarg_T *eap, static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap,
char_u *cmd, int do_in, char_u *cmd, int do_in,
int do_out)); int do_out);
static char_u *viminfo_filename __ARGS((char_u *)); static char_u *viminfo_filename(char_u *);
static void do_viminfo __ARGS((FILE *fp_in, FILE *fp_out, int flags)); static void do_viminfo(FILE *fp_in, FILE *fp_out, int flags);
static int viminfo_encoding __ARGS((vir_T *virp)); static int viminfo_encoding(vir_T *virp);
static int read_viminfo_up_to_marks __ARGS((vir_T *virp, int forceit, static int read_viminfo_up_to_marks(vir_T *virp, int forceit,
int writing)); int writing);
static int check_readonly __ARGS((int *forceit, buf_T *buf)); static int check_readonly(int *forceit, buf_T *buf);
static void delbuf_msg __ARGS((char_u *name)); static void delbuf_msg(char_u *name);
static int static int help_compare(const void *s1, const void *s2);
help_compare __ARGS((const void *s1, const void *s2));
/* /*
* ":ascii" and "ga". * ":ascii" and "ga".
@ -285,7 +284,7 @@ typedef struct {
} sorti_T; } sorti_T;
static int static int
sort_compare __ARGS((const void *s1, const void *s2)); sort_compare(const void *s1, const void *s2);
static int sort_compare(const void *s1, const void *s2) static int sort_compare(const void *s1, const void *s2)
{ {
@ -1395,7 +1394,7 @@ void append_redir(char_u *buf, int buflen, char_u *opt, char_u *fname)
} }
static int no_viminfo __ARGS((void)); static int no_viminfo(void);
static int viminfo_errcnt; static int viminfo_errcnt;
static int no_viminfo(void) { static int no_viminfo(void) {
@ -5327,8 +5326,8 @@ void ex_viusage(exarg_T *eap)
do_cmdline_cmd((char_u *)"help normal-index"); do_cmdline_cmd((char_u *)"help normal-index");
} }
static void helptags_one __ARGS((char_u *dir, char_u *ext, char_u *lang, static void helptags_one(char_u *dir, char_u *ext, char_u *lang,
int add_help_tags)); int add_help_tags);
/* /*
* ":helptags" * ":helptags"

134
src/ex_cmds.h
View File

@ -2,75 +2,75 @@
#define NEOVIM_EX_CMDS_H #define NEOVIM_EX_CMDS_H
/* ex_cmds.c */ /* ex_cmds.c */
void do_ascii __ARGS((exarg_T *eap)); void do_ascii(exarg_T *eap);
void ex_align __ARGS((exarg_T *eap)); void ex_align(exarg_T *eap);
void ex_sort __ARGS((exarg_T *eap)); void ex_sort(exarg_T *eap);
void ex_retab __ARGS((exarg_T *eap)); void ex_retab(exarg_T *eap);
int do_move __ARGS((linenr_T line1, linenr_T line2, linenr_T dest)); int do_move(linenr_T line1, linenr_T line2, linenr_T dest);
void ex_copy __ARGS((linenr_T line1, linenr_T line2, linenr_T n)); void ex_copy(linenr_T line1, linenr_T line2, linenr_T n);
void free_prev_shellcmd __ARGS((void)); void free_prev_shellcmd(void);
void do_bang __ARGS((int addr_count, exarg_T *eap, int forceit, int do_in, void do_bang(int addr_count, exarg_T *eap, int forceit, int do_in,
int do_out)); int do_out);
void do_shell __ARGS((char_u *cmd, int flags)); void do_shell(char_u *cmd, int flags);
char_u *make_filter_cmd __ARGS((char_u *cmd, char_u *itmp, char_u *otmp)); char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp);
void append_redir __ARGS((char_u *buf, int buflen, char_u *opt, char_u *fname)); void append_redir(char_u *buf, int buflen, char_u *opt, char_u *fname);
int viminfo_error __ARGS((char *errnum, char *message, char_u *line)); int viminfo_error(char *errnum, char *message, char_u *line);
int read_viminfo __ARGS((char_u *file, int flags)); int read_viminfo(char_u *file, int flags);
void write_viminfo __ARGS((char_u *file, int forceit)); void write_viminfo(char_u *file, int forceit);
int viminfo_readline __ARGS((vir_T *virp)); int viminfo_readline(vir_T *virp);
char_u *viminfo_readstring __ARGS((vir_T *virp, int off, int convert)); char_u *viminfo_readstring(vir_T *virp, int off, int convert);
void viminfo_writestring __ARGS((FILE *fd, char_u *p)); void viminfo_writestring(FILE *fd, char_u *p);
void do_fixdel __ARGS((exarg_T *eap)); void do_fixdel(exarg_T *eap);
void print_line_no_prefix __ARGS((linenr_T lnum, int use_number, int list)); void print_line_no_prefix(linenr_T lnum, int use_number, int list);
void print_line __ARGS((linenr_T lnum, int use_number, int list)); void print_line(linenr_T lnum, int use_number, int list);
int rename_buffer __ARGS((char_u *new_fname)); int rename_buffer(char_u *new_fname);
void ex_file __ARGS((exarg_T *eap)); void ex_file(exarg_T *eap);
void ex_update __ARGS((exarg_T *eap)); void ex_update(exarg_T *eap);
void ex_write __ARGS((exarg_T *eap)); void ex_write(exarg_T *eap);
int do_write __ARGS((exarg_T *eap)); int do_write(exarg_T *eap);
int check_overwrite __ARGS((exarg_T *eap, buf_T *buf, char_u *fname, char_u * int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *
ffname, ffname,
int other)); int other);
void ex_wnext __ARGS((exarg_T *eap)); void ex_wnext(exarg_T *eap);
void do_wqall __ARGS((exarg_T *eap)); void do_wqall(exarg_T *eap);
int not_writing __ARGS((void)); int not_writing(void);
int getfile __ARGS((int fnum, char_u *ffname, char_u *sfname, int setpm, int getfile(int fnum, char_u *ffname, char_u *sfname, int setpm,
linenr_T lnum, linenr_T lnum,
int forceit)); int forceit);
int do_ecmd __ARGS((int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap,
linenr_T newlnum, int flags, linenr_T newlnum, int flags,
win_T *oldwin)); win_T *oldwin);
void ex_append __ARGS((exarg_T *eap)); void ex_append(exarg_T *eap);
void ex_change __ARGS((exarg_T *eap)); void ex_change(exarg_T *eap);
void ex_z __ARGS((exarg_T *eap)); void ex_z(exarg_T *eap);
int check_restricted __ARGS((void)); int check_restricted(void);
int check_secure __ARGS((void)); int check_secure(void);
void do_sub __ARGS((exarg_T *eap)); void do_sub(exarg_T *eap);
int do_sub_msg __ARGS((int count_only)); int do_sub_msg(int count_only);
void ex_global __ARGS((exarg_T *eap)); void ex_global(exarg_T *eap);
void global_exe __ARGS((char_u *cmd)); void global_exe(char_u *cmd);
int read_viminfo_sub_string __ARGS((vir_T *virp, int force)); int read_viminfo_sub_string(vir_T *virp, int force);
void write_viminfo_sub_string __ARGS((FILE *fp)); void write_viminfo_sub_string(FILE *fp);
void free_old_sub __ARGS((void)); void free_old_sub(void);
int prepare_tagpreview __ARGS((int undo_sync)); int prepare_tagpreview(int undo_sync);
void ex_help __ARGS((exarg_T *eap)); void ex_help(exarg_T *eap);
char_u *check_help_lang __ARGS((char_u *arg)); char_u *check_help_lang(char_u *arg);
int help_heuristic __ARGS((char_u *matched_string, int offset, int wrong_case)); int help_heuristic(char_u *matched_string, int offset, int wrong_case);
int find_help_tags __ARGS((char_u *arg, int *num_matches, char_u ***matches, int find_help_tags(char_u *arg, int *num_matches, char_u ***matches,
int keep_lang)); int keep_lang);
void fix_help_buffer __ARGS((void)); void fix_help_buffer(void);
void ex_exusage __ARGS((exarg_T *eap)); void ex_exusage(exarg_T *eap);
void ex_viusage __ARGS((exarg_T *eap)); void ex_viusage(exarg_T *eap);
void ex_helptags __ARGS((exarg_T *eap)); void ex_helptags(exarg_T *eap);
void ex_sign __ARGS((exarg_T *eap)); void ex_sign(exarg_T *eap);
void sign_gui_started __ARGS((void)); void sign_gui_started(void);
int sign_get_attr __ARGS((int typenr, int line)); int sign_get_attr(int typenr, int line);
char_u *sign_get_text __ARGS((int typenr)); char_u *sign_get_text(int typenr);
void *sign_get_image __ARGS((int typenr)); void *sign_get_image(int typenr);
char_u *sign_typenr2name __ARGS((int typenr)); char_u *sign_typenr2name(int typenr);
void free_signs __ARGS((void)); void free_signs(void);
char_u *get_sign_name __ARGS((expand_T *xp, int idx)); char_u *get_sign_name(expand_T *xp, int idx);
void set_context_in_sign_cmd __ARGS((expand_T *xp, char_u *arg)); void set_context_in_sign_cmd(expand_T *xp, char_u *arg);
void ex_drop __ARGS((exarg_T *eap)); void ex_drop(exarg_T *eap);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EX_CMDS_H */ #endif /* NEOVIM_EX_CMDS_H */

42
src/ex_cmds2.c
View File

@ -40,7 +40,7 @@
#include "undo.h" #include "undo.h"
#include "window.h" #include "window.h"
static void cmd_source __ARGS((char_u *fname, exarg_T *eap)); static void cmd_source(char_u *fname, exarg_T *eap);
/* Growarray to store info about already sourced scripts. /* Growarray to store info about already sourced scripts.
* For Unix also store the dev/ino, so that we don't have to stat() each * For Unix also store the dev/ino, so that we don't have to stat() each
@ -385,10 +385,10 @@ static garray_T prof_ga = {0, 0, sizeof(struct debuggy), 4, NULL};
#define DBG_FUNC 1 #define DBG_FUNC 1
#define DBG_FILE 2 #define DBG_FILE 2
static int dbg_parsearg __ARGS((char_u *arg, garray_T *gap)); static int dbg_parsearg(char_u *arg, garray_T *gap);
static linenr_T debuggy_find __ARGS((int file,char_u *fname, linenr_T after, static linenr_T debuggy_find(int file,char_u *fname, linenr_T after,
garray_T *gap, garray_T *gap,
int *fp)); int *fp);
/* /*
* Parse the arguments of ":profile", ":breakadd" or ":breakdel" and put them * Parse the arguments of ":profile", ":breakadd" or ":breakdel" and put them
@ -844,8 +844,8 @@ int count;
/* /*
* Functions for profiling. * Functions for profiling.
*/ */
static void script_do_profile __ARGS((scriptitem_T *si)); static void script_do_profile(scriptitem_T *si);
static void script_dump_profile __ARGS((FILE *fd)); static void script_dump_profile(FILE *fd);
static proftime_T prof_wait_time; static proftime_T prof_wait_time;
/* /*
@ -1324,7 +1324,7 @@ int can_abandon(buf_T *buf, int forceit)
|| forceit; || forceit;
} }
static void add_bufnum __ARGS((int *bufnrs, int *bufnump, int nr)); static void add_bufnum(int *bufnrs, int *bufnump, int nr);
/* /*
* Add a buffer number to "bufnrs", unless it's already there. * Add a buffer number to "bufnrs", unless it's already there.
@ -1484,11 +1484,11 @@ int buf_write_all(buf_T *buf, int forceit)
* Code to handle the argument list. * Code to handle the argument list.
*/ */
static char_u *do_one_arg __ARGS((char_u *str)); static char_u *do_one_arg(char_u *str);
static int do_arglist __ARGS((char_u *str, int what, int after)); static int do_arglist(char_u *str, int what, int after);
static void alist_check_arg_idx __ARGS((void)); static void alist_check_arg_idx(void);
static int editing_arg_idx __ARGS((win_T *win)); static int editing_arg_idx(win_T *win);
static int alist_add_list __ARGS((int count, char_u **files, int after)); static int alist_add_list(int count, char_u **files, int after);
#define AL_SET 1 #define AL_SET 1
#define AL_ADD 2 #define AL_ADD 2
#define AL_DEL 3 #define AL_DEL 3
@ -2213,7 +2213,7 @@ void ex_runtime(exarg_T *eap)
source_runtime(eap->arg, eap->forceit); source_runtime(eap->arg, eap->forceit);
} }
static void source_callback __ARGS((char_u *fname, void *cookie)); static void source_callback(char_u *fname, void *cookie);
static void source_callback(char_u *fname, void *cookie) static void source_callback(char_u *fname, void *cookie)
{ {
@ -2245,7 +2245,7 @@ int source_runtime(char_u *name, int all)
int do_in_runtimepath(name, all, callback, cookie) int do_in_runtimepath(name, all, callback, cookie)
char_u *name; char_u *name;
int all; int all;
void (*callback)__ARGS((char_u *fname, void *ck)); void (*callback)(char_u *fname, void *ck);
void *cookie; void *cookie;
{ {
char_u *rtp; char_u *rtp;
@ -2410,11 +2410,11 @@ int source_level(void *cookie)
return ((struct source_cookie *)cookie)->level; return ((struct source_cookie *)cookie)->level;
} }
static char_u *get_one_sourceline __ARGS((struct source_cookie *sp)); static char_u *get_one_sourceline(struct source_cookie *sp);
#if (defined(WIN32) && defined(FEAT_CSCOPE)) || defined(HAVE_FD_CLOEXEC) #if (defined(WIN32) && defined(FEAT_CSCOPE)) || defined(HAVE_FD_CLOEXEC)
# define USE_FOPEN_NOINH # define USE_FOPEN_NOINH
static FILE *fopen_noinh_readbin __ARGS((char *filename)); static FILE *fopen_noinh_readbin(char *filename);
/* /*
* Special function to open a file without handle inheritance. * Special function to open a file without handle inheritance.
@ -3236,7 +3236,7 @@ void do_finish(exarg_T *eap, int reanimate)
* Return FALSE when not sourcing a file. * Return FALSE when not sourcing a file.
*/ */
int source_finished(fgetline, cookie) int source_finished(fgetline, cookie)
char_u *(*fgetline)__ARGS((int, void *, int)); char_u *(*fgetline)(int, void *, int);
void *cookie; void *cookie;
{ {
return getline_equal(fgetline, cookie, getsourceline) return getline_equal(fgetline, cookie, getsourceline)
@ -3266,7 +3266,7 @@ void ex_checktime(exarg_T *eap)
#if (defined(HAVE_LOCALE_H) || defined(X_LOCALE)) \ #if (defined(HAVE_LOCALE_H) || defined(X_LOCALE)) \
&& (defined(FEAT_EVAL) || defined(FEAT_MULTI_LANG)) && (defined(FEAT_EVAL) || defined(FEAT_MULTI_LANG))
# define HAVE_GET_LOCALE_VAL # define HAVE_GET_LOCALE_VAL
static char *get_locale_val __ARGS((int what)); static char *get_locale_val(int what);
static char *get_locale_val(int what) static char *get_locale_val(int what)
{ {
@ -3313,7 +3313,7 @@ char_u *get_mess_lang(void) {
/* Complicated #if; matches with where get_mess_env() is used below. */ /* Complicated #if; matches with where get_mess_env() is used below. */
#ifdef HAVE_WORKING_LIBINTL #ifdef HAVE_WORKING_LIBINTL
static char_u *get_mess_env __ARGS((void)); static char_u *get_mess_env(void);
/* /*
* Get the language used for messages from the environment. * Get the language used for messages from the environment.
@ -3475,8 +3475,8 @@ void ex_language(exarg_T *eap)
static char_u **locales = NULL; /* Array of all available locales */ static char_u **locales = NULL; /* Array of all available locales */
static int did_init_locales = FALSE; static int did_init_locales = FALSE;
static void init_locales __ARGS((void)); static void init_locales(void);
static char_u **find_locales __ARGS((void)); static char_u **find_locales(void);
/* /*
* Lazy initialization of all available locales. * Lazy initialization of all available locales.

183
src/ex_cmds2.h
View File

@ -1,96 +1,97 @@
#ifndef NEOVIM_EX_CMDS2_H #ifndef NEOVIM_EX_CMDS2_H
#define NEOVIM_EX_CMDS2_H #define NEOVIM_EX_CMDS2_H
/* ex_cmds2.c */ /* ex_cmds2.c */
void do_debug __ARGS((char_u *cmd)); void do_debug(char_u *cmd);
void ex_debug __ARGS((exarg_T *eap)); void ex_debug(exarg_T *eap);
void dbg_check_breakpoint __ARGS((exarg_T *eap)); void dbg_check_breakpoint(exarg_T *eap);
int dbg_check_skipped __ARGS((exarg_T *eap)); int dbg_check_skipped(exarg_T *eap);
void ex_breakadd __ARGS((exarg_T *eap)); void ex_breakadd(exarg_T *eap);
void ex_debuggreedy __ARGS((exarg_T *eap)); void ex_debuggreedy(exarg_T *eap);
void ex_breakdel __ARGS((exarg_T *eap)); void ex_breakdel(exarg_T *eap);
void ex_breaklist __ARGS((exarg_T *eap)); void ex_breaklist(exarg_T *eap);
linenr_T dbg_find_breakpoint __ARGS((int file, char_u *fname, linenr_T after)); linenr_T dbg_find_breakpoint(int file, char_u *fname, linenr_T after);
int has_profiling __ARGS((int file, char_u *fname, int *fp)); int has_profiling(int file, char_u *fname, int *fp);
void dbg_breakpoint __ARGS((char_u *name, linenr_T lnum)); void dbg_breakpoint(char_u *name, linenr_T lnum);
void profile_start __ARGS((proftime_T *tm)); void profile_start(proftime_T *tm);
void profile_end __ARGS((proftime_T *tm)); void profile_end(proftime_T *tm);
void profile_sub __ARGS((proftime_T *tm, proftime_T *tm2)); void profile_sub(proftime_T *tm, proftime_T *tm2);
char *profile_msg __ARGS((proftime_T *tm)); char *profile_msg(proftime_T *tm);
void profile_setlimit __ARGS((long msec, proftime_T *tm)); void profile_setlimit(long msec, proftime_T *tm);
int profile_passed_limit __ARGS((proftime_T *tm)); int profile_passed_limit(proftime_T *tm);
void profile_zero __ARGS((proftime_T *tm)); void profile_zero(proftime_T *tm);
void profile_divide __ARGS((proftime_T *tm, int count, proftime_T *tm2)); void profile_divide(proftime_T *tm, int count, proftime_T *tm2);
void profile_add __ARGS((proftime_T *tm, proftime_T *tm2)); void profile_add(proftime_T *tm, proftime_T *tm2);
void profile_self __ARGS((proftime_T *self, proftime_T *total, void profile_self(proftime_T *self, proftime_T *total,
proftime_T *children)); proftime_T *children);
void profile_get_wait __ARGS((proftime_T *tm)); void profile_get_wait(proftime_T *tm);
void profile_sub_wait __ARGS((proftime_T *tm, proftime_T *tma)); void profile_sub_wait(proftime_T *tm, proftime_T *tma);
int profile_equal __ARGS((proftime_T *tm1, proftime_T *tm2)); int profile_equal(proftime_T *tm1, proftime_T *tm2);
int profile_cmp __ARGS((const proftime_T *tm1, const proftime_T *tm2)); int profile_cmp(const proftime_T *tm1, const proftime_T *tm2);
void ex_profile __ARGS((exarg_T *eap)); void ex_profile(exarg_T *eap);
char_u *get_profile_name __ARGS((expand_T *xp, int idx)); char_u *get_profile_name(expand_T *xp, int idx);
void set_context_in_profile_cmd __ARGS((expand_T *xp, char_u *arg)); void set_context_in_profile_cmd(expand_T *xp, char_u *arg);
void profile_dump __ARGS((void)); void profile_dump(void);
void script_prof_save __ARGS((proftime_T *tm)); void script_prof_save(proftime_T *tm);
void script_prof_restore __ARGS((proftime_T *tm)); void script_prof_restore(proftime_T *tm);
void prof_inchar_enter __ARGS((void)); void prof_inchar_enter(void);
void prof_inchar_exit __ARGS((void)); void prof_inchar_exit(void);
int prof_def_func __ARGS((void)); int prof_def_func(void);
int autowrite __ARGS((buf_T *buf, int forceit)); int autowrite(buf_T *buf, int forceit);
void autowrite_all __ARGS((void)); void autowrite_all(void);
int check_changed __ARGS((buf_T *buf, int flags)); int check_changed(buf_T *buf, int flags);
void browse_save_fname __ARGS((buf_T *buf)); void browse_save_fname(buf_T *buf);
void dialog_changed __ARGS((buf_T *buf, int checkall)); void dialog_changed(buf_T *buf, int checkall);
int can_abandon __ARGS((buf_T *buf, int forceit)); int can_abandon(buf_T *buf, int forceit);
int check_changed_any __ARGS((int hidden)); int check_changed_any(int hidden);
int check_fname __ARGS((void)); int check_fname(void);
int buf_write_all __ARGS((buf_T *buf, int forceit)); int buf_write_all(buf_T *buf, int forceit);
int get_arglist __ARGS((garray_T *gap, char_u *str)); int get_arglist(garray_T *gap, char_u *str);
int get_arglist_exp __ARGS((char_u *str, int *fcountp, char_u ***fnamesp, int get_arglist_exp(char_u *str, int *fcountp, char_u ***fnamesp,
int wig)); int wig);
void set_arglist __ARGS((char_u *str)); void set_arglist(char_u *str);
void check_arg_idx __ARGS((win_T *win)); void check_arg_idx(win_T *win);
void ex_args __ARGS((exarg_T *eap)); void ex_args(exarg_T *eap);
void ex_previous __ARGS((exarg_T *eap)); void ex_previous(exarg_T *eap);
void ex_rewind __ARGS((exarg_T *eap)); void ex_rewind(exarg_T *eap);
void ex_last __ARGS((exarg_T *eap)); void ex_last(exarg_T *eap);
void ex_argument __ARGS((exarg_T *eap)); void ex_argument(exarg_T *eap);
void do_argfile __ARGS((exarg_T *eap, int argn)); void do_argfile(exarg_T *eap, int argn);
void ex_next __ARGS((exarg_T *eap)); void ex_next(exarg_T *eap);
void ex_argedit __ARGS((exarg_T *eap)); void ex_argedit(exarg_T *eap);
void ex_argadd __ARGS((exarg_T *eap)); void ex_argadd(exarg_T *eap);
void ex_argdelete __ARGS((exarg_T *eap)); void ex_argdelete(exarg_T *eap);
void ex_listdo __ARGS((exarg_T *eap)); void ex_listdo(exarg_T *eap);
void ex_compiler __ARGS((exarg_T *eap)); void ex_compiler(exarg_T *eap);
void ex_runtime __ARGS((exarg_T *eap)); void ex_runtime(exarg_T *eap);
int source_runtime __ARGS((char_u *name, int all)); int source_runtime(char_u *name, int all);
int do_in_runtimepath __ARGS((char_u *name, int all, void (*callback)( int do_in_runtimepath(char_u *name, int all,
char_u *fname, void *ck), void *cookie)); void (*callback)(char_u *fname, void *ck),
void ex_options __ARGS((exarg_T *eap)); void *cookie);
void ex_source __ARGS((exarg_T *eap)); void ex_options(exarg_T *eap);
linenr_T *source_breakpoint __ARGS((void *cookie)); void ex_source(exarg_T *eap);
int *source_dbg_tick __ARGS((void *cookie)); linenr_T *source_breakpoint(void *cookie);
int source_level __ARGS((void *cookie)); int *source_dbg_tick(void *cookie);
int do_source __ARGS((char_u *fname, int check_other, int is_vimrc)); int source_level(void *cookie);
void ex_scriptnames __ARGS((exarg_T *eap)); int do_source(char_u *fname, int check_other, int is_vimrc);
void scriptnames_slash_adjust __ARGS((void)); void ex_scriptnames(exarg_T *eap);
char_u *get_scriptname __ARGS((scid_T id)); void scriptnames_slash_adjust(void);
void free_scriptnames __ARGS((void)); char_u *get_scriptname(scid_T id);
char *fgets_cr __ARGS((char *s, int n, FILE *stream)); void free_scriptnames(void);
char_u *getsourceline __ARGS((int c, void *cookie, int indent)); char *fgets_cr(char *s, int n, FILE *stream);
void script_line_start __ARGS((void)); char_u *getsourceline(int c, void *cookie, int indent);
void script_line_exec __ARGS((void)); void script_line_start(void);
void script_line_end __ARGS((void)); void script_line_exec(void);
void ex_scriptencoding __ARGS((exarg_T *eap)); void script_line_end(void);
void ex_finish __ARGS((exarg_T *eap)); void ex_scriptencoding(exarg_T *eap);
void do_finish __ARGS((exarg_T *eap, int reanimate)); void ex_finish(exarg_T *eap);
int source_finished __ARGS((char_u *(*fgetline)(int, void *, int), void *cookie)); void do_finish(exarg_T *eap, int reanimate);
void ex_checktime __ARGS((exarg_T *eap)); int source_finished(char_u *(*fgetline)(int, void *, int), void *cookie);
char_u *get_mess_lang __ARGS((void)); void ex_checktime(exarg_T *eap);
void set_lang_var __ARGS((void)); char_u *get_mess_lang(void);
void ex_language __ARGS((exarg_T *eap)); void set_lang_var(void);
void free_locales __ARGS((void)); void ex_language(exarg_T *eap);
char_u *get_lang_arg __ARGS((expand_T *xp, int idx)); void free_locales(void);
char_u *get_locales __ARGS((expand_T *xp, int idx)); char_u *get_lang_arg(expand_T *xp, int idx);
char_u *get_locales(expand_T *xp, int idx);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EX_CMDS2_H */ #endif /* NEOVIM_EX_CMDS2_H */

4
src/ex_cmds_defs.h
View File

@ -76,7 +76,7 @@ typedef struct exarg exarg_T;
#ifdef DO_DECLARE_EXCMD #ifdef DO_DECLARE_EXCMD
# define EX(a, b, c, d) {(char_u *)b, c, (long_u)(d)} # define EX(a, b, c, d) {(char_u *)b, c, (long_u)(d)}
typedef void (*ex_func_T) __ARGS ((exarg_T *eap)); typedef void (*ex_func_T)(exarg_T *eap);
static struct cmdname { static struct cmdname {
char_u *cmd_name; /* name of the command */ char_u *cmd_name; /* name of the command */
@ -1175,7 +1175,7 @@ struct exarg {
int bad_char; /* BAD_KEEP, BAD_DROP or replacement byte */ int bad_char; /* BAD_KEEP, BAD_DROP or replacement byte */
int useridx; /* user command index */ int useridx; /* user command index */
char_u *errmsg; /* returned error message */ char_u *errmsg; /* returned error message */
char_u *(*getline)__ARGS((int, void *, int)); char_u *(*getline)(int, void *, int);
void *cookie; /* argument for getline() */ void *cookie; /* argument for getline() */
struct condstack *cstack; /* condition stack for ":if" etc. */ struct condstack *cstack; /* condition stack for ":if" etc. */
}; };

320
src/ex_docmd.c
View File

@ -78,39 +78,39 @@ static garray_T ucmds = {0, 0, sizeof(ucmd_T), 4, NULL};
#define USER_CMD(i) (&((ucmd_T *)(ucmds.ga_data))[i]) #define USER_CMD(i) (&((ucmd_T *)(ucmds.ga_data))[i])
#define USER_CMD_GA(gap, i) (&((ucmd_T *)((gap)->ga_data))[i]) #define USER_CMD_GA(gap, i) (&((ucmd_T *)((gap)->ga_data))[i])
static void do_ucmd __ARGS((exarg_T *eap)); static void do_ucmd(exarg_T *eap);
static void ex_command __ARGS((exarg_T *eap)); static void ex_command(exarg_T *eap);
static void ex_delcommand __ARGS((exarg_T *eap)); static void ex_delcommand(exarg_T *eap);
static char_u *get_user_command_name __ARGS((int idx)); static char_u *get_user_command_name(int idx);
static char_u *do_one_cmd __ARGS((char_u **, int, struct condstack *, static char_u *do_one_cmd(char_u **, int, struct condstack *,
char_u *(*fgetline)(int, void *, int), char_u *(*fgetline)(int, void *, int),
void *cookie)); void *cookie);
static void append_command __ARGS((char_u *cmd)); static void append_command(char_u *cmd);
static char_u *find_command __ARGS((exarg_T *eap, int *full)); static char_u *find_command(exarg_T *eap, int *full);
static void ex_abbreviate __ARGS((exarg_T *eap)); static void ex_abbreviate(exarg_T *eap);
static void ex_map __ARGS((exarg_T *eap)); static void ex_map(exarg_T *eap);
static void ex_unmap __ARGS((exarg_T *eap)); static void ex_unmap(exarg_T *eap);
static void ex_mapclear __ARGS((exarg_T *eap)); static void ex_mapclear(exarg_T *eap);
static void ex_abclear __ARGS((exarg_T *eap)); static void ex_abclear(exarg_T *eap);
static void ex_autocmd __ARGS((exarg_T *eap)); static void ex_autocmd(exarg_T *eap);
static void ex_doautocmd __ARGS((exarg_T *eap)); static void ex_doautocmd(exarg_T *eap);
static void ex_bunload __ARGS((exarg_T *eap)); static void ex_bunload(exarg_T *eap);
static void ex_buffer __ARGS((exarg_T *eap)); static void ex_buffer(exarg_T *eap);
static void ex_bmodified __ARGS((exarg_T *eap)); static void ex_bmodified(exarg_T *eap);
static void ex_bnext __ARGS((exarg_T *eap)); static void ex_bnext(exarg_T *eap);
static void ex_bprevious __ARGS((exarg_T *eap)); static void ex_bprevious(exarg_T *eap);
static void ex_brewind __ARGS((exarg_T *eap)); static void ex_brewind(exarg_T *eap);
static void ex_blast __ARGS((exarg_T *eap)); static void ex_blast(exarg_T *eap);
static char_u *getargcmd __ARGS((char_u **)); static char_u *getargcmd(char_u **);
static char_u *skip_cmd_arg __ARGS((char_u *p, int rembs)); static char_u *skip_cmd_arg(char_u *p, int rembs);
static int getargopt __ARGS((exarg_T *eap)); static int getargopt(exarg_T *eap);
static int check_more __ARGS((int, int)); static int check_more(int, int);
static linenr_T get_address __ARGS((char_u **, int skip, int to_other_file)); static linenr_T get_address(char_u **, int skip, int to_other_file);
static void get_flags __ARGS((exarg_T *eap)); static void get_flags(exarg_T *eap);
#if !defined(FEAT_PERL) \ #if !defined(FEAT_PERL) \
|| !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) \ || !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) \
|| !defined(FEAT_TCL) \ || !defined(FEAT_TCL) \
@ -118,49 +118,49 @@ static void get_flags __ARGS((exarg_T *eap));
|| !defined(FEAT_LUA) \ || !defined(FEAT_LUA) \
|| !defined(FEAT_MZSCHEME) || !defined(FEAT_MZSCHEME)
# define HAVE_EX_SCRIPT_NI # define HAVE_EX_SCRIPT_NI
static void ex_script_ni __ARGS((exarg_T *eap)); static void ex_script_ni(exarg_T *eap);
#endif #endif
static char_u *invalid_range __ARGS((exarg_T *eap)); static char_u *invalid_range(exarg_T *eap);
static void correct_range __ARGS((exarg_T *eap)); static void correct_range(exarg_T *eap);
static char_u *replace_makeprg __ARGS((exarg_T *eap, char_u *p, static char_u *replace_makeprg(exarg_T *eap, char_u *p,
char_u **cmdlinep)); char_u **cmdlinep);
static char_u *repl_cmdline __ARGS((exarg_T *eap, char_u *src, int srclen, static char_u *repl_cmdline(exarg_T *eap, char_u *src, int srclen,
char_u *repl, char_u *repl,
char_u **cmdlinep)); char_u **cmdlinep);
static void ex_highlight __ARGS((exarg_T *eap)); static void ex_highlight(exarg_T *eap);
static void ex_colorscheme __ARGS((exarg_T *eap)); static void ex_colorscheme(exarg_T *eap);
static void ex_quit __ARGS((exarg_T *eap)); static void ex_quit(exarg_T *eap);
static void ex_cquit __ARGS((exarg_T *eap)); static void ex_cquit(exarg_T *eap);
static void ex_quit_all __ARGS((exarg_T *eap)); static void ex_quit_all(exarg_T *eap);
static void ex_close __ARGS((exarg_T *eap)); static void ex_close(exarg_T *eap);
static void ex_win_close __ARGS((int forceit, win_T *win, tabpage_T *tp)); static void ex_win_close(int forceit, win_T *win, tabpage_T *tp);
static void ex_only __ARGS((exarg_T *eap)); static void ex_only(exarg_T *eap);
static void ex_resize __ARGS((exarg_T *eap)); static void ex_resize(exarg_T *eap);
static void ex_stag __ARGS((exarg_T *eap)); static void ex_stag(exarg_T *eap);
static void ex_tabclose __ARGS((exarg_T *eap)); static void ex_tabclose(exarg_T *eap);
static void ex_tabonly __ARGS((exarg_T *eap)); static void ex_tabonly(exarg_T *eap);
static void ex_tabnext __ARGS((exarg_T *eap)); static void ex_tabnext(exarg_T *eap);
static void ex_tabmove __ARGS((exarg_T *eap)); static void ex_tabmove(exarg_T *eap);
static void ex_tabs __ARGS((exarg_T *eap)); static void ex_tabs(exarg_T *eap);
static void ex_pclose __ARGS((exarg_T *eap)); static void ex_pclose(exarg_T *eap);
static void ex_ptag __ARGS((exarg_T *eap)); static void ex_ptag(exarg_T *eap);
static void ex_pedit __ARGS((exarg_T *eap)); static void ex_pedit(exarg_T *eap);
static void ex_hide __ARGS((exarg_T *eap)); static void ex_hide(exarg_T *eap);
static void ex_stop __ARGS((exarg_T *eap)); static void ex_stop(exarg_T *eap);
static void ex_exit __ARGS((exarg_T *eap)); static void ex_exit(exarg_T *eap);
static void ex_print __ARGS((exarg_T *eap)); static void ex_print(exarg_T *eap);
static void ex_goto __ARGS((exarg_T *eap)); static void ex_goto(exarg_T *eap);
static void ex_shell __ARGS((exarg_T *eap)); static void ex_shell(exarg_T *eap);
static void ex_preserve __ARGS((exarg_T *eap)); static void ex_preserve(exarg_T *eap);
static void ex_recover __ARGS((exarg_T *eap)); static void ex_recover(exarg_T *eap);
static void ex_mode __ARGS((exarg_T *eap)); static void ex_mode(exarg_T *eap);
static void ex_wrongmodifier __ARGS((exarg_T *eap)); static void ex_wrongmodifier(exarg_T *eap);
static void ex_find __ARGS((exarg_T *eap)); static void ex_find(exarg_T *eap);
static void ex_open __ARGS((exarg_T *eap)); static void ex_open(exarg_T *eap);
static void ex_edit __ARGS((exarg_T *eap)); static void ex_edit(exarg_T *eap);
# define ex_drop ex_ni # define ex_drop ex_ni
# define ex_gui ex_nogui # define ex_gui ex_nogui
static void ex_nogui __ARGS((exarg_T *eap)); static void ex_nogui(exarg_T *eap);
# define ex_tearoff ex_ni # define ex_tearoff ex_ni
# define ex_popup ex_ni # define ex_popup ex_ni
# define ex_simalt ex_ni # define ex_simalt ex_ni
@ -187,70 +187,70 @@ static void ex_nogui __ARGS((exarg_T *eap));
# define ex_rubydo ex_ni # define ex_rubydo ex_ni
# define ex_rubyfile ex_ni # define ex_rubyfile ex_ni
# define ex_sniff ex_ni # define ex_sniff ex_ni
static void ex_swapname __ARGS((exarg_T *eap)); static void ex_swapname(exarg_T *eap);
static void ex_syncbind __ARGS((exarg_T *eap)); static void ex_syncbind(exarg_T *eap);
static void ex_read __ARGS((exarg_T *eap)); static void ex_read(exarg_T *eap);
static void ex_pwd __ARGS((exarg_T *eap)); static void ex_pwd(exarg_T *eap);
static void ex_equal __ARGS((exarg_T *eap)); static void ex_equal(exarg_T *eap);
static void ex_sleep __ARGS((exarg_T *eap)); static void ex_sleep(exarg_T *eap);
static void do_exmap __ARGS((exarg_T *eap, int isabbrev)); static void do_exmap(exarg_T *eap, int isabbrev);
static void ex_winsize __ARGS((exarg_T *eap)); static void ex_winsize(exarg_T *eap);
static void ex_wincmd __ARGS((exarg_T *eap)); static void ex_wincmd(exarg_T *eap);
#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN) #if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
static void ex_winpos __ARGS((exarg_T *eap)); static void ex_winpos(exarg_T *eap);
#else #else
# define ex_winpos ex_ni # define ex_winpos ex_ni
#endif #endif
static void ex_operators __ARGS((exarg_T *eap)); static void ex_operators(exarg_T *eap);
static void ex_put __ARGS((exarg_T *eap)); static void ex_put(exarg_T *eap);
static void ex_copymove __ARGS((exarg_T *eap)); static void ex_copymove(exarg_T *eap);
static void ex_may_print __ARGS((exarg_T *eap)); static void ex_may_print(exarg_T *eap);
static void ex_submagic __ARGS((exarg_T *eap)); static void ex_submagic(exarg_T *eap);
static void ex_join __ARGS((exarg_T *eap)); static void ex_join(exarg_T *eap);
static void ex_at __ARGS((exarg_T *eap)); static void ex_at(exarg_T *eap);
static void ex_bang __ARGS((exarg_T *eap)); static void ex_bang(exarg_T *eap);
static void ex_undo __ARGS((exarg_T *eap)); static void ex_undo(exarg_T *eap);
static void ex_wundo __ARGS((exarg_T *eap)); static void ex_wundo(exarg_T *eap);
static void ex_rundo __ARGS((exarg_T *eap)); static void ex_rundo(exarg_T *eap);
static void ex_redo __ARGS((exarg_T *eap)); static void ex_redo(exarg_T *eap);
static void ex_later __ARGS((exarg_T *eap)); static void ex_later(exarg_T *eap);
static void ex_redir __ARGS((exarg_T *eap)); static void ex_redir(exarg_T *eap);
static void ex_redraw __ARGS((exarg_T *eap)); static void ex_redraw(exarg_T *eap);
static void ex_redrawstatus __ARGS((exarg_T *eap)); static void ex_redrawstatus(exarg_T *eap);
static void close_redir __ARGS((void)); static void close_redir(void);
static void ex_mkrc __ARGS((exarg_T *eap)); static void ex_mkrc(exarg_T *eap);
static void ex_mark __ARGS((exarg_T *eap)); static void ex_mark(exarg_T *eap);
static char_u *uc_fun_cmd __ARGS((void)); static char_u *uc_fun_cmd(void);
static char_u *find_ucmd __ARGS((exarg_T *eap, char_u *p, int *full, static char_u *find_ucmd(exarg_T *eap, char_u *p, int *full,
expand_T *xp, expand_T *xp,
int *compl)); int *compl);
static void ex_normal __ARGS((exarg_T *eap)); static void ex_normal(exarg_T *eap);
static void ex_startinsert __ARGS((exarg_T *eap)); static void ex_startinsert(exarg_T *eap);
static void ex_stopinsert __ARGS((exarg_T *eap)); static void ex_stopinsert(exarg_T *eap);
static void ex_checkpath __ARGS((exarg_T *eap)); static void ex_checkpath(exarg_T *eap);
static void ex_findpat __ARGS((exarg_T *eap)); static void ex_findpat(exarg_T *eap);
static void ex_psearch __ARGS((exarg_T *eap)); static void ex_psearch(exarg_T *eap);
static void ex_tag __ARGS((exarg_T *eap)); static void ex_tag(exarg_T *eap);
static void ex_tag_cmd __ARGS((exarg_T *eap, char_u *name)); static void ex_tag_cmd(exarg_T *eap, char_u *name);
static char_u *arg_all __ARGS((void)); static char_u *arg_all(void);
static int makeopens __ARGS((FILE *fd, char_u *dirnow)); static int makeopens(FILE *fd, char_u *dirnow);
static int put_view __ARGS((FILE *fd, win_T *wp, int add_edit, unsigned *flagp, static int put_view(FILE *fd, win_T *wp, int add_edit, unsigned *flagp,
int current_arg_idx)); int current_arg_idx);
static void ex_loadview __ARGS((exarg_T *eap)); static void ex_loadview(exarg_T *eap);
static char_u *get_view_file __ARGS((int c)); static char_u *get_view_file(int c);
static int did_lcd; /* whether ":lcd" was produced for a session */ static int did_lcd; /* whether ":lcd" was produced for a session */
static void ex_viminfo __ARGS((exarg_T *eap)); static void ex_viminfo(exarg_T *eap);
static void ex_behave __ARGS((exarg_T *eap)); static void ex_behave(exarg_T *eap);
static void ex_filetype __ARGS((exarg_T *eap)); static void ex_filetype(exarg_T *eap);
static void ex_setfiletype __ARGS((exarg_T *eap)); static void ex_setfiletype(exarg_T *eap);
static void ex_digraphs __ARGS((exarg_T *eap)); static void ex_digraphs(exarg_T *eap);
static void ex_set __ARGS((exarg_T *eap)); static void ex_set(exarg_T *eap);
static void ex_nohlsearch __ARGS((exarg_T *eap)); static void ex_nohlsearch(exarg_T *eap);
static void ex_match __ARGS((exarg_T *eap)); static void ex_match(exarg_T *eap);
static void ex_X __ARGS((exarg_T *eap)); static void ex_X(exarg_T *eap);
static void ex_fold __ARGS((exarg_T *eap)); static void ex_fold(exarg_T *eap);
static void ex_foldopen __ARGS((exarg_T *eap)); static void ex_foldopen(exarg_T *eap);
static void ex_folddo __ARGS((exarg_T *eap)); static void ex_folddo(exarg_T *eap);
#ifndef HAVE_WORKING_LIBINTL #ifndef HAVE_WORKING_LIBINTL
# define ex_language ex_ni # define ex_language ex_ni
#endif #endif
@ -322,13 +322,13 @@ struct loop_cookie {
int current_line; /* last read line from growarray */ int current_line; /* last read line from growarray */
int repeating; /* TRUE when looping a second time */ int repeating; /* TRUE when looping a second time */
/* When "repeating" is FALSE use "getline" and "cookie" to get lines */ /* When "repeating" is FALSE use "getline" and "cookie" to get lines */
char_u *(*getline)__ARGS((int, void *, int)); char_u *(*getline)(int, void *, int);
void *cookie; void *cookie;
}; };
static char_u *get_loop_line __ARGS((int c, void *cookie, int indent)); static char_u *get_loop_line(int c, void *cookie, int indent);
static int store_loop_line __ARGS((garray_T *gap, char_u *line)); static int store_loop_line(garray_T *gap, char_u *line);
static void free_cmdlines __ARGS((garray_T *gap)); static void free_cmdlines(garray_T *gap);
/* Struct to save a few things while debugging. Used in do_cmdline() only. */ /* Struct to save a few things while debugging. Used in do_cmdline() only. */
struct dbg_stuff { struct dbg_stuff {
@ -345,8 +345,8 @@ struct dbg_stuff {
except_T *current_exception; except_T *current_exception;
}; };
static void save_dbg_stuff __ARGS((struct dbg_stuff *dsp)); static void save_dbg_stuff(struct dbg_stuff *dsp);
static void restore_dbg_stuff __ARGS((struct dbg_stuff *dsp)); static void restore_dbg_stuff(struct dbg_stuff *dsp);
static void save_dbg_stuff(struct dbg_stuff *dsp) static void save_dbg_stuff(struct dbg_stuff *dsp)
{ {
@ -493,7 +493,7 @@ int do_cmdline_cmd(char_u *cmd)
*/ */
int do_cmdline(cmdline, fgetline, cookie, flags) int do_cmdline(cmdline, fgetline, cookie, flags)
char_u *cmdline; char_u *cmdline;
char_u *(*fgetline)__ARGS((int, void *, int)); char_u *(*fgetline)(int, void *, int);
void *cookie; /* argument for fgetline() */ void *cookie; /* argument for fgetline() */
int flags; int flags;
{ {
@ -517,7 +517,7 @@ int flags;
struct msglist *private_msg_list; struct msglist *private_msg_list;
/* "fgetline" and "cookie" passed to do_one_cmd() */ /* "fgetline" and "cookie" passed to do_one_cmd() */
char_u *(*cmd_getline)__ARGS((int, void *, int)); char_u *(*cmd_getline)(int, void *, int);
void *cmd_cookie; void *cmd_cookie;
struct loop_cookie cmd_loop_cookie; struct loop_cookie cmd_loop_cookie;
void *real_cookie; void *real_cookie;
@ -1226,11 +1226,11 @@ static void free_cmdlines(garray_T *gap)
* "func". * Otherwise return TRUE when "fgetline" equals "func". * "func". * Otherwise return TRUE when "fgetline" equals "func".
*/ */
int getline_equal(fgetline, cookie, func) int getline_equal(fgetline, cookie, func)
char_u *(*fgetline)__ARGS((int, void *, int)); char_u *(*fgetline)(int, void *, int);
void *cookie; /* argument for fgetline() */ void *cookie; /* argument for fgetline() */
char_u *(*func)__ARGS((int, void *, int)); char_u *(*func)(int, void *, int);
{ {
char_u *(*gp)__ARGS((int, void *, int)); char_u *(*gp)(int, void *, int);
struct loop_cookie *cp; struct loop_cookie *cp;
/* When "fgetline" is "get_loop_line()" use the "cookie" to find the /* When "fgetline" is "get_loop_line()" use the "cookie" to find the
@ -1250,10 +1250,10 @@ char_u *(*func)__ARGS((int, void *, int));
* getline function. Otherwise return "cookie". * getline function. Otherwise return "cookie".
*/ */
void * getline_cookie(fgetline, cookie) void * getline_cookie(fgetline, cookie)
char_u *(*fgetline)__ARGS((int, void *, int)); char_u *(*fgetline)(int, void *, int);
void *cookie; /* argument for fgetline() */ void *cookie; /* argument for fgetline() */
{ {
char_u *(*gp)__ARGS((int, void *, int)); char_u *(*gp)(int, void *, int);
struct loop_cookie *cp; struct loop_cookie *cp;
/* When "fgetline" is "get_loop_line()" use the "cookie" to find the /* When "fgetline" is "get_loop_line()" use the "cookie" to find the
@ -1290,8 +1290,8 @@ static char_u * do_one_cmd(cmdlinep, sourcing,
char_u **cmdlinep; char_u **cmdlinep;
int sourcing; int sourcing;
struct condstack *cstack; struct condstack *cstack;
char_u *(*fgetline)__ARGS((int, void *, int)); char_u *(*fgetline)(int, void *, int);
void *cookie; /* argument for fgetline() */ void *cookie; /*argument for fgetline() */
{ {
char_u *p; char_u *p;
linenr_T lnum; linenr_T lnum;
@ -3528,7 +3528,7 @@ static void correct_range(exarg_T *eap)
} }
} }
static char_u *skip_grep_pat __ARGS((exarg_T *eap)); static char_u *skip_grep_pat(exarg_T *eap);
/* /*
* For a ":vimgrep" or ":vimgrepadd" command return a pointer past the * For a ":vimgrep" or ":vimgrepadd" command return a pointer past the
@ -4315,19 +4315,18 @@ char_u *get_command_name(expand_T *xp, int idx)
return cmdnames[idx].cmd_name; return cmdnames[idx].cmd_name;
} }
static int uc_add_command __ARGS((char_u *name, size_t name_len, char_u *rep, static int uc_add_command(char_u *name, size_t name_len, char_u *rep,
long argt, long def, int flags, int compl, long argt, long def, int flags, int compl,
char_u *compl_arg, char_u *compl_arg,
int force)); int force);
static void uc_list __ARGS((char_u *name, size_t name_len)); static void uc_list(char_u *name, size_t name_len);
static int uc_scan_attr __ARGS((char_u *attr, size_t len, long *argt, long *def, static int uc_scan_attr(char_u *attr, size_t len, long *argt, long *def,
int *flags, int *compl, int *flags, int *compl,
char_u **compl_arg)); char_u **compl_arg);
static char_u *uc_split_args __ARGS((char_u *arg, size_t *lenp)); static char_u *uc_split_args(char_u *arg, size_t *lenp);
static size_t uc_check_code __ARGS((char_u *code, size_t len, char_u *buf, static size_t uc_check_code(char_u *code, size_t len, char_u *buf,
ucmd_T *cmd, exarg_T *eap, char_u * ucmd_T *cmd, exarg_T *eap, char_u **split_buf,
*split_buf, size_t *split_len);
size_t *split_len));
static int uc_add_command(char_u *name, size_t name_len, char_u *rep, long argt, long def, int flags, int compl, char_u *compl_arg, int force) static int uc_add_command(char_u *name, size_t name_len, char_u *rep, long argt, long def, int flags, int compl, char_u *compl_arg, int force)
{ {
@ -8182,16 +8181,15 @@ char_u *expand_sfile(char_u *arg)
return result; return result;
} }
static int ses_winsizes __ARGS((FILE *fd, int restore_size, static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin);
win_T *tab_firstwin)); static int ses_win_rec(FILE *fd, frame_T *fr);
static int ses_win_rec __ARGS((FILE *fd, frame_T *fr)); static frame_T *ses_skipframe(frame_T *fr);
static frame_T *ses_skipframe __ARGS((frame_T *fr)); static int ses_do_frame(frame_T *fr);
static int ses_do_frame __ARGS((frame_T *fr)); static int ses_do_win(win_T *wp);
static int ses_do_win __ARGS((win_T *wp)); static int ses_arglist(FILE *fd, char *cmd, garray_T *gap, int fullname,
static int ses_arglist __ARGS((FILE *fd, char *cmd, garray_T *gap, int fullname, unsigned *flagp);
unsigned *flagp)); static int ses_put_fname(FILE *fd, char_u *name, unsigned *flagp);
static int ses_put_fname __ARGS((FILE *fd, char_u *name, unsigned *flagp)); static int ses_fname(FILE *fd, buf_T *buf, unsigned *flagp);
static int ses_fname __ARGS((FILE *fd, buf_T *buf, unsigned *flagp));
/* /*
* Write openfile commands for the current buffers to an .exrc file. * Write openfile commands for the current buffers to an .exrc file.

125
src/ex_docmd.h
View File

@ -1,72 +1,69 @@
#ifndef NEOVIM_EX_DOCMD_H #ifndef NEOVIM_EX_DOCMD_H
#define NEOVIM_EX_DOCMD_H #define NEOVIM_EX_DOCMD_H
/* ex_docmd.c */ /* ex_docmd.c */
void do_exmode __ARGS((int improved)); void do_exmode(int improved);
int do_cmdline_cmd __ARGS((char_u *cmd)); int do_cmdline_cmd(char_u *cmd);
int do_cmdline __ARGS((char_u *cmdline, char_u * int do_cmdline(char_u *cmdline, char_u *
(*fgetline)(int, void *, int), void *cookie, (*fgetline)(int, void *, int), void *cookie,
int flags)); int flags);
int getline_equal __ARGS((char_u * int getline_equal(char_u *
(*fgetline)(int, void *, (*fgetline)(int, void *, int), void *cookie, char_u *
int), void *cookie, char_u * (*func)(int, void *, int));
(*func)(int, void *, void *getline_cookie(char_u *(*fgetline)(int, void *, int), void *cookie);
int))); int checkforcmd(char_u **pp, char *cmd, int len);
void *getline_cookie __ARGS((char_u *(*fgetline)(int, void *, int), int modifier_len(char_u *cmd);
void *cookie)); int cmd_exists(char_u *name);
int checkforcmd __ARGS((char_u **pp, char *cmd, int len)); char_u *set_one_cmd_context(expand_T *xp, char_u *buff);
int modifier_len __ARGS((char_u *cmd)); char_u *skip_range(char_u *cmd, int *ctx);
int cmd_exists __ARGS((char_u *name)); void ex_ni(exarg_T *eap);
char_u *set_one_cmd_context __ARGS((expand_T *xp, char_u *buff)); int expand_filename(exarg_T *eap, char_u **cmdlinep, char_u **errormsgp);
char_u *skip_range __ARGS((char_u *cmd, int *ctx)); void separate_nextcmd(exarg_T *eap);
void ex_ni __ARGS((exarg_T *eap)); int ends_excmd(int c);
int expand_filename __ARGS((exarg_T *eap, char_u **cmdlinep, char_u **errormsgp)); char_u *find_nextcmd(char_u *p);
void separate_nextcmd __ARGS((exarg_T *eap)); char_u *check_nextcmd(char_u *p);
int ends_excmd __ARGS((int c)); char_u *get_command_name(expand_T *xp, int idx);
char_u *find_nextcmd __ARGS((char_u *p)); void ex_comclear(exarg_T *eap);
char_u *check_nextcmd __ARGS((char_u *p)); void uc_clear(garray_T *gap);
char_u *get_command_name __ARGS((expand_T *xp, int idx)); char_u *get_user_commands(expand_T *xp, int idx);
void ex_comclear __ARGS((exarg_T *eap)); char_u *get_user_cmd_flags(expand_T *xp, int idx);
void uc_clear __ARGS((garray_T *gap)); char_u *get_user_cmd_nargs(expand_T *xp, int idx);
char_u *get_user_commands __ARGS((expand_T *xp, int idx)); char_u *get_user_cmd_complete(expand_T *xp, int idx);
char_u *get_user_cmd_flags __ARGS((expand_T *xp, int idx)); int parse_compl_arg(char_u *value, int vallen, int *complp, long *argt,
char_u *get_user_cmd_nargs __ARGS((expand_T *xp, int idx)); char_u **compl_arg);
char_u *get_user_cmd_complete __ARGS((expand_T *xp, int idx)); void not_exiting(void);
int parse_compl_arg __ARGS((char_u *value, int vallen, int *complp, long *argt, void tabpage_close(int forceit);
char_u **compl_arg)); void tabpage_close_other(tabpage_T *tp, int forceit);
void not_exiting __ARGS((void)); void ex_all(exarg_T *eap);
void tabpage_close __ARGS((int forceit)); void handle_drop(int filec, char_u **filev, int split);
void tabpage_close_other __ARGS((tabpage_T *tp, int forceit)); void alist_clear(alist_T *al);
void ex_all __ARGS((exarg_T *eap)); void alist_init(alist_T *al);
void handle_drop __ARGS((int filec, char_u **filev, int split)); void alist_unlink(alist_T *al);
void alist_clear __ARGS((alist_T *al)); void alist_new(void);
void alist_init __ARGS((alist_T *al)); void alist_expand(int *fnum_list, int fnum_len);
void alist_unlink __ARGS((alist_T *al)); void alist_set(alist_T *al, int count, char_u **files, int use_curbuf,
void alist_new __ARGS((void));
void alist_expand __ARGS((int *fnum_list, int fnum_len));
void alist_set __ARGS((alist_T *al, int count, char_u **files, int use_curbuf,
int *fnum_list, int *fnum_list,
int fnum_len)); int fnum_len);
void alist_add __ARGS((alist_T *al, char_u *fname, int set_fnum)); void alist_add(alist_T *al, char_u *fname, int set_fnum);
void alist_slash_adjust __ARGS((void)); void alist_slash_adjust(void);
void ex_splitview __ARGS((exarg_T *eap)); void ex_splitview(exarg_T *eap);
void tabpage_new __ARGS((void)); void tabpage_new(void);
void do_exedit __ARGS((exarg_T *eap, win_T *old_curwin)); void do_exedit(exarg_T *eap, win_T *old_curwin);
void free_cd_dir __ARGS((void)); void free_cd_dir(void);
void post_chdir __ARGS((int local)); void post_chdir(int local);
void ex_cd __ARGS((exarg_T *eap)); void ex_cd(exarg_T *eap);
void do_sleep __ARGS((long msec)); void do_sleep(long msec);
int vim_mkdir_emsg __ARGS((char_u *name, int prot)); int vim_mkdir_emsg(char_u *name, int prot);
FILE *open_exfile __ARGS((char_u *fname, int forceit, char *mode)); FILE *open_exfile(char_u *fname, int forceit, char *mode);
void update_topline_cursor __ARGS((void)); void update_topline_cursor(void);
void exec_normal_cmd __ARGS((char_u *cmd, int remap, int silent)); void exec_normal_cmd(char_u *cmd, int remap, int silent);
int find_cmdline_var __ARGS((char_u *src, int *usedlen)); int find_cmdline_var(char_u *src, int *usedlen);
char_u *eval_vars __ARGS((char_u *src, char_u *srcstart, int *usedlen, char_u *eval_vars(char_u *src, char_u *srcstart, int *usedlen,
linenr_T *lnump, char_u **errormsg, linenr_T *lnump, char_u **errormsg,
int *escaped)); int *escaped);
char_u *expand_sfile __ARGS((char_u *arg)); char_u *expand_sfile(char_u *arg);
int put_eol __ARGS((FILE *fd)); int put_eol(FILE *fd);
int put_line __ARGS((FILE *fd, char *s)); int put_line(FILE *fd, char *s);
void dialog_msg __ARGS((char_u *buff, char *format, char_u *fname)); void dialog_msg(char_u *buff, char *format, char_u *fname);
char_u *get_behave_arg __ARGS((expand_T *xp, int idx)); char_u *get_behave_arg(expand_T *xp, int idx);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EX_DOCMD_H */ #endif /* NEOVIM_EX_DOCMD_H */

14
src/ex_eval.c
View File

@ -22,9 +22,9 @@
#include "regexp.h" #include "regexp.h"
static void free_msglist __ARGS((struct msglist *l)); static void free_msglist(struct msglist *l);
static int throw_exception __ARGS((void *, int, char_u *)); static int throw_exception(void *, int, char_u *);
static char_u *get_end_emsg __ARGS((struct condstack *cstack)); static char_u *get_end_emsg(struct condstack *cstack);
/* /*
* Exception handling terms: * Exception handling terms:
@ -65,10 +65,10 @@ static char_u *get_end_emsg __ARGS((struct condstack *cstack));
# define THROW_ON_INTERRUPT TRUE # define THROW_ON_INTERRUPT TRUE
# define THROW_ON_INTERRUPT_TRUE # define THROW_ON_INTERRUPT_TRUE
static void catch_exception __ARGS((except_T *excp)); static void catch_exception(except_T *excp);
static void finish_exception __ARGS((except_T *excp)); static void finish_exception(except_T *excp);
static void discard_exception __ARGS((except_T *excp, int was_finished)); static void discard_exception(except_T *excp, int was_finished);
static void report_pending __ARGS((int action, int pending, void *value)); static void report_pending(int action, int pending, void *value);
/* /*
* When several errors appear in a row, setting "force_abort" is delayed until * When several errors appear in a row, setting "force_abort" is delayed until

70
src/ex_eval.h
View File

@ -1,41 +1,41 @@
#ifndef NEOVIM_EX_EVAL_H #ifndef NEOVIM_EX_EVAL_H
#define NEOVIM_EX_EVAL_H #define NEOVIM_EX_EVAL_H
/* ex_eval.c */ /* ex_eval.c */
int aborting __ARGS((void)); int aborting(void);
void update_force_abort __ARGS((void)); void update_force_abort(void);
int should_abort __ARGS((int retcode)); int should_abort(int retcode);
int aborted_in_try __ARGS((void)); int aborted_in_try(void);
int cause_errthrow __ARGS((char_u *mesg, int severe, int *ignore)); int cause_errthrow(char_u *mesg, int severe, int *ignore);
void free_global_msglist __ARGS((void)); void free_global_msglist(void);
void do_errthrow __ARGS((struct condstack *cstack, char_u *cmdname)); void do_errthrow(struct condstack *cstack, char_u *cmdname);
int do_intthrow __ARGS((struct condstack *cstack)); int do_intthrow(struct condstack *cstack);
char_u *get_exception_string __ARGS((void *value, int type, char_u *cmdname, char_u *get_exception_string(void *value, int type, char_u *cmdname,
int *should_free)); int *should_free);
void discard_current_exception __ARGS((void)); void discard_current_exception(void);
void report_make_pending __ARGS((int pending, void *value)); void report_make_pending(int pending, void *value);
void report_resume_pending __ARGS((int pending, void *value)); void report_resume_pending(int pending, void *value);
void report_discard_pending __ARGS((int pending, void *value)); void report_discard_pending(int pending, void *value);
void ex_if __ARGS((exarg_T *eap)); void ex_if(exarg_T *eap);
void ex_endif __ARGS((exarg_T *eap)); void ex_endif(exarg_T *eap);
void ex_else __ARGS((exarg_T *eap)); void ex_else(exarg_T *eap);
void ex_while __ARGS((exarg_T *eap)); void ex_while(exarg_T *eap);
void ex_continue __ARGS((exarg_T *eap)); void ex_continue(exarg_T *eap);
void ex_break __ARGS((exarg_T *eap)); void ex_break(exarg_T *eap);
void ex_endwhile __ARGS((exarg_T *eap)); void ex_endwhile(exarg_T *eap);
void ex_throw __ARGS((exarg_T *eap)); void ex_throw(exarg_T *eap);
void do_throw __ARGS((struct condstack *cstack)); void do_throw(struct condstack *cstack);
void ex_try __ARGS((exarg_T *eap)); void ex_try(exarg_T *eap);
void ex_catch __ARGS((exarg_T *eap)); void ex_catch(exarg_T *eap);
void ex_finally __ARGS((exarg_T *eap)); void ex_finally(exarg_T *eap);
void ex_endtry __ARGS((exarg_T *eap)); void ex_endtry(exarg_T *eap);
void enter_cleanup __ARGS((cleanup_T *csp)); void enter_cleanup(cleanup_T *csp);
void leave_cleanup __ARGS((cleanup_T *csp)); void leave_cleanup(cleanup_T *csp);
int cleanup_conditionals __ARGS((struct condstack *cstack, int searched_cond, int cleanup_conditionals(struct condstack *cstack, int searched_cond,
int inclusive)); int inclusive);
void rewind_conditionals __ARGS((struct condstack *cstack, int idx, void rewind_conditionals(struct condstack *cstack, int idx,
int cond_type, int cond_type,
int *cond_level)); int *cond_level);
void ex_endfunction __ARGS((exarg_T *eap)); void ex_endfunction(exarg_T *eap);
int has_loop_cmd __ARGS((char_u *p)); int has_loop_cmd(char_u *p);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EX_EVAL_H */ #endif /* NEOVIM_EX_EVAL_H */

93
src/ex_getln.c
View File

@ -92,52 +92,50 @@ static int hisnum[HIST_COUNT] = {0, 0, 0, 0, 0};
/* identifying (unique) number of newest history entry */ /* identifying (unique) number of newest history entry */
static int hislen = 0; /* actual length of history tables */ static int hislen = 0; /* actual length of history tables */
static int hist_char2type __ARGS((int c)); static int hist_char2type(int c);
static int in_history __ARGS((int, char_u *, int, int, int)); static int in_history(int, char_u *, int, int, int);
static int calc_hist_idx __ARGS((int histype, int num)); static int calc_hist_idx(int histype, int num);
static int cmd_hkmap = 0; /* Hebrew mapping during command line */ static int cmd_hkmap = 0; /* Hebrew mapping during command line */
static int cmd_fkmap = 0; /* Farsi mapping during command line */ static int cmd_fkmap = 0; /* Farsi mapping during command line */
static int cmdline_charsize __ARGS((int idx)); static int cmdline_charsize(int idx);
static void set_cmdspos __ARGS((void)); static void set_cmdspos(void);
static void set_cmdspos_cursor __ARGS((void)); static void set_cmdspos_cursor(void);
static void correct_cmdspos __ARGS((int idx, int cells)); static void correct_cmdspos(int idx, int cells);
static void alloc_cmdbuff __ARGS((int len)); static void alloc_cmdbuff(int len);
static int realloc_cmdbuff __ARGS((int len)); static int realloc_cmdbuff(int len);
static void draw_cmdline __ARGS((int start, int len)); static void draw_cmdline(int start, int len);
static void save_cmdline __ARGS((struct cmdline_info *ccp)); static void save_cmdline(struct cmdline_info *ccp);
static void restore_cmdline __ARGS((struct cmdline_info *ccp)); static void restore_cmdline(struct cmdline_info *ccp);
static int cmdline_paste __ARGS((int regname, int literally, int remcr)); static int cmdline_paste(int regname, int literally, int remcr);
static void cmdline_del __ARGS((int from)); static void cmdline_del(int from);
static void redrawcmdprompt __ARGS((void)); static void redrawcmdprompt(void);
static void cursorcmd __ARGS((void)); static void cursorcmd(void);
static int ccheck_abbr __ARGS((int)); static int ccheck_abbr(int);
static int nextwild __ARGS((expand_T *xp, int type, int options, int escape)); static int nextwild(expand_T *xp, int type, int options, int escape);
static void escape_fname __ARGS((char_u **pp)); static void escape_fname(char_u **pp);
static int showmatches __ARGS((expand_T *xp, int wildmenu)); static int showmatches(expand_T *xp, int wildmenu);
static void set_expand_context __ARGS((expand_T *xp)); static void set_expand_context(expand_T *xp);
static int ExpandFromContext __ARGS((expand_T *xp, char_u *, int *, char_u ***, static int ExpandFromContext(expand_T *xp, char_u *, int *, char_u ***, int);
int)); static int expand_showtail(expand_T *xp);
static int expand_showtail __ARGS((expand_T *xp)); static int expand_shellcmd(char_u *filepat, int *num_file,
static int expand_shellcmd __ARGS((char_u *filepat, int *num_file, char_u * char_u ***file,
**file, int flagsarg);
int flagsarg)); static int ExpandRTDir(char_u *pat, int *num_file, char_u ***file,
static int ExpandRTDir __ARGS((char_u *pat, int *num_file, char_u ***file, char *dirname[]);
char *dirname[])); static char_u *get_history_arg(expand_T *xp, int idx);
static char_u *get_history_arg __ARGS((expand_T *xp, int idx)); static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch,
static int ExpandUserDefined __ARGS((expand_T *xp, regmatch_T *regmatch,
int *num_file, int *num_file,
char_u ***file)); char_u ***file);
static int ExpandUserList __ARGS((expand_T *xp, int *num_file, char_u ***file)); static int ExpandUserList(expand_T *xp, int *num_file, char_u ***file);
static void clear_hist_entry __ARGS((histentry_T *hisptr)); static void clear_hist_entry(histentry_T *hisptr);
static int ex_window __ARGS((void)); static int ex_window(void);
static int static int sort_func_compare(const void *s1, const void *s2);
sort_func_compare __ARGS((const void *s1, const void *s2));
/* /*
* getcmdline() - accept a command line starting with firstc. * getcmdline() - accept a command line starting with firstc.
@ -3621,7 +3619,7 @@ expand_cmdline (
/* /*
* Cleanup matches for help tags: remove "@en" if "en" is the only language. * Cleanup matches for help tags: remove "@en" if "en" is the only language.
*/ */
static void cleanup_help_tags __ARGS((int num_file, char_u **file)); static void cleanup_help_tags(int num_file, char_u **file);
static void cleanup_help_tags(int num_file, char_u **file) static void cleanup_help_tags(int num_file, char_u **file)
{ {
@ -3771,7 +3769,7 @@ ExpandFromContext (
else { else {
static struct expgen { static struct expgen {
int context; int context;
char_u *((*func)__ARGS((expand_T *, int))); char_u *((*func)(expand_T *, int));
int ic; int ic;
int escaped; int escaped;
} tab[] = } tab[] =
@ -3839,7 +3837,7 @@ expand_T *xp;
regmatch_T *regmatch; regmatch_T *regmatch;
int *num_file; int *num_file;
char_u ***file; char_u ***file;
char_u *((*func)__ARGS((expand_T *, int))); char_u *((*func)(expand_T *, int));
/* returns a string from the list */ /* returns a string from the list */
int escaped; int escaped;
{ {
@ -4008,18 +4006,17 @@ expand_shellcmd (
return OK; return OK;
} }
typedef void *(*user_expand_func_T)(char_u *, int, char_u **, int);
static void * call_user_expand_func __ARGS((void *(*user_expand_func)__ARGS( static void * call_user_expand_func(user_expand_func_T user_expand_func,
(char_u *, int, char_u **, expand_T *xp, int *num_file,
int)), expand_T *xp, char_u ***file);
int *num_file, char_u ***file));
/* /*
* Call "user_expand_func()" to invoke a user defined VimL function and return * Call "user_expand_func()" to invoke a user defined VimL function and return
* the result (either a string or a List). * the result (either a string or a List).
*/ */
static void * call_user_expand_func(user_expand_func, xp, num_file, file) static void * call_user_expand_func(user_expand_func, xp, num_file, file)
void *(*user_expand_func)__ARGS((char_u *, int, char_u **, int)); user_expand_func_T user_expand_func;
expand_T *xp; expand_T *xp;
int *num_file; int *num_file;
char_u ***file; char_u ***file;
@ -4552,7 +4549,7 @@ int get_history_idx(int histype)
return history[histype][hisidx[histype]].hisnum; return history[histype][hisidx[histype]].hisnum;
} }
static struct cmdline_info *get_ccline_ptr __ARGS((void)); static struct cmdline_info *get_ccline_ptr(void);
/* /*
* Get pointer to the command line info to use. cmdline_paste() may clear * Get pointer to the command line info to use. cmdline_paste() may clear
@ -4936,7 +4933,7 @@ static int viminfo_hisidx[HIST_COUNT] = {0, 0, 0, 0};
static int viminfo_hislen[HIST_COUNT] = {0, 0, 0, 0}; static int viminfo_hislen[HIST_COUNT] = {0, 0, 0, 0};
static int viminfo_add_at_front = FALSE; static int viminfo_add_at_front = FALSE;
static int hist_type2char __ARGS((int type, int use_question)); static int hist_type2char(int type, int use_question);
/* /*
* Translate a history type number to the associated character. * Translate a history type number to the associated character.

122
src/ex_getln.h
View File

@ -1,69 +1,69 @@
#ifndef NEOVIM_EX_GETLN_H #ifndef NEOVIM_EX_GETLN_H
#define NEOVIM_EX_GETLN_H #define NEOVIM_EX_GETLN_H
/* ex_getln.c */ /* ex_getln.c */
char_u *getcmdline __ARGS((int firstc, long count, int indent)); char_u *getcmdline(int firstc, long count, int indent);
char_u *getcmdline_prompt __ARGS((int firstc, char_u *prompt, int attr, char_u *getcmdline_prompt(int firstc, char_u *prompt, int attr,
int xp_context, int xp_context,
char_u *xp_arg)); char_u *xp_arg);
int text_locked __ARGS((void)); int text_locked(void);
void text_locked_msg __ARGS((void)); void text_locked_msg(void);
int curbuf_locked __ARGS((void)); int curbuf_locked(void);
int allbuf_locked __ARGS((void)); int allbuf_locked(void);
char_u *getexline __ARGS((int c, void *cookie, int indent)); char_u *getexline(int c, void *cookie, int indent);
char_u *getexmodeline __ARGS((int promptc, void *cookie, int indent)); char_u *getexmodeline(int promptc, void *cookie, int indent);
int cmdline_overstrike __ARGS((void)); int cmdline_overstrike(void);
int cmdline_at_end __ARGS((void)); int cmdline_at_end(void);
colnr_T cmdline_getvcol_cursor __ARGS((void)); colnr_T cmdline_getvcol_cursor(void);
void free_cmdline_buf __ARGS((void)); void free_cmdline_buf(void);
void putcmdline __ARGS((int c, int shift)); void putcmdline(int c, int shift);
void unputcmdline __ARGS((void)); void unputcmdline(void);
int put_on_cmdline __ARGS((char_u *str, int len, int redraw)); int put_on_cmdline(char_u *str, int len, int redraw);
char_u *save_cmdline_alloc __ARGS((void)); char_u *save_cmdline_alloc(void);
void restore_cmdline_alloc __ARGS((char_u *p)); void restore_cmdline_alloc(char_u *p);
void cmdline_paste_str __ARGS((char_u *s, int literally)); void cmdline_paste_str(char_u *s, int literally);
void redrawcmdline __ARGS((void)); void redrawcmdline(void);
void redrawcmd __ARGS((void)); void redrawcmd(void);
void compute_cmdrow __ARGS((void)); void compute_cmdrow(void);
void gotocmdline __ARGS((int clr)); void gotocmdline(int clr);
char_u *ExpandOne __ARGS((expand_T *xp, char_u *str, char_u *orig, int options, char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options,
int mode)); int mode);
void ExpandInit __ARGS((expand_T *xp)); void ExpandInit(expand_T *xp);
void ExpandCleanup __ARGS((expand_T *xp)); void ExpandCleanup(expand_T *xp);
void ExpandEscape __ARGS((expand_T *xp, char_u *str, int numfiles, char_u * void ExpandEscape(expand_T *xp, char_u *str, int numfiles, char_u *
*files, *files,
int options)); int options);
char_u *vim_strsave_fnameescape __ARGS((char_u *fname, int shell)); char_u *vim_strsave_fnameescape(char_u *fname, int shell);
void tilde_replace __ARGS((char_u *orig_pat, int num_files, char_u **files)); void tilde_replace(char_u *orig_pat, int num_files, char_u **files);
char_u *sm_gettail __ARGS((char_u *s)); char_u *sm_gettail(char_u *s);
char_u *addstar __ARGS((char_u *fname, int len, int context)); char_u *addstar(char_u *fname, int len, int context);
void set_cmd_context __ARGS((expand_T *xp, char_u *str, int len, int col)); void set_cmd_context(expand_T *xp, char_u *str, int len, int col);
int expand_cmdline __ARGS((expand_T *xp, char_u *str, int col, int *matchcount, int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount,
char_u ***matches)); char_u ***matches);
int ExpandGeneric __ARGS((expand_T *xp, regmatch_T *regmatch, int *num_file, int ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file,
char_u ***file, char_u *((*func)(expand_T *, int)), char_u ***file, char_u *((*func)(expand_T *, int)),
int escaped)); int escaped);
char_u *globpath __ARGS((char_u *path, char_u *file, int expand_options)); char_u *globpath(char_u *path, char_u *file, int expand_options);
void init_history __ARGS((void)); void init_history(void);
int get_histtype __ARGS((char_u *name)); int get_histtype(char_u *name);
void add_to_history __ARGS((int histype, char_u *new_entry, int in_map, int sep)); void add_to_history(int histype, char_u *new_entry, int in_map, int sep);
int get_history_idx __ARGS((int histype)); int get_history_idx(int histype);
char_u *get_cmdline_str __ARGS((void)); char_u *get_cmdline_str(void);
int get_cmdline_pos __ARGS((void)); int get_cmdline_pos(void);
int set_cmdline_pos __ARGS((int pos)); int set_cmdline_pos(int pos);
int get_cmdline_type __ARGS((void)); int get_cmdline_type(void);
char_u *get_history_entry __ARGS((int histype, int idx)); char_u *get_history_entry(int histype, int idx);
int clr_history __ARGS((int histype)); int clr_history(int histype);
int del_history_entry __ARGS((int histype, char_u *str)); int del_history_entry(int histype, char_u *str);
int del_history_idx __ARGS((int histype, int idx)); int del_history_idx(int histype, int idx);
void remove_key_from_history __ARGS((void)); void remove_key_from_history(void);
int get_list_range __ARGS((char_u **str, int *num1, int *num2)); int get_list_range(char_u **str, int *num1, int *num2);
void ex_history __ARGS((exarg_T *eap)); void ex_history(exarg_T *eap);
void prepare_viminfo_history __ARGS((int asklen, int writing)); void prepare_viminfo_history(int asklen, int writing);
int read_viminfo_history __ARGS((vir_T *virp, int writing)); int read_viminfo_history(vir_T *virp, int writing);
void finish_viminfo_history __ARGS((void)); void finish_viminfo_history(void);
void write_viminfo_history __ARGS((FILE *fp, int merge)); void write_viminfo_history(FILE *fp, int merge);
void cmd_pchar __ARGS((int c, int offset)); void cmd_pchar(int c, int offset);
int cmd_gchar __ARGS((int offset)); int cmd_gchar(int offset);
char_u *script_get __ARGS((exarg_T *eap, char_u *cmd)); char_u *script_get(exarg_T *eap, char_u *cmd);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_EX_GETLN_H */ #endif /* NEOVIM_EX_GETLN_H */

40
src/farsi.c
View File

@ -17,26 +17,26 @@
* Included by main.c, when FEAT_FKMAP is defined. * Included by main.c, when FEAT_FKMAP is defined.
*/ */
static int toF_Xor_X_ __ARGS((int c)); static int toF_Xor_X_(int c);
static int F_is_TyE __ARGS((int c)); static int F_is_TyE(int c);
static int F_is_TyC_TyD __ARGS((int c)); static int F_is_TyC_TyD(int c);
static int F_is_TyB_TyC_TyD __ARGS((int src, int offset)); static int F_is_TyB_TyC_TyD(int src, int offset);
static int toF_TyB __ARGS((int c)); static int toF_TyB(int c);
static void put_curr_and_l_to_X __ARGS((int c)); static void put_curr_and_l_to_X(int c);
static void put_and_redo __ARGS((int c)); static void put_and_redo(int c);
static void chg_c_toX_orX __ARGS((void)); static void chg_c_toX_orX(void);
static void chg_c_to_X_orX_ __ARGS((void)); static void chg_c_to_X_orX_(void);
static void chg_c_to_X_or_X __ARGS((void)); static void chg_c_to_X_or_X(void);
static void chg_l_to_X_orX_ __ARGS((void)); static void chg_l_to_X_orX_(void);
static void chg_l_toXor_X __ARGS((void)); static void chg_l_toXor_X(void);
static void chg_r_to_Xor_X_ __ARGS((void)); static void chg_r_to_Xor_X_(void);
static int toF_leading __ARGS((int c)); static int toF_leading(int c);
static int toF_Rjoin __ARGS((int c)); static int toF_Rjoin(int c);
static int canF_Ljoin __ARGS((int c)); static int canF_Ljoin(int c);
static int canF_Rjoin __ARGS((int c)); static int canF_Rjoin(int c);
static int F_isterm __ARGS((int c)); static int F_isterm(int c);
static int toF_ending __ARGS((int c)); static int toF_ending(int c);
static void lrswapbuf __ARGS((char_u *buf, int len)); static void lrswapbuf(char_u *buf, int len);
/* /*
** Convert the given Farsi character into a _X or _X_ type ** Convert the given Farsi character into a _X or _X_ type

26
src/file_search.c
View File

@ -182,20 +182,20 @@ typedef struct ff_search_ctx_T {
} ff_search_ctx_T; } ff_search_ctx_T;
/* locally needed functions */ /* locally needed functions */
static int ff_check_visited __ARGS((ff_visited_T **, char_u *, char_u *)); static int ff_check_visited(ff_visited_T **, char_u *, char_u *);
static void vim_findfile_free_visited_list __ARGS( static void vim_findfile_free_visited_list
(ff_visited_list_hdr_T **list_headp)); (ff_visited_list_hdr_T **list_headp);
static void ff_free_visited_list __ARGS((ff_visited_T *vl)); static void ff_free_visited_list(ff_visited_T *vl);
static ff_visited_list_hdr_T* ff_get_visited_list __ARGS( static ff_visited_list_hdr_T* ff_get_visited_list
(char_u *, ff_visited_list_hdr_T **list_headp)); (char_u *, ff_visited_list_hdr_T **list_headp);
static int ff_wc_equal __ARGS((char_u *s1, char_u *s2)); static int ff_wc_equal(char_u *s1, char_u *s2);
static void ff_push __ARGS((ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr)); static void ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr);
static ff_stack_T *ff_pop __ARGS((ff_search_ctx_T *search_ctx)); static ff_stack_T *ff_pop(ff_search_ctx_T *search_ctx);
static void ff_clear __ARGS((ff_search_ctx_T *search_ctx)); static void ff_clear(ff_search_ctx_T *search_ctx);
static void ff_free_stack_element __ARGS((ff_stack_T *stack_ptr)); static void ff_free_stack_element(ff_stack_T *stack_ptr);
static ff_stack_T *ff_create_stack_element __ARGS((char_u *, char_u *, int, int)); static ff_stack_T *ff_create_stack_element(char_u *, char_u *, int, int);
static int ff_path_in_stoplist __ARGS((char_u *, int, char_u **)); static int ff_path_in_stoplist(char_u *, int, char_u **);
static char_u e_pathtoolong[] = N_("E854: path too long for completion"); static char_u e_pathtoolong[] = N_("E854: path too long for completion");

26
src/file_search.h
View File

@ -1,23 +1,23 @@
#ifndef NEOVIM_FIND_FILE_H #ifndef NEOVIM_FIND_FILE_H
#define NEOVIM_FIND_FILE_H #define NEOVIM_FIND_FILE_H
void *vim_findfile_init __ARGS((char_u *path, char_u *filename, char_u * void *vim_findfile_init(char_u *path, char_u *filename, char_u *
stopdirs, int level, int free_visited, stopdirs, int level, int free_visited,
int find_what, void *search_ctx_arg, int find_what, void *search_ctx_arg,
int tagfile, int tagfile,
char_u *rel_fname)); char_u *rel_fname);
char_u *vim_findfile_stopdir __ARGS((char_u *buf)); char_u *vim_findfile_stopdir(char_u *buf);
void vim_findfile_cleanup __ARGS((void *ctx)); void vim_findfile_cleanup(void *ctx);
char_u *vim_findfile __ARGS((void *search_ctx_arg)); char_u *vim_findfile(void *search_ctx_arg);
void vim_findfile_free_visited __ARGS((void *search_ctx_arg)); void vim_findfile_free_visited(void *search_ctx_arg);
char_u *find_file_in_path __ARGS((char_u *ptr, int len, int options, int first, char_u *find_file_in_path(char_u *ptr, int len, int options, int first,
char_u *rel_fname)); char_u *rel_fname);
void free_findfile __ARGS((void)); void free_findfile(void);
char_u *find_directory_in_path __ARGS((char_u *ptr, int len, int options, char_u *find_directory_in_path(char_u *ptr, int len, int options,
char_u *rel_fname)); char_u *rel_fname);
char_u *find_file_in_path_option __ARGS((char_u *ptr, int len, int options, char_u *find_file_in_path_option(char_u *ptr, int len, int options,
int first, char_u *path_option, int first, char_u *path_option,
int find_what, char_u *rel_fname, int find_what, char_u *rel_fname,
char_u *suffixes)); char_u *suffixes);
#endif /* NEOVIM_FIND_FILE_H */ #endif /* NEOVIM_FIND_FILE_H */

89
src/fileio.c
View File

@ -69,27 +69,27 @@ static int crypt_seed_len[] = {0, 8};
/* Is there any system that doesn't have access()? */ /* Is there any system that doesn't have access()? */
#define USE_MCH_ACCESS #define USE_MCH_ACCESS
static char_u *next_fenc __ARGS((char_u **pp)); static char_u *next_fenc(char_u **pp);
static char_u *readfile_charconvert __ARGS((char_u *fname, char_u *fenc, static char_u *readfile_charconvert(char_u *fname, char_u *fenc,
int *fdp)); int *fdp);
static void check_marks_read __ARGS((void)); static void check_marks_read(void);
static int crypt_method_from_magic __ARGS((char *ptr, int len)); static int crypt_method_from_magic(char *ptr, int len);
static char_u *check_for_cryptkey __ARGS((char_u *cryptkey, char_u *ptr, static char_u *check_for_cryptkey(char_u *cryptkey, char_u *ptr,
long *sizep, off_t *filesizep, long *sizep, off_t *filesizep,
int newfile, char_u *fname, int newfile, char_u *fname,
int *did_ask)); int *did_ask);
#ifdef UNIX #ifdef UNIX
static void set_file_time __ARGS((char_u *fname, time_t atime, time_t mtime)); static void set_file_time(char_u *fname, time_t atime, time_t mtime);
#endif #endif
static int set_rw_fname __ARGS((char_u *fname, char_u *sfname)); static int set_rw_fname(char_u *fname, char_u *sfname);
static int msg_add_fileformat __ARGS((int eol_type)); static int msg_add_fileformat(int eol_type);
static void msg_add_eol __ARGS((void)); static void msg_add_eol(void);
static int check_mtime __ARGS((buf_T *buf, struct stat *s)); static int check_mtime(buf_T *buf, struct stat *s);
static int time_differs __ARGS((long t1, long t2)); static int time_differs(long t1, long t2);
static int apply_autocmds_exarg __ARGS((event_T event, char_u *fname, char_u * static int apply_autocmds_exarg(event_T event, char_u *fname, char_u *fname_io,
fname_io, int force, buf_T *buf, int force, buf_T *buf,
exarg_T *eap)); exarg_T *eap);
static int au_find_group __ARGS((char_u *name)); static int au_find_group(char_u *name);
# define AUGROUP_DEFAULT -1 /* default autocmd group */ # define AUGROUP_DEFAULT -1 /* default autocmd group */
# define AUGROUP_ERROR -2 /* erroneous autocmd group */ # define AUGROUP_ERROR -2 /* erroneous autocmd group */
@ -138,18 +138,18 @@ struct bw_info {
# endif # endif
}; };
static int buf_write_bytes __ARGS((struct bw_info *ip)); static int buf_write_bytes(struct bw_info *ip);
static linenr_T readfile_linenr __ARGS((linenr_T linecnt, char_u *p, static linenr_T readfile_linenr(linenr_T linecnt, char_u *p,
char_u *endp)); char_u *endp);
static int ucs2bytes __ARGS((unsigned c, char_u **pp, int flags)); static int ucs2bytes(unsigned c, char_u **pp, int flags);
static int need_conversion __ARGS((char_u *fenc)); static int need_conversion(char_u *fenc);
static int get_fio_flags __ARGS((char_u *ptr)); static int get_fio_flags(char_u *ptr);
static char_u *check_for_bom __ARGS((char_u *p, long size, int *lenp, int flags)); static char_u *check_for_bom(char_u *p, long size, int *lenp, int flags);
static int make_bom __ARGS((char_u *buf, char_u *name)); static int make_bom(char_u *buf, char_u *name);
static int move_lines __ARGS((buf_T *frombuf, buf_T *tobuf)); static int move_lines(buf_T *frombuf, buf_T *tobuf);
#ifdef TEMPDIRNAMES #ifdef TEMPDIRNAMES
static void vim_settempdir __ARGS((char_u *tempdir)); static void vim_settempdir(char_u *tempdir);
#endif #endif
static char *e_auchangedbuf = N_( static char *e_auchangedbuf = N_(
"E812: Autocommands changed buffer or buffer name"); "E812: Autocommands changed buffer or buffer name");
@ -6151,25 +6151,24 @@ static int current_augroup = AUGROUP_DEFAULT;
static int au_need_clean = FALSE; /* need to delete marked patterns */ static int au_need_clean = FALSE; /* need to delete marked patterns */
static void show_autocmd __ARGS((AutoPat *ap, event_T event)); static void show_autocmd(AutoPat *ap, event_T event);
static void au_remove_pat __ARGS((AutoPat *ap)); static void au_remove_pat(AutoPat *ap);
static void au_remove_cmds __ARGS((AutoPat *ap)); static void au_remove_cmds(AutoPat *ap);
static void au_cleanup __ARGS((void)); static void au_cleanup(void);
static int au_new_group __ARGS((char_u *name)); static int au_new_group(char_u *name);
static void au_del_group __ARGS((char_u *name)); static void au_del_group(char_u *name);
static event_T event_name2nr __ARGS((char_u *start, char_u **end)); static event_T event_name2nr(char_u *start, char_u **end);
static char_u *event_nr2name __ARGS((event_T event)); static char_u *event_nr2name(event_T event);
static char_u *find_end_event __ARGS((char_u *arg, int have_group)); static char_u *find_end_event(char_u *arg, int have_group);
static int event_ignored __ARGS((event_T event)); static int event_ignored(event_T event);
static int au_get_grouparg __ARGS((char_u **argp)); static int au_get_grouparg(char_u **argp);
static int do_autocmd_event __ARGS((event_T event, char_u *pat, int nested, static int do_autocmd_event(event_T event, char_u *pat, int nested,
char_u *cmd, int forceit, char_u *cmd, int forceit,
int group)); int group);
static int apply_autocmds_group __ARGS((event_T event, char_u *fname, char_u * static int apply_autocmds_group(event_T event, char_u *fname, char_u *fname_io,
fname_io, int force, int group, buf_T * int force, int group, buf_T *buf,
buf, exarg_T *eap);
exarg_T *eap)); static void auto_next_pat(AutoPatCmd *apc, int stop_at_last);
static void auto_next_pat __ARGS((AutoPatCmd *apc, int stop_at_last));
static event_T last_event; static event_T last_event;

149
src/fileio.h
View File

@ -1,85 +1,84 @@
#ifndef NEOVIM_FILEIO_H #ifndef NEOVIM_FILEIO_H
#define NEOVIM_FILEIO_H #define NEOVIM_FILEIO_H
/* fileio.c */ /* fileio.c */
void filemess __ARGS((buf_T *buf, char_u *name, char_u *s, int attr)); void filemess(buf_T *buf, char_u *name, char_u *s, int attr);
int readfile __ARGS((char_u *fname, char_u *sfname, linenr_T from, int readfile(char_u *fname, char_u *sfname, linenr_T from,
linenr_T lines_to_skip, linenr_T lines_to_read, exarg_T * linenr_T lines_to_skip, linenr_T lines_to_read, exarg_T *eap,
eap, int flags);
int flags)); int prep_exarg(exarg_T *eap, buf_T *buf);
int prep_exarg __ARGS((exarg_T *eap, buf_T *buf)); void set_file_options(int set_options, exarg_T *eap);
void set_file_options __ARGS((int set_options, exarg_T *eap)); void set_forced_fenc(exarg_T *eap);
void set_forced_fenc __ARGS((exarg_T *eap)); int prepare_crypt_read(FILE *fp);
int prepare_crypt_read __ARGS((FILE *fp)); char_u *prepare_crypt_write(buf_T *buf, int *lenp);
char_u *prepare_crypt_write __ARGS((buf_T *buf, int *lenp)); int check_file_readonly(char_u *fname, int perm);
int check_file_readonly __ARGS((char_u *fname, int perm)); int buf_write(buf_T *buf, char_u *fname, char_u *sfname, linenr_T start,
int buf_write __ARGS((buf_T *buf, char_u *fname, char_u *sfname, linenr_T start,
linenr_T end, exarg_T *eap, int append, int forceit, linenr_T end, exarg_T *eap, int append, int forceit,
int reset_changed, int reset_changed,
int filtering)); int filtering);
void msg_add_fname __ARGS((buf_T *buf, char_u *fname)); void msg_add_fname(buf_T *buf, char_u *fname);
void msg_add_lines __ARGS((int insert_space, long lnum, off_t nchars)); void msg_add_lines(int insert_space, long lnum, off_t nchars);
char_u *shorten_fname1 __ARGS((char_u *full_path)); char_u *shorten_fname1(char_u *full_path);
char_u *shorten_fname __ARGS((char_u *full_path, char_u *dir_name)); char_u *shorten_fname(char_u *full_path, char_u *dir_name);
void shorten_fnames __ARGS((int force)); void shorten_fnames(int force);
void shorten_filenames __ARGS((char_u **fnames, int count)); void shorten_filenames(char_u **fnames, int count);
char_u *modname __ARGS((char_u *fname, char_u *ext, int prepend_dot)); char_u *modname(char_u *fname, char_u *ext, int prepend_dot);
char_u *buf_modname __ARGS((int shortname, char_u *fname, char_u *ext, char_u *buf_modname(int shortname, char_u *fname, char_u *ext,
int prepend_dot)); int prepend_dot);
int vim_fgets __ARGS((char_u *buf, int size, FILE *fp)); int vim_fgets(char_u *buf, int size, FILE *fp);
int tag_fgets __ARGS((char_u *buf, int size, FILE *fp)); int tag_fgets(char_u *buf, int size, FILE *fp);
int vim_rename __ARGS((char_u *from, char_u *to)); int vim_rename(char_u *from, char_u *to);
int check_timestamps __ARGS((int focus)); int check_timestamps(int focus);
int buf_check_timestamp __ARGS((buf_T *buf, int focus)); int buf_check_timestamp(buf_T *buf, int focus);
void buf_reload __ARGS((buf_T *buf, int orig_mode)); void buf_reload(buf_T *buf, int orig_mode);
void buf_store_time __ARGS((buf_T *buf, struct stat *st, char_u *fname)); void buf_store_time(buf_T *buf, struct stat *st, char_u *fname);
void write_lnum_adjust __ARGS((linenr_T offset)); void write_lnum_adjust(linenr_T offset);
void vim_deltempdir __ARGS((void)); void vim_deltempdir(void);
char_u *vim_tempname __ARGS((int extra_char)); char_u *vim_tempname(int extra_char);
void forward_slash __ARGS((char_u *fname)); void forward_slash(char_u *fname);
void aubuflocal_remove __ARGS((buf_T *buf)); void aubuflocal_remove(buf_T *buf);
int au_has_group __ARGS((char_u *name)); int au_has_group(char_u *name);
void do_augroup __ARGS((char_u *arg, int del_group)); void do_augroup(char_u *arg, int del_group);
void free_all_autocmds __ARGS((void)); void free_all_autocmds(void);
int check_ei __ARGS((void)); int check_ei(void);
char_u *au_event_disable __ARGS((char *what)); char_u *au_event_disable(char *what);
void au_event_restore __ARGS((char_u *old_ei)); void au_event_restore(char_u *old_ei);
void do_autocmd __ARGS((char_u *arg, int forceit)); void do_autocmd(char_u *arg, int forceit);
int do_doautocmd __ARGS((char_u *arg, int do_msg)); int do_doautocmd(char_u *arg, int do_msg);
void ex_doautoall __ARGS((exarg_T *eap)); void ex_doautoall(exarg_T *eap);
int check_nomodeline __ARGS((char_u **argp)); int check_nomodeline(char_u **argp);
void aucmd_prepbuf __ARGS((aco_save_T *aco, buf_T *buf)); void aucmd_prepbuf(aco_save_T *aco, buf_T *buf);
void aucmd_restbuf __ARGS((aco_save_T *aco)); void aucmd_restbuf(aco_save_T *aco);
int apply_autocmds __ARGS((event_T event, char_u *fname, char_u *fname_io, int apply_autocmds(event_T event, char_u *fname, char_u *fname_io,
int force, int force,
buf_T *buf)); buf_T *buf);
int apply_autocmds_retval __ARGS((event_T event, char_u *fname, char_u * int apply_autocmds_retval(event_T event, char_u *fname, char_u *fname_io,
fname_io, int force, buf_T *buf, int force, buf_T *buf,
int *retval)); int *retval);
int has_cursorhold __ARGS((void)); int has_cursorhold(void);
int trigger_cursorhold __ARGS((void)); int trigger_cursorhold(void);
int has_cursormoved __ARGS((void)); int has_cursormoved(void);
int has_cursormovedI __ARGS((void)); int has_cursormovedI(void);
int has_textchanged __ARGS((void)); int has_textchanged(void);
int has_textchangedI __ARGS((void)); int has_textchangedI(void);
int has_insertcharpre __ARGS((void)); int has_insertcharpre(void);
void block_autocmds __ARGS((void)); void block_autocmds(void);
void unblock_autocmds __ARGS((void)); void unblock_autocmds(void);
int is_autocmd_blocked __ARGS((void)); int is_autocmd_blocked(void);
char_u *getnextac __ARGS((int c, void *cookie, int indent)); char_u *getnextac(int c, void *cookie, int indent);
int has_autocmd __ARGS((event_T event, char_u *sfname, buf_T *buf)); int has_autocmd(event_T event, char_u *sfname, buf_T *buf);
char_u *get_augroup_name __ARGS((expand_T *xp, int idx)); char_u *get_augroup_name(expand_T *xp, int idx);
char_u *set_context_in_autocmd __ARGS((expand_T *xp, char_u *arg, int doautocmd)); char_u *set_context_in_autocmd(expand_T *xp, char_u *arg, int doautocmd);
char_u *get_event_name __ARGS((expand_T *xp, int idx)); char_u *get_event_name(expand_T *xp, int idx);
int autocmd_supported __ARGS((char_u *name)); int autocmd_supported(char_u *name);
int au_exists __ARGS((char_u *arg)); int au_exists(char_u *arg);
int match_file_pat __ARGS((char_u *pattern, regprog_T *prog, char_u *fname, int match_file_pat(char_u *pattern, regprog_T *prog, char_u *fname,
char_u *sfname, char_u *tail, char_u *sfname, char_u *tail,
int allow_dirs)); int allow_dirs);
int match_file_list __ARGS((char_u *list, char_u *sfname, char_u *ffname)); int match_file_list(char_u *list, char_u *sfname, char_u *ffname);
char_u *file_pat_to_reg_pat __ARGS((char_u *pat, char_u *pat_end, char_u *file_pat_to_reg_pat(char_u *pat, char_u *pat_end,
char *allow_dirs, char *allow_dirs,
int no_bslash)); int no_bslash);
long read_eintr __ARGS((int fd, void *buf, size_t bufsize)); long read_eintr(int fd, void *buf, size_t bufsize);
long write_eintr __ARGS((int fd, void *buf, size_t bufsize)); long write_eintr(int fd, void *buf, size_t bufsize);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_FILEIO_H */ #endif /* NEOVIM_FILEIO_H */

89
src/fold.c
View File

@ -56,35 +56,35 @@ typedef struct {
#define MAX_LEVEL 20 /* maximum fold depth */ #define MAX_LEVEL 20 /* maximum fold depth */
/* static functions {{{2 */ /* static functions {{{2 */
static void newFoldLevelWin __ARGS((win_T *wp)); static void newFoldLevelWin(win_T *wp);
static int checkCloseRec __ARGS((garray_T *gap, linenr_T lnum, int level)); static int checkCloseRec(garray_T *gap, linenr_T lnum, int level);
static int foldFind __ARGS((garray_T *gap, linenr_T lnum, fold_T **fpp)); static int foldFind(garray_T *gap, linenr_T lnum, fold_T **fpp);
static int foldLevelWin __ARGS((win_T *wp, linenr_T lnum)); static int foldLevelWin(win_T *wp, linenr_T lnum);
static void checkupdate __ARGS((win_T *wp)); static void checkupdate(win_T *wp);
static void setFoldRepeat __ARGS((linenr_T lnum, long count, int do_open)); static void setFoldRepeat(linenr_T lnum, long count, int do_open);
static linenr_T setManualFold __ARGS((linenr_T lnum, int opening, int recurse, static linenr_T setManualFold(linenr_T lnum, int opening, int recurse,
int *donep)); int *donep);
static linenr_T setManualFoldWin __ARGS((win_T *wp, linenr_T lnum, int opening, static linenr_T setManualFoldWin(win_T *wp, linenr_T lnum, int opening,
int recurse, int recurse,
int *donep)); int *donep);
static void foldOpenNested __ARGS((fold_T *fpr)); static void foldOpenNested(fold_T *fpr);
static void deleteFoldEntry __ARGS((garray_T *gap, int idx, int recursive)); static void deleteFoldEntry(garray_T *gap, int idx, int recursive);
static void foldMarkAdjustRecurse __ARGS((garray_T *gap, linenr_T line1, static void foldMarkAdjustRecurse(garray_T *gap, linenr_T line1,
linenr_T line2, long amount, linenr_T line2, long amount,
long amount_after)); long amount_after);
static int getDeepestNestingRecurse __ARGS((garray_T *gap)); static int getDeepestNestingRecurse(garray_T *gap);
static int check_closed __ARGS((win_T *win, fold_T *fp, int *use_levelp, static int check_closed(win_T *win, fold_T *fp, int *use_levelp,
int level, int *maybe_smallp, int level, int *maybe_smallp,
linenr_T lnum_off)); linenr_T lnum_off);
static void checkSmall __ARGS((win_T *wp, fold_T *fp, linenr_T lnum_off)); static void checkSmall(win_T *wp, fold_T *fp, linenr_T lnum_off);
static void setSmallMaybe __ARGS((garray_T *gap)); static void setSmallMaybe(garray_T *gap);
static void foldCreateMarkers __ARGS((linenr_T start, linenr_T end)); static void foldCreateMarkers(linenr_T start, linenr_T end);
static void foldAddMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen)); static void foldAddMarker(linenr_T lnum, char_u *marker, int markerlen);
static void deleteFoldMarkers __ARGS((fold_T *fp, int recursive, static void deleteFoldMarkers(fold_T *fp, int recursive,
linenr_T lnum_off)); linenr_T lnum_off);
static void foldDelMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen)); static void foldDelMarker(linenr_T lnum, char_u *marker, int markerlen);
static void foldUpdateIEMS __ARGS((win_T *wp, linenr_T top, linenr_T bot)); static void foldUpdateIEMS(win_T *wp, linenr_T top, linenr_T bot);
static void parseMarker __ARGS((win_T *wp)); static void parseMarker(win_T *wp);
static char *e_nofold = N_("E490: No fold found"); static char *e_nofold = N_("E490: No fold found");
@ -1876,20 +1876,19 @@ typedef struct {
static int fold_changed; static int fold_changed;
/* Function declarations. {{{2 */ /* Function declarations. {{{2 */
static linenr_T foldUpdateIEMSRecurse __ARGS((garray_T *gap, int level, static linenr_T foldUpdateIEMSRecurse(garray_T *gap, int level,
linenr_T startlnum, fline_T *flp, linenr_T startlnum, fline_T *flp,
void (*getlevel)__ARGS( void (*getlevel)(fline_T *), linenr_T bot,
(fline_T *)), linenr_T bot, int topflags);
int topflags)); static int foldInsert(garray_T *gap, int i);
static int foldInsert __ARGS((garray_T *gap, int i)); static void foldSplit(garray_T *gap, int i, linenr_T top, linenr_T bot);
static void foldSplit __ARGS((garray_T *gap, int i, linenr_T top, linenr_T bot)); static void foldRemove(garray_T *gap, linenr_T top, linenr_T bot);
static void foldRemove __ARGS((garray_T *gap, linenr_T top, linenr_T bot)); static void foldMerge(fold_T *fp1, garray_T *gap, fold_T *fp2);
static void foldMerge __ARGS((fold_T *fp1, garray_T *gap, fold_T *fp2)); static void foldlevelIndent(fline_T *flp);
static void foldlevelIndent __ARGS((fline_T *flp)); static void foldlevelDiff(fline_T *flp);
static void foldlevelDiff __ARGS((fline_T *flp)); static void foldlevelExpr(fline_T *flp);
static void foldlevelExpr __ARGS((fline_T *flp)); static void foldlevelMarker(fline_T *flp);
static void foldlevelMarker __ARGS((fline_T *flp)); static void foldlevelSyntax(fline_T *flp);
static void foldlevelSyntax __ARGS((fline_T *flp));
/* foldUpdateIEMS() {{{2 */ /* foldUpdateIEMS() {{{2 */
/* /*
@ -1901,7 +1900,7 @@ static void foldUpdateIEMS(win_T *wp, linenr_T top, linenr_T bot)
linenr_T start; linenr_T start;
linenr_T end; linenr_T end;
fline_T fline; fline_T fline;
void (*getlevel)__ARGS((fline_T *)); void (*getlevel)(fline_T *);
int level; int level;
fold_T *fp; fold_T *fp;
@ -2132,7 +2131,7 @@ garray_T *gap;
int level; int level;
linenr_T startlnum; linenr_T startlnum;
fline_T *flp; fline_T *flp;
void (*getlevel)__ARGS((fline_T *)); void (*getlevel)(fline_T *);
linenr_T bot; linenr_T bot;
int topflags; /* flags used by containing fold */ int topflags; /* flags used by containing fold */
{ {
@ -2910,10 +2909,10 @@ static void foldlevelSyntax(fline_T *flp)
/* functions for storing the fold state in a View {{{1 */ /* functions for storing the fold state in a View {{{1 */
/* put_folds() {{{2 */ /* put_folds() {{{2 */
static int put_folds_recurse __ARGS((FILE *fd, garray_T *gap, linenr_T off)); static int put_folds_recurse(FILE *fd, garray_T *gap, linenr_T off);
static int put_foldopen_recurse __ARGS((FILE *fd, win_T *wp, garray_T *gap, static int put_foldopen_recurse(FILE *fd, win_T *wp, garray_T *gap,
linenr_T off)); linenr_T off);
static int put_fold_open_close __ARGS((FILE *fd, fold_T *fp, linenr_T off)); static int put_fold_open_close(FILE *fd, fold_T *fp, linenr_T off);
/* /*
* Write commands to "fd" to restore the manual folds in window "wp". * Write commands to "fd" to restore the manual folds in window "wp".

88
src/fold.h
View File

@ -1,53 +1,53 @@
#ifndef NEOVIM_FOLD_H #ifndef NEOVIM_FOLD_H
#define NEOVIM_FOLD_H #define NEOVIM_FOLD_H
/* fold.c */ /* fold.c */
void copyFoldingState __ARGS((win_T *wp_from, win_T *wp_to)); void copyFoldingState(win_T *wp_from, win_T *wp_to);
int hasAnyFolding __ARGS((win_T *win)); int hasAnyFolding(win_T *win);
int hasFolding __ARGS((linenr_T lnum, linenr_T *firstp, linenr_T *lastp)); int hasFolding(linenr_T lnum, linenr_T *firstp, linenr_T *lastp);
int hasFoldingWin __ARGS((win_T *win, linenr_T lnum, linenr_T *firstp, int hasFoldingWin(win_T *win, linenr_T lnum, linenr_T *firstp,
linenr_T *lastp, int cache, linenr_T *lastp, int cache,
foldinfo_T *infop)); foldinfo_T *infop);
int foldLevel __ARGS((linenr_T lnum)); int foldLevel(linenr_T lnum);
int lineFolded __ARGS((win_T *win, linenr_T lnum)); int lineFolded(win_T *win, linenr_T lnum);
long foldedCount __ARGS((win_T *win, linenr_T lnum, foldinfo_T *infop)); long foldedCount(win_T *win, linenr_T lnum, foldinfo_T *infop);
int foldmethodIsManual __ARGS((win_T *wp)); int foldmethodIsManual(win_T *wp);
int foldmethodIsIndent __ARGS((win_T *wp)); int foldmethodIsIndent(win_T *wp);
int foldmethodIsExpr __ARGS((win_T *wp)); int foldmethodIsExpr(win_T *wp);
int foldmethodIsMarker __ARGS((win_T *wp)); int foldmethodIsMarker(win_T *wp);
int foldmethodIsSyntax __ARGS((win_T *wp)); int foldmethodIsSyntax(win_T *wp);
int foldmethodIsDiff __ARGS((win_T *wp)); int foldmethodIsDiff(win_T *wp);
void closeFold __ARGS((linenr_T lnum, long count)); void closeFold(linenr_T lnum, long count);
void closeFoldRecurse __ARGS((linenr_T lnum)); void closeFoldRecurse(linenr_T lnum);
void opFoldRange __ARGS((linenr_T first, linenr_T last, int opening, void opFoldRange(linenr_T first, linenr_T last, int opening,
int recurse, int recurse,
int had_visual)); int had_visual);
void openFold __ARGS((linenr_T lnum, long count)); void openFold(linenr_T lnum, long count);
void openFoldRecurse __ARGS((linenr_T lnum)); void openFoldRecurse(linenr_T lnum);
void foldOpenCursor __ARGS((void)); void foldOpenCursor(void);
void newFoldLevel __ARGS((void)); void newFoldLevel(void);
void foldCheckClose __ARGS((void)); void foldCheckClose(void);
int foldManualAllowed __ARGS((int create)); int foldManualAllowed(int create);
void foldCreate __ARGS((linenr_T start, linenr_T end)); void foldCreate(linenr_T start, linenr_T end);
void deleteFold __ARGS((linenr_T start, linenr_T end, int recursive, void deleteFold(linenr_T start, linenr_T end, int recursive,
int had_visual)); int had_visual);
void clearFolding __ARGS((win_T *win)); void clearFolding(win_T *win);
void foldUpdate __ARGS((win_T *wp, linenr_T top, linenr_T bot)); void foldUpdate(win_T *wp, linenr_T top, linenr_T bot);
void foldUpdateAll __ARGS((win_T *win)); void foldUpdateAll(win_T *win);
int foldMoveTo __ARGS((int updown, int dir, long count)); int foldMoveTo(int updown, int dir, long count);
void foldInitWin __ARGS((win_T *new_win)); void foldInitWin(win_T *new_win);
int find_wl_entry __ARGS((win_T *win, linenr_T lnum)); int find_wl_entry(win_T *win, linenr_T lnum);
void foldAdjustVisual __ARGS((void)); void foldAdjustVisual(void);
void foldAdjustCursor __ARGS((void)); void foldAdjustCursor(void);
void cloneFoldGrowArray __ARGS((garray_T *from, garray_T *to)); void cloneFoldGrowArray(garray_T *from, garray_T *to);
void deleteFoldRecurse __ARGS((garray_T *gap)); void deleteFoldRecurse(garray_T *gap);
void foldMarkAdjust __ARGS((win_T *wp, linenr_T line1, linenr_T line2, void foldMarkAdjust(win_T *wp, linenr_T line1, linenr_T line2,
long amount, long amount,
long amount_after)); long amount_after);
int getDeepestNesting __ARGS((void)); int getDeepestNesting(void);
char_u *get_foldtext __ARGS((win_T *wp, linenr_T lnum, linenr_T lnume, char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume,
foldinfo_T *foldinfo, foldinfo_T *foldinfo,
char_u *buf)); char_u *buf);
void foldtext_cleanup __ARGS((char_u *str)); void foldtext_cleanup(char_u *str);
int put_folds __ARGS((FILE *fd, win_T *wp)); int put_folds(FILE *fd, win_T *wp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_FOLD_H */ #endif /* NEOVIM_FOLD_H */

18
src/garray.h
View File

@ -1,14 +1,14 @@
#ifndef NEOVIM_GARRAY_H #ifndef NEOVIM_GARRAY_H
#define NEOVIM_GARRAY_H #define NEOVIM_GARRAY_H
void ga_clear __ARGS((garray_T *gap)); void ga_clear(garray_T *gap);
void ga_clear_strings __ARGS((garray_T *gap)); void ga_clear_strings(garray_T *gap);
void ga_init __ARGS((garray_T *gap)); void ga_init(garray_T *gap);
void ga_init2 __ARGS((garray_T *gap, int itemsize, int growsize)); void ga_init2(garray_T *gap, int itemsize, int growsize);
int ga_grow __ARGS((garray_T *gap, int n)); int ga_grow(garray_T *gap, int n);
char_u *ga_concat_strings __ARGS((garray_T *gap)); char_u *ga_concat_strings(garray_T *gap);
void ga_concat __ARGS((garray_T *gap, char_u *s)); void ga_concat(garray_T *gap, char_u *s);
void ga_append __ARGS((garray_T *gap, int c)); void ga_append(garray_T *gap, int c);
void append_ga_line __ARGS((garray_T *gap)); void append_ga_line(garray_T *gap);
#endif /* NEOVIM_GARRAY_H */ #endif /* NEOVIM_GARRAY_H */

34
src/getchar.c
View File

@ -135,23 +135,23 @@ static char_u noremapbuf_init[TYPELEN_INIT]; /* initial typebuf.tb_noremap */
static int last_recorded_len = 0; /* number of last recorded chars */ static int last_recorded_len = 0; /* number of last recorded chars */
static char_u *get_buffcont __ARGS((struct buffheader *, int)); static char_u *get_buffcont(struct buffheader *, int);
static void add_buff __ARGS((struct buffheader *, char_u *, long n)); static void add_buff(struct buffheader *, char_u *, long n);
static void add_num_buff __ARGS((struct buffheader *, long)); static void add_num_buff(struct buffheader *, long);
static void add_char_buff __ARGS((struct buffheader *, int)); static void add_char_buff(struct buffheader *, int);
static int read_stuff __ARGS((int advance)); static int read_stuff(int advance);
static void start_stuff __ARGS((void)); static void start_stuff(void);
static int read_redo __ARGS((int, int)); static int read_redo(int, int);
static void copy_redo __ARGS((int)); static void copy_redo(int);
static void init_typebuf __ARGS((void)); static void init_typebuf(void);
static void gotchars __ARGS((char_u *, int)); static void gotchars(char_u *, int);
static void may_sync_undo __ARGS((void)); static void may_sync_undo(void);
static void closescript __ARGS((void)); static void closescript(void);
static int vgetorpeek __ARGS((int)); static int vgetorpeek(int);
static void map_free __ARGS((mapblock_T **)); static void map_free(mapblock_T **);
static void validate_maphash __ARGS((void)); static void validate_maphash(void);
static void showmap __ARGS((mapblock_T *mp, int local)); static void showmap(mapblock_T *mp, int local);
static char_u *eval_map_expr __ARGS((char_u *str, int c)); static char_u *eval_map_expr(char_u *str, int c);
/* /*
* Free and clear a buffer. * Free and clear a buffer.

140
src/getchar.h
View File

@ -1,77 +1,77 @@
#ifndef NEOVIM_GETCHAR_H #ifndef NEOVIM_GETCHAR_H
#define NEOVIM_GETCHAR_H #define NEOVIM_GETCHAR_H
/* getchar.c */ /* getchar.c */
void free_buff __ARGS((struct buffheader *buf)); void free_buff(struct buffheader *buf);
char_u *get_recorded __ARGS((void)); char_u *get_recorded(void);
char_u *get_inserted __ARGS((void)); char_u *get_inserted(void);
int stuff_empty __ARGS((void)); int stuff_empty(void);
void typeahead_noflush __ARGS((int c)); void typeahead_noflush(int c);
void flush_buffers __ARGS((int flush_typeahead)); void flush_buffers(int flush_typeahead);
void ResetRedobuff __ARGS((void)); void ResetRedobuff(void);
void CancelRedo __ARGS((void)); void CancelRedo(void);
void saveRedobuff __ARGS((void)); void saveRedobuff(void);
void restoreRedobuff __ARGS((void)); void restoreRedobuff(void);
void AppendToRedobuff __ARGS((char_u *s)); void AppendToRedobuff(char_u *s);
void AppendToRedobuffLit __ARGS((char_u *str, int len)); void AppendToRedobuffLit(char_u *str, int len);
void AppendCharToRedobuff __ARGS((int c)); void AppendCharToRedobuff(int c);
void AppendNumberToRedobuff __ARGS((long n)); void AppendNumberToRedobuff(long n);
void stuffReadbuff __ARGS((char_u *s)); void stuffReadbuff(char_u *s);
void stuffReadbuffLen __ARGS((char_u *s, long len)); void stuffReadbuffLen(char_u *s, long len);
void stuffReadbuffSpec __ARGS((char_u *s)); void stuffReadbuffSpec(char_u *s);
void stuffcharReadbuff __ARGS((int c)); void stuffcharReadbuff(int c);
void stuffnumReadbuff __ARGS((long n)); void stuffnumReadbuff(long n);
int start_redo __ARGS((long count, int old_redo)); int start_redo(long count, int old_redo);
int start_redo_ins __ARGS((void)); int start_redo_ins(void);
void stop_redo_ins __ARGS((void)); void stop_redo_ins(void);
int ins_typebuf __ARGS((char_u *str, int noremap, int offset, int nottyped, int ins_typebuf(char_u *str, int noremap, int offset, int nottyped,
int silent)); int silent);
void ins_char_typebuf __ARGS((int c)); void ins_char_typebuf(int c);
int typebuf_changed __ARGS((int tb_change_cnt)); int typebuf_changed(int tb_change_cnt);
int typebuf_typed __ARGS((void)); int typebuf_typed(void);
int typebuf_maplen __ARGS((void)); int typebuf_maplen(void);
void del_typebuf __ARGS((int len, int offset)); void del_typebuf(int len, int offset);
int alloc_typebuf __ARGS((void)); int alloc_typebuf(void);
void free_typebuf __ARGS((void)); void free_typebuf(void);
int save_typebuf __ARGS((void)); int save_typebuf(void);
void save_typeahead __ARGS((tasave_T *tp)); void save_typeahead(tasave_T *tp);
void restore_typeahead __ARGS((tasave_T *tp)); void restore_typeahead(tasave_T *tp);
void openscript __ARGS((char_u *name, int directly)); void openscript(char_u *name, int directly);
void close_all_scripts __ARGS((void)); void close_all_scripts(void);
int using_script __ARGS((void)); int using_script(void);
void before_blocking __ARGS((void)); void before_blocking(void);
void updatescript __ARGS((int c)); void updatescript(int c);
int vgetc __ARGS((void)); int vgetc(void);
int safe_vgetc __ARGS((void)); int safe_vgetc(void);
int plain_vgetc __ARGS((void)); int plain_vgetc(void);
int vpeekc __ARGS((void)); int vpeekc(void);
int vpeekc_nomap __ARGS((void)); int vpeekc_nomap(void);
int vpeekc_any __ARGS((void)); int vpeekc_any(void);
int char_avail __ARGS((void)); int char_avail(void);
void vungetc __ARGS((int c)); void vungetc(int c);
int inchar __ARGS((char_u *buf, int maxlen, long wait_time, int tb_change_cnt)); int inchar(char_u *buf, int maxlen, long wait_time, int tb_change_cnt);
int fix_input_buffer __ARGS((char_u *buf, int len, int script)); int fix_input_buffer(char_u *buf, int len, int script);
int input_available __ARGS((void)); int input_available(void);
int do_map __ARGS((int maptype, char_u *arg, int mode, int abbrev)); int do_map(int maptype, char_u *arg, int mode, int abbrev);
int get_map_mode __ARGS((char_u **cmdp, int forceit)); int get_map_mode(char_u **cmdp, int forceit);
void map_clear __ARGS((char_u *cmdp, char_u *arg, int forceit, int abbr)); void map_clear(char_u *cmdp, char_u *arg, int forceit, int abbr);
void map_clear_int __ARGS((buf_T *buf, int mode, int local, int abbr)); void map_clear_int(buf_T *buf, int mode, int local, int abbr);
char_u *map_mode_to_chars __ARGS((int mode)); char_u *map_mode_to_chars(int mode);
int map_to_exists __ARGS((char_u *str, char_u *modechars, int abbr)); int map_to_exists(char_u *str, char_u *modechars, int abbr);
int map_to_exists_mode __ARGS((char_u *rhs, int mode, int abbr)); int map_to_exists_mode(char_u *rhs, int mode, int abbr);
char_u *set_context_in_map_cmd __ARGS((expand_T *xp, char_u *cmd, char_u *arg, char_u *set_context_in_map_cmd(expand_T *xp, char_u *cmd, char_u *arg,
int forceit, int isabbrev, int isunmap, int forceit, int isabbrev, int isunmap,
cmdidx_T cmdidx)); cmdidx_T cmdidx);
int ExpandMappings __ARGS((regmatch_T *regmatch, int *num_file, char_u ***file)); int ExpandMappings(regmatch_T *regmatch, int *num_file, char_u ***file);
int check_abbr __ARGS((int c, char_u *ptr, int col, int mincol)); int check_abbr(int c, char_u *ptr, int col, int mincol);
char_u *vim_strsave_escape_csi __ARGS((char_u *p)); char_u *vim_strsave_escape_csi(char_u *p);
void vim_unescape_csi __ARGS((char_u *p)); void vim_unescape_csi(char_u *p);
int makemap __ARGS((FILE *fd, buf_T *buf)); int makemap(FILE *fd, buf_T *buf);
int put_escstr __ARGS((FILE *fd, char_u *strstart, int what)); int put_escstr(FILE *fd, char_u *strstart, int what);
void check_map_keycodes __ARGS((void)); void check_map_keycodes(void);
char_u *check_map __ARGS((char_u *keys, int mode, int exact, int ign_mod, char_u *check_map(char_u *keys, int mode, int exact, int ign_mod,
int abbr, mapblock_T **mp_ptr, int abbr, mapblock_T **mp_ptr,
int *local_ptr)); int *local_ptr);
void init_mappings __ARGS((void)); void init_mappings(void);
void add_map __ARGS((char_u *map, int mode)); void add_map(char_u *map, int mode);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_GETCHAR_H */ #endif /* NEOVIM_GETCHAR_H */

22
src/globals.h
View File

@ -645,23 +645,21 @@ EXTERN vimconv_T output_conv; /* type of output conversion */
* The value is set in mb_init(); * The value is set in mb_init();
*/ */
/* length of char in bytes, including following composing chars */ /* length of char in bytes, including following composing chars */
EXTERN int (*mb_ptr2len)__ARGS((char_u *p)) INIT(= latin_ptr2len); EXTERN int (*mb_ptr2len)(char_u *p) INIT(= latin_ptr2len);
/* idem, with limit on string length */ /* idem, with limit on string length */
EXTERN int (*mb_ptr2len_len)__ARGS((char_u *p, int size)) INIT( EXTERN int (*mb_ptr2len_len)(char_u *p, int size) INIT(= latin_ptr2len_len);
= latin_ptr2len_len);
/* byte length of char */ /* byte length of char */
EXTERN int (*mb_char2len)__ARGS((int c)) INIT(= latin_char2len); EXTERN int (*mb_char2len)(int c) INIT(= latin_char2len);
/* convert char to bytes, return the length */ /* convert char to bytes, return the length */
EXTERN int (*mb_char2bytes)__ARGS((int c, char_u *buf)) INIT(= latin_char2bytes); EXTERN int (*mb_char2bytes)(int c, char_u *buf) INIT(= latin_char2bytes);
EXTERN int (*mb_ptr2cells)__ARGS((char_u *p)) INIT(= latin_ptr2cells); EXTERN int (*mb_ptr2cells)(char_u *p) INIT(= latin_ptr2cells);
EXTERN int (*mb_ptr2cells_len)__ARGS((char_u *p, int size)) INIT( EXTERN int (*mb_ptr2cells_len)(char_u *p, int size) INIT(
= latin_ptr2cells_len); = latin_ptr2cells_len);
EXTERN int (*mb_char2cells)__ARGS((int c)) INIT(= latin_char2cells); EXTERN int (*mb_char2cells)(int c) INIT(= latin_char2cells);
EXTERN int (*mb_off2cells)__ARGS((unsigned off, unsigned max_off)) INIT( EXTERN int (*mb_off2cells)(unsigned off, unsigned max_off) INIT(
= latin_off2cells); = latin_off2cells);
EXTERN int (*mb_ptr2char)__ARGS((char_u *p)) INIT(= latin_ptr2char); EXTERN int (*mb_ptr2char)(char_u *p) INIT(= latin_ptr2char);
EXTERN int (*mb_head_off)__ARGS((char_u *base, char_u *p)) INIT( EXTERN int (*mb_head_off)(char_u *base, char_u *p) INIT(= latin_head_off);
= latin_head_off);
# if defined(USE_ICONV) && defined(DYNAMIC_ICONV) # if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
/* Pointers to functions and variables to be loaded at runtime */ /* Pointers to functions and variables to be loaded at runtime */

9
src/hangulin.c
View File

@ -41,11 +41,10 @@ static char_u stack[20] = {0};
static int last_l = -1, last_ll = -1; static int last_l = -1, last_ll = -1;
static int hangul_keyboard_type = HANGUL_DEFAULT_KEYBOARD; static int hangul_keyboard_type = HANGUL_DEFAULT_KEYBOARD;
static void convert_ks_to_3 __ARGS((const char_u *src, int *fp, int *mp, static void convert_ks_to_3(const char_u *src, int *fp, int *mp, int *lp);
int *lp)); static int convert_3_to_ks(int fv, int mv, int lv, char_u *des);
static int convert_3_to_ks __ARGS((int fv, int mv, int lv, char_u *des)); static int hangul_automata2(char_u *buf, unsigned int *c);
static int hangul_automata2 __ARGS((char_u *buf, unsigned int *c)); static int hangul_automata3(char_u *buf, unsigned int *c);
static int hangul_automata3 __ARGS((char_u *buf, unsigned int *c));
#define push(x) {stack[ sp++ ] = *(x); stack[sp++] = *((x)+1); } #define push(x) {stack[ sp++ ] = *(x); stack[sp++] = *((x)+1); }
#define pop(x) {*((x) + 1) = stack[--sp]; *(x) = stack[--sp]; } #define pop(x) {*((x) + 1) = stack[--sp]; *(x) = stack[--sp]; }

14
src/hangulin.h
View File

@ -1,12 +1,12 @@
#ifndef NEOVIM_HANGULIN_H #ifndef NEOVIM_HANGULIN_H
#define NEOVIM_HANGULIN_H #define NEOVIM_HANGULIN_H
/* hangulin.c */ /* hangulin.c */
int hangul_input_state_get __ARGS((void)); int hangul_input_state_get(void);
void hangul_input_state_set __ARGS((int state)); void hangul_input_state_set(int state);
int im_get_status __ARGS((void)); int im_get_status(void);
void hangul_input_state_toggle __ARGS((void)); void hangul_input_state_toggle(void);
void hangul_keyboard_set __ARGS((void)); void hangul_keyboard_set(void);
int hangul_input_process __ARGS((char_u *s, int len)); int hangul_input_process(char_u *s, int len);
void hangul_input_clear __ARGS((void)); void hangul_input_clear(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_HANGULIN_H */ #endif /* NEOVIM_HANGULIN_H */

131
src/hardcopy.c
View File

@ -147,23 +147,23 @@ typedef struct {
int ff; /* seen form feed character */ int ff; /* seen form feed character */
} prt_pos_T; } prt_pos_T;
static char_u *parse_list_options __ARGS((char_u *option_str, option_table_T * static char_u *parse_list_options(char_u *option_str,
table, option_table_T *table,
int table_size)); int table_size);
static long_u darken_rgb __ARGS((long_u rgb)); static long_u darken_rgb(long_u rgb);
static long_u prt_get_term_color __ARGS((int colorindex)); static long_u prt_get_term_color(int colorindex);
static void prt_set_fg __ARGS((long_u fg)); static void prt_set_fg(long_u fg);
static void prt_set_bg __ARGS((long_u bg)); static void prt_set_bg(long_u bg);
static void prt_set_font __ARGS((int bold, int italic, int underline)); static void prt_set_font(int bold, int italic, int underline);
static void prt_line_number __ARGS((prt_settings_T *psettings, int page_line, static void prt_line_number(prt_settings_T *psettings, int page_line,
linenr_T lnum)); linenr_T lnum);
static void prt_header __ARGS((prt_settings_T *psettings, int pagenum, static void prt_header(prt_settings_T *psettings, int pagenum,
linenr_T lnum)); linenr_T lnum);
static void prt_message __ARGS((char_u *s)); static void prt_message(char_u *s);
static colnr_T hardcopy_line __ARGS((prt_settings_T *psettings, int page_line, static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line,
prt_pos_T *ppos)); prt_pos_T *ppos);
static void prt_get_attr __ARGS((int hl_id, prt_text_attr_T* pattr, int modec)); static void prt_get_attr(int hl_id, prt_text_attr_T* pattr, int modec);
/* /*
* Parse 'printoptions' and set the flags in "printer_opts". * Parse 'printoptions' and set the flags in "printer_opts".
@ -1199,61 +1199,60 @@ static struct prt_dsc_comment_S prt_dsc_table[] =
PRT_DSC_ENDCOMMENTS_TYPE} PRT_DSC_ENDCOMMENTS_TYPE}
}; };
static void prt_write_file_raw_len __ARGS((char_u *buffer, int bytes)); static void prt_write_file_raw_len(char_u *buffer, int bytes);
static void prt_write_file __ARGS((char_u *buffer)); static void prt_write_file(char_u *buffer);
static void prt_write_file_len __ARGS((char_u *buffer, int bytes)); static void prt_write_file_len(char_u *buffer, int bytes);
static void prt_write_string __ARGS((char *s)); static void prt_write_string(char *s);
static void prt_write_int __ARGS((int i)); static void prt_write_int(int i);
static void prt_write_boolean __ARGS((int b)); static void prt_write_boolean(int b);
static void prt_def_font __ARGS((char *new_name, char *encoding, int height, static void prt_def_font(char *new_name, char *encoding, int height,
char *font)); char *font);
static void prt_real_bits __ARGS((double real, int precision, int *pinteger, static void prt_real_bits(double real, int precision, int *pinteger,
int *pfraction)); int *pfraction);
static void prt_write_real __ARGS((double val, int prec)); static void prt_write_real(double val, int prec);
static void prt_def_var __ARGS((char *name, double value, int prec)); static void prt_def_var(char *name, double value, int prec);
static void prt_flush_buffer __ARGS((void)); static void prt_flush_buffer(void);
static void prt_resource_name __ARGS((char_u *filename, void *cookie)); static void prt_resource_name(char_u *filename, void *cookie);
static int prt_find_resource __ARGS((char *name, static int prt_find_resource(char *name, struct prt_ps_resource_S *resource);
struct prt_ps_resource_S *resource)); static int prt_open_resource(struct prt_ps_resource_S *resource);
static int prt_open_resource __ARGS((struct prt_ps_resource_S *resource)); static int prt_check_resource(struct prt_ps_resource_S *resource,
static int prt_check_resource __ARGS((struct prt_ps_resource_S *resource, char_u *version);
char_u *version)); static void prt_dsc_start(void);
static void prt_dsc_start __ARGS((void)); static void prt_dsc_noarg(char *comment);
static void prt_dsc_noarg __ARGS((char *comment)); static void prt_dsc_textline(char *comment, char *text);
static void prt_dsc_textline __ARGS((char *comment, char *text)); static void prt_dsc_text(char *comment, char *text);
static void prt_dsc_text __ARGS((char *comment, char *text)); static void prt_dsc_ints(char *comment, int count, int *ints);
static void prt_dsc_ints __ARGS((char *comment, int count, int *ints)); static void prt_dsc_requirements(int duplex, int tumble, int collate,
static void prt_dsc_requirements __ARGS((int duplex, int tumble, int collate,
int color, int color,
int num_copies)); int num_copies);
static void prt_dsc_docmedia __ARGS((char *paper_name, double width, static void prt_dsc_docmedia(char *paper_name, double width,
double height, double weight, char *colour, double height, double weight, char *colour,
char *type)); char *type);
static void prt_dsc_resources __ARGS((char *comment, char *type, char *strings)); static void prt_dsc_resources(char *comment, char *type, char *strings);
static void prt_dsc_font_resource __ARGS((char *resource, static void prt_dsc_font_resource(char *resource,
struct prt_ps_font_S *ps_font)); struct prt_ps_font_S *ps_font);
static float to_device_units __ARGS((int idx, double physsize, int def_number)); static float to_device_units(int idx, double physsize, int def_number);
static void prt_page_margins __ARGS((double width, double height, double *left, static void prt_page_margins(double width, double height, double *left,
double *right, double *top, double *right, double *top,
double *bottom)); double *bottom);
static void prt_font_metrics __ARGS((int font_scale)); static void prt_font_metrics(int font_scale);
static int prt_get_cpl __ARGS((void)); static int prt_get_cpl(void);
static int prt_get_lpp __ARGS((void)); static int prt_get_lpp(void);
static int prt_add_resource __ARGS((struct prt_ps_resource_S *resource)); static int prt_add_resource(struct prt_ps_resource_S *resource);
static int prt_resfile_next_line __ARGS((void)); static int prt_resfile_next_line(void);
static int prt_resfile_strncmp __ARGS((int offset, char *string, int len)); static int prt_resfile_strncmp(int offset, char *string, int len);
static int prt_resfile_skip_nonws __ARGS((int offset)); static int prt_resfile_skip_nonws(int offset);
static int prt_resfile_skip_ws __ARGS((int offset)); static int prt_resfile_skip_ws(int offset);
static int prt_next_dsc __ARGS((struct prt_dsc_line_S *p_dsc_line)); static int prt_next_dsc(struct prt_dsc_line_S *p_dsc_line);
static int prt_build_cid_fontname __ARGS((int font, char_u *name, int name_len)); static int prt_build_cid_fontname(int font, char_u *name, int name_len);
static void prt_def_cidfont __ARGS((char *new_name, int height, char *cidfont)); static void prt_def_cidfont(char *new_name, int height, char *cidfont);
static void prt_dup_cidfont __ARGS((char *original_name, char *new_name)); static void prt_dup_cidfont(char *original_name, char *new_name);
static int prt_match_encoding __ARGS((char *p_encoding, static int prt_match_encoding(char *p_encoding,
struct prt_ps_mbfont_S *p_cmap, struct prt_ps_mbfont_S *p_cmap,
struct prt_ps_encoding_S **pp_mbenc)); struct prt_ps_encoding_S **pp_mbenc);
static int prt_match_charset __ARGS((char *p_charset, static int prt_match_charset(char *p_charset,
struct prt_ps_mbfont_S *p_cmap, struct prt_ps_mbfont_S *p_cmap,
struct prt_ps_charset_S **pp_mbchar)); struct prt_ps_charset_S **pp_mbchar);
/* /*
* Variables for the output PostScript file. * Variables for the output PostScript file.

38
src/hardcopy.h
View File

@ -1,24 +1,24 @@
#ifndef NEOVIM_HARDCOPY_H #ifndef NEOVIM_HARDCOPY_H
#define NEOVIM_HARDCOPY_H #define NEOVIM_HARDCOPY_H
/* hardcopy.c */ /* hardcopy.c */
char_u *parse_printoptions __ARGS((void)); char_u *parse_printoptions(void);
char_u *parse_printmbfont __ARGS((void)); char_u *parse_printmbfont(void);
int prt_header_height __ARGS((void)); int prt_header_height(void);
int prt_use_number __ARGS((void)); int prt_use_number(void);
int prt_get_unit __ARGS((int idx)); int prt_get_unit(int idx);
void ex_hardcopy __ARGS((exarg_T *eap)); void ex_hardcopy(exarg_T *eap);
void mch_print_cleanup __ARGS((void)); void mch_print_cleanup(void);
int mch_print_init __ARGS((prt_settings_T *psettings, char_u *jobname, int mch_print_init(prt_settings_T *psettings, char_u *jobname,
int forceit)); int forceit);
int mch_print_begin __ARGS((prt_settings_T *psettings)); int mch_print_begin(prt_settings_T *psettings);
void mch_print_end __ARGS((prt_settings_T *psettings)); void mch_print_end(prt_settings_T *psettings);
int mch_print_end_page __ARGS((void)); int mch_print_end_page(void);
int mch_print_begin_page __ARGS((char_u *str)); int mch_print_begin_page(char_u *str);
int mch_print_blank_page __ARGS((void)); int mch_print_blank_page(void);
void mch_print_start_line __ARGS((int margin, int page_line)); void mch_print_start_line(int margin, int page_line);
int mch_print_text_out __ARGS((char_u *p, int len)); int mch_print_text_out(char_u *p, int len);
void mch_print_set_font __ARGS((int iBold, int iItalic, int iUnderline)); void mch_print_set_font(int iBold, int iItalic, int iUnderline);
void mch_print_set_bg __ARGS((long_u bgcol)); void mch_print_set_bg(long_u bgcol);
void mch_print_set_fg __ARGS((long_u fgcol)); void mch_print_set_fg(long_u fgcol);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_HARDCOPY_H */ #endif /* NEOVIM_HARDCOPY_H */

2
src/hashtab.c
View File

@ -35,7 +35,7 @@
/* Magic value for algorithm that walks through the array. */ /* Magic value for algorithm that walks through the array. */
#define PERTURB_SHIFT 5 #define PERTURB_SHIFT 5
static int hash_may_resize __ARGS((hashtab_T *ht, int minitems)); static int hash_may_resize(hashtab_T *ht, int minitems);
/* /*

26
src/hashtab.h
View File

@ -1,18 +1,18 @@
#ifndef NEOVIM_HASHTAB_H #ifndef NEOVIM_HASHTAB_H
#define NEOVIM_HASHTAB_H #define NEOVIM_HASHTAB_H
/* hashtab.c */ /* hashtab.c */
void hash_init __ARGS((hashtab_T *ht)); void hash_init(hashtab_T *ht);
void hash_clear __ARGS((hashtab_T *ht)); void hash_clear(hashtab_T *ht);
void hash_clear_all __ARGS((hashtab_T *ht, int off)); void hash_clear_all(hashtab_T *ht, int off);
hashitem_T *hash_find __ARGS((hashtab_T *ht, char_u *key)); hashitem_T *hash_find(hashtab_T *ht, char_u *key);
hashitem_T *hash_lookup __ARGS((hashtab_T *ht, char_u *key, hash_T hash)); hashitem_T *hash_lookup(hashtab_T *ht, char_u *key, hash_T hash);
void hash_debug_results __ARGS((void)); void hash_debug_results(void);
int hash_add __ARGS((hashtab_T *ht, char_u *key)); int hash_add(hashtab_T *ht, char_u *key);
int hash_add_item __ARGS((hashtab_T *ht, hashitem_T *hi, char_u *key, int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key,
hash_T hash)); hash_T hash);
void hash_remove __ARGS((hashtab_T *ht, hashitem_T *hi)); void hash_remove(hashtab_T *ht, hashitem_T *hi);
void hash_lock __ARGS((hashtab_T *ht)); void hash_lock(hashtab_T *ht);
void hash_unlock __ARGS((hashtab_T *ht)); void hash_unlock(hashtab_T *ht);
hash_T hash_hash __ARGS((char_u *key)); hash_T hash_hash(char_u *key);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_HASHTAB_H */ #endif /* NEOVIM_HASHTAB_H */

76
src/if_cscope.c
View File

@ -30,45 +30,45 @@
#endif #endif
#include "if_cscope_defs.h" #include "if_cscope_defs.h"
static void cs_usage_msg __ARGS((csid_e x)); static void cs_usage_msg(csid_e x);
static int cs_add __ARGS((exarg_T *eap)); static int cs_add(exarg_T *eap);
static void cs_stat_emsg __ARGS((char *fname)); static void cs_stat_emsg(char *fname);
static int cs_add_common __ARGS((char *, char *, char *)); static int cs_add_common(char *, char *, char *);
static int cs_check_for_connections __ARGS((void)); static int cs_check_for_connections(void);
static int cs_check_for_tags __ARGS((void)); static int cs_check_for_tags(void);
static int cs_cnt_connections __ARGS((void)); static int cs_cnt_connections(void);
static void cs_reading_emsg __ARGS((int idx)); static void cs_reading_emsg(int idx);
static int cs_cnt_matches __ARGS((int idx)); static int cs_cnt_matches(int idx);
static char * cs_create_cmd __ARGS((char *csoption, char *pattern)); static char * cs_create_cmd(char *csoption, char *pattern);
static int cs_create_connection __ARGS((int i)); static int cs_create_connection(int i);
static void do_cscope_general __ARGS((exarg_T *eap, int make_split)); static void do_cscope_general(exarg_T *eap, int make_split);
static void cs_file_results __ARGS((FILE *, int *)); static void cs_file_results(FILE *, int *);
static void cs_fill_results __ARGS((char *, int, int *, char ***, static void cs_fill_results(char *, int, int *, char ***,
char ***, int *)); char ***, int *);
static int cs_find __ARGS((exarg_T *eap)); static int cs_find(exarg_T *eap);
static int cs_find_common __ARGS((char *opt, char *pat, int, int, int, static int cs_find_common(char *opt, char *pat, int, int, int,
char_u *cmdline)); char_u *cmdline);
static int cs_help __ARGS((exarg_T *eap)); static int cs_help(exarg_T *eap);
static void clear_csinfo __ARGS((int i)); static void clear_csinfo(int i);
static int cs_insert_filelist __ARGS((char *, char *, char *, static int cs_insert_filelist(char *, char *, char *,
struct stat *)); struct stat *);
static int cs_kill __ARGS((exarg_T *eap)); static int cs_kill(exarg_T *eap);
static void cs_kill_execute __ARGS((int, char *)); static void cs_kill_execute(int, char *);
static cscmd_T * cs_lookup_cmd __ARGS((exarg_T *eap)); static cscmd_T * cs_lookup_cmd(exarg_T *eap);
static char * cs_make_vim_style_matches __ARGS((char *, char *, static char * cs_make_vim_style_matches(char *, char *,
char *, char *)); char *, char *);
static char * cs_manage_matches __ARGS((char **, char **, int, mcmd_e)); static char * cs_manage_matches(char **, char **, int, mcmd_e);
static char * cs_parse_results __ARGS((int cnumber, char *buf, static char * cs_parse_results(int cnumber, char *buf,
int bufsize, char **context, int bufsize, char **context,
char **linenumber, char **linenumber,
char **search)); char **search);
static char * cs_pathcomponents __ARGS((char *path)); static char * cs_pathcomponents(char *path);
static void cs_print_tags_priv __ARGS((char **, char **, int)); static void cs_print_tags_priv(char **, char **, int);
static int cs_read_prompt __ARGS((int)); static int cs_read_prompt(int);
static void cs_release_csp __ARGS((int, int freefnpp)); static void cs_release_csp(int, int freefnpp);
static int cs_reset __ARGS((exarg_T *eap)); static int cs_reset(exarg_T *eap);
static char * cs_resolve_file __ARGS((int, char *)); static char * cs_resolve_file(int, char *);
static int cs_show __ARGS((exarg_T *eap)); static int cs_show(exarg_T *eap);
static csinfo_T * csinfo = NULL; static csinfo_T * csinfo = NULL;
@ -1235,7 +1235,7 @@ static void clear_csinfo(int i)
} }
#ifndef UNIX #ifndef UNIX
static char *GetWin32Error __ARGS((void)); static char *GetWin32Error(void);
static char *GetWin32Error(void) { static char *GetWin32Error(void) {
char *msg = NULL; char *msg = NULL;

22
src/if_cscope.h
View File

@ -1,16 +1,16 @@
#ifndef NEOVIM_IF_CSCOPE_H #ifndef NEOVIM_IF_CSCOPE_H
#define NEOVIM_IF_CSCOPE_H #define NEOVIM_IF_CSCOPE_H
/* if_cscope.c */ /* if_cscope.c */
char_u *get_cscope_name __ARGS((expand_T *xp, int idx)); char_u *get_cscope_name(expand_T *xp, int idx);
void set_context_in_cscope_cmd __ARGS((expand_T *xp, char_u *arg, void set_context_in_cscope_cmd(expand_T *xp, char_u *arg,
cmdidx_T cmdidx)); cmdidx_T cmdidx);
void do_cscope __ARGS((exarg_T *eap)); void do_cscope(exarg_T *eap);
void do_scscope __ARGS((exarg_T *eap)); void do_scscope(exarg_T *eap);
void do_cstag __ARGS((exarg_T *eap)); void do_cstag(exarg_T *eap);
int cs_fgets __ARGS((char_u *buf, int size)); int cs_fgets(char_u *buf, int size);
void cs_free_tags __ARGS((void)); void cs_free_tags(void);
void cs_print_tags __ARGS((void)); void cs_print_tags(void);
int cs_connection __ARGS((int num, char_u *dbpath, char_u *ppath)); int cs_connection(int num, char_u *dbpath, char_u *ppath);
void cs_end __ARGS((void)); void cs_end(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_IF_CSCOPE_H */ #endif /* NEOVIM_IF_CSCOPE_H */

2
src/if_cscope_defs.h
View File

@ -37,7 +37,7 @@
typedef struct { typedef struct {
char * name; char * name;
int (*func)__ARGS((exarg_T *eap)); int (*func)(exarg_T *eap);
char * help; char * help;
char * usage; char * usage;
int cansplit; /* if supports splitting window */ int cansplit; /* if supports splitting window */

58
src/main.c
View File

@ -92,39 +92,39 @@ typedef struct {
#define EDIT_QF 4 /* start in quickfix mode */ #define EDIT_QF 4 /* start in quickfix mode */
#if (defined(UNIX) || defined(VMS)) && !defined(NO_VIM_MAIN) #if (defined(UNIX) || defined(VMS)) && !defined(NO_VIM_MAIN)
static int file_owned __ARGS((char *fname)); static int file_owned(char *fname);
#endif #endif
static void mainerr __ARGS((int, char_u *)); static void mainerr(int, char_u *);
#ifndef NO_VIM_MAIN #ifndef NO_VIM_MAIN
static void main_msg __ARGS((char *s)); static void main_msg(char *s);
static void usage __ARGS((void)); static void usage(void);
static int get_number_arg __ARGS((char_u *p, int *idx, int def)); static int get_number_arg(char_u *p, int *idx, int def);
# if defined(HAVE_LOCALE_H) || defined(X_LOCALE) # if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
static void init_locale __ARGS((void)); static void init_locale(void);
# endif # endif
static void parse_command_name __ARGS((mparm_T *parmp)); static void parse_command_name(mparm_T *parmp);
static bool parse_char_i __ARGS((char_u **input, char val)); static bool parse_char_i(char_u **input, char val);
static bool parse_string __ARGS((char_u **input, char* val, int len)); static bool parse_string(char_u **input, char* val, int len);
static void command_line_scan __ARGS((mparm_T *parmp)); static void command_line_scan(mparm_T *parmp);
static void init_params __ARGS((mparm_T *parmp, int argc, char **argv)); static void init_params(mparm_T *parmp, int argc, char **argv);
static void init_startuptime __ARGS((mparm_T *parmp)); static void init_startuptime(mparm_T *parmp);
static void allocate_generic_buffers __ARGS((void)); static void allocate_generic_buffers(void);
static void check_and_set_isatty __ARGS((mparm_T *parmp)); static void check_and_set_isatty(mparm_T *parmp);
static char_u* get_fname __ARGS((mparm_T *parmp)); static char_u* get_fname(mparm_T *parmp);
static void set_window_layout __ARGS((mparm_T *parmp)); static void set_window_layout(mparm_T *parmp);
static void load_plugins __ARGS((void)); static void load_plugins(void);
static void handle_quickfix __ARGS((mparm_T *parmp)); static void handle_quickfix(mparm_T *parmp);
static void handle_tag __ARGS((char_u *tagname)); static void handle_tag(char_u *tagname);
static void check_tty __ARGS((mparm_T *parmp)); static void check_tty(mparm_T *parmp);
static void read_stdin __ARGS((void)); static void read_stdin(void);
static void create_windows __ARGS((mparm_T *parmp)); static void create_windows(mparm_T *parmp);
static void edit_buffers __ARGS((mparm_T *parmp)); static void edit_buffers(mparm_T *parmp);
static void exe_pre_commands __ARGS((mparm_T *parmp)); static void exe_pre_commands(mparm_T *parmp);
static void exe_commands __ARGS((mparm_T *parmp)); static void exe_commands(mparm_T *parmp);
static void source_startup_scripts __ARGS((mparm_T *parmp)); static void source_startup_scripts(mparm_T *parmp);
static void main_start_gui __ARGS((void)); static void main_start_gui(void);
# if defined(HAS_SWAP_EXISTS_ACTION) # if defined(HAS_SWAP_EXISTS_ACTION)
static void check_swap_exists_action __ARGS((void)); static void check_swap_exists_action(void);
# endif # endif
#endif /* NO_VIM_MAIN */ #endif /* NO_VIM_MAIN */
@ -2298,7 +2298,7 @@ static void check_swap_exists_action(void) {
#endif #endif
#if defined(STARTUPTIME) || defined(PROTO) #if defined(STARTUPTIME) || defined(PROTO)
static void time_diff __ARGS((struct timeval *then, struct timeval *now)); static void time_diff(struct timeval *then, struct timeval *now);
static struct timeval prev_timeval; static struct timeval prev_timeval;

50
src/main.h
View File

@ -1,30 +1,30 @@
#ifndef NEOVIM_MAIN_H #ifndef NEOVIM_MAIN_H
#define NEOVIM_MAIN_H #define NEOVIM_MAIN_H
/* main.c */ /* main.c */
void main_loop __ARGS((int cmdwin, int noexmode)); void main_loop(int cmdwin, int noexmode);
void getout_preserve_modified __ARGS((int exitval)); void getout_preserve_modified(int exitval);
void getout __ARGS((int exitval)); void getout(int exitval);
int process_env __ARGS((char_u *env, int is_viminit)); int process_env(char_u *env, int is_viminit);
void mainerr_arg_missing __ARGS((char_u *str)); void mainerr_arg_missing(char_u *str);
void time_push __ARGS((void *tv_rel, void *tv_start)); void time_push(void *tv_rel, void *tv_start);
void time_pop __ARGS((void *tp)); void time_pop(void *tp);
void time_msg __ARGS((char *mesg, void *tv_start)); void time_msg(char *mesg, void *tv_start);
void server_to_input_buf __ARGS((char_u *str)); void server_to_input_buf(char_u *str);
char_u *eval_client_expr_to_string __ARGS((char_u *expr)); char_u *eval_client_expr_to_string(char_u *expr);
char_u *serverConvert __ARGS((char_u *client_enc, char_u *data, char_u **tofree)); char_u *serverConvert(char_u *client_enc, char_u *data, char_u **tofree);
int toF_TyA __ARGS((int c)); int toF_TyA(int c);
int fkmap __ARGS((int c)); int fkmap(int c);
void conv_to_pvim __ARGS((void)); void conv_to_pvim(void);
void conv_to_pstd __ARGS((void)); void conv_to_pstd(void);
char_u *lrswap __ARGS((char_u *ibuf)); char_u *lrswap(char_u *ibuf);
char_u *lrFswap __ARGS((char_u *cmdbuf, int len)); char_u *lrFswap(char_u *cmdbuf, int len);
char_u *lrF_sub __ARGS((char_u *ibuf)); char_u *lrF_sub(char_u *ibuf);
int cmdl_fkmap __ARGS((int c)); int cmdl_fkmap(int c);
int F_isalpha __ARGS((int c)); int F_isalpha(int c);
int F_isdigit __ARGS((int c)); int F_isdigit(int c);
int F_ischar __ARGS((int c)); int F_ischar(int c);
void farsi_fkey __ARGS((cmdarg_T *cap)); void farsi_fkey(cmdarg_T *cap);
int arabic_shape __ARGS((int c, int *ccp, int *c1p, int prev_c, int prev_c1, int arabic_shape(int c, int *ccp, int *c1p, int prev_c, int prev_c1,
int next_c)); int next_c);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MAIN_H */ #endif /* NEOVIM_MAIN_H */

14
src/mark.c
View File

@ -46,12 +46,12 @@
#define EXTRA_MARKS 10 /* marks 0-9 */ #define EXTRA_MARKS 10 /* marks 0-9 */
static xfmark_T namedfm[NMARKS + EXTRA_MARKS]; /* marks with file nr */ static xfmark_T namedfm[NMARKS + EXTRA_MARKS]; /* marks with file nr */
static void fname2fnum __ARGS((xfmark_T *fm)); static void fname2fnum(xfmark_T *fm);
static void fmarks_check_one __ARGS((xfmark_T *fm, char_u *name, buf_T *buf)); static void fmarks_check_one(xfmark_T *fm, char_u *name, buf_T *buf);
static char_u *mark_line __ARGS((pos_T *mp, int lead_len)); static char_u *mark_line(pos_T *mp, int lead_len);
static void show_one_mark __ARGS((int, char_u *, pos_T *, char_u *, int current)); static void show_one_mark(int, char_u *, pos_T *, char_u *, int current);
static void cleanup_jumplist __ARGS((void)); static void cleanup_jumplist(void);
static void write_one_filemark __ARGS((FILE *fp, xfmark_T *fm, int c1, int c2)); static void write_one_filemark(FILE *fp, xfmark_T *fm, int c1, int c2);
/* /*
* Set named mark "c" at current cursor position. * Set named mark "c" at current cursor position.
@ -1321,7 +1321,7 @@ int removable(char_u *name)
return retval; return retval;
} }
static void write_one_mark __ARGS((FILE *fp_out, int c, pos_T *pos)); static void write_one_mark(FILE *fp_out, int c, pos_T *pos);
/* /*
* Write all the named marks for all buffers. * Write all the named marks for all buffers.

64
src/mark.h
View File

@ -1,37 +1,37 @@
#ifndef NEOVIM_MARK_H #ifndef NEOVIM_MARK_H
#define NEOVIM_MARK_H #define NEOVIM_MARK_H
/* mark.c */ /* mark.c */
int setmark __ARGS((int c)); int setmark(int c);
int setmark_pos __ARGS((int c, pos_T *pos, int fnum)); int setmark_pos(int c, pos_T *pos, int fnum);
void setpcmark __ARGS((void)); void setpcmark(void);
void checkpcmark __ARGS((void)); void checkpcmark(void);
pos_T *movemark __ARGS((int count)); pos_T *movemark(int count);
pos_T *movechangelist __ARGS((int count)); pos_T *movechangelist(int count);
pos_T *getmark_buf __ARGS((buf_T *buf, int c, int changefile)); pos_T *getmark_buf(buf_T *buf, int c, int changefile);
pos_T *getmark __ARGS((int c, int changefile)); pos_T *getmark(int c, int changefile);
pos_T *getmark_buf_fnum __ARGS((buf_T *buf, int c, int changefile, int *fnum)); pos_T *getmark_buf_fnum(buf_T *buf, int c, int changefile, int *fnum);
pos_T *getnextmark __ARGS((pos_T *startpos, int dir, int begin_line)); pos_T *getnextmark(pos_T *startpos, int dir, int begin_line);
void fmarks_check_names __ARGS((buf_T *buf)); void fmarks_check_names(buf_T *buf);
int check_mark __ARGS((pos_T *pos)); int check_mark(pos_T *pos);
void clrallmarks __ARGS((buf_T *buf)); void clrallmarks(buf_T *buf);
char_u *fm_getname __ARGS((fmark_T *fmark, int lead_len)); char_u *fm_getname(fmark_T *fmark, int lead_len);
void do_marks __ARGS((exarg_T *eap)); void do_marks(exarg_T *eap);
void ex_delmarks __ARGS((exarg_T *eap)); void ex_delmarks(exarg_T *eap);
void ex_jumps __ARGS((exarg_T *eap)); void ex_jumps(exarg_T *eap);
void ex_changes __ARGS((exarg_T *eap)); void ex_changes(exarg_T *eap);
void mark_adjust __ARGS((linenr_T line1, linenr_T line2, long amount, void mark_adjust(linenr_T line1, linenr_T line2, long amount,
long amount_after)); long amount_after);
void mark_col_adjust __ARGS((linenr_T lnum, colnr_T mincol, long lnum_amount, void mark_col_adjust(linenr_T lnum, colnr_T mincol, long lnum_amount,
long col_amount)); long col_amount);
void copy_jumplist __ARGS((win_T *from, win_T *to)); void copy_jumplist(win_T *from, win_T *to);
void free_jumplist __ARGS((win_T *wp)); void free_jumplist(win_T *wp);
void set_last_cursor __ARGS((win_T *win)); void set_last_cursor(win_T *win);
void free_all_marks __ARGS((void)); void free_all_marks(void);
int read_viminfo_filemark __ARGS((vir_T *virp, int force)); int read_viminfo_filemark(vir_T *virp, int force);
void write_viminfo_filemarks __ARGS((FILE *fp)); void write_viminfo_filemarks(FILE *fp);
int removable __ARGS((char_u *name)); int removable(char_u *name);
int write_viminfo_marks __ARGS((FILE *fp_out)); int write_viminfo_marks(FILE *fp_out);
void copy_viminfo_marks __ARGS((vir_T *virp, FILE *fp_out, int count, int eof, void copy_viminfo_marks(vir_T *virp, FILE *fp_out, int count, int eof,
int flags)); int flags);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MARK_H */ #endif /* NEOVIM_MARK_H */

32
src/mbyte.c
View File

@ -101,16 +101,16 @@
static int enc_canon_search __ARGS((char_u *name)); static int enc_canon_search(char_u *name);
static int dbcs_char2len __ARGS((int c)); static int dbcs_char2len(int c);
static int dbcs_char2bytes __ARGS((int c, char_u *buf)); static int dbcs_char2bytes(int c, char_u *buf);
static int dbcs_ptr2len __ARGS((char_u *p)); static int dbcs_ptr2len(char_u *p);
static int dbcs_ptr2len_len __ARGS((char_u *p, int size)); static int dbcs_ptr2len_len(char_u *p, int size);
static int utf_ptr2cells_len __ARGS((char_u *p, int size)); static int utf_ptr2cells_len(char_u *p, int size);
static int dbcs_char2cells __ARGS((int c)); static int dbcs_char2cells(int c);
static int dbcs_ptr2cells_len __ARGS((char_u *p, int size)); static int dbcs_ptr2cells_len(char_u *p, int size);
static int dbcs_ptr2char __ARGS((char_u *p)); static int dbcs_ptr2char(char_u *p);
static int utf_safe_read_char_adv __ARGS((char_u **s, size_t *n)); static int utf_safe_read_char_adv(char_u **s, size_t *n);
/* /*
* Lookup table to quickly get the length in bytes of a UTF-8 character from * Lookup table to quickly get the length in bytes of a UTF-8 character from
@ -953,7 +953,7 @@ struct interval {
long first; long first;
long last; long last;
}; };
static int intable __ARGS((struct interval *table, size_t size, int c)); static int intable(struct interval *table, size_t size, int c);
/* /*
* Return TRUE if "c" is in "table[size / sizeof(struct interval)]". * Return TRUE if "c" is in "table[size / sizeof(struct interval)]".
@ -2405,8 +2405,8 @@ static convertStruct foldCase[] =
{0x10400,0x10427,1,40} {0x10400,0x10427,1,40}
}; };
static int utf_convert __ARGS((int a, convertStruct table[], int tableSize)); static int utf_convert(int a, convertStruct table[], int tableSize);
static int utf_strnicmp __ARGS((char_u *s1, char_u *s2, size_t n1, size_t n2)); static int utf_strnicmp(char_u *s1, char_u *s2, size_t n1, size_t n2);
/* /*
* Generic conversion function for case operations. * Generic conversion function for case operations.
@ -3366,7 +3366,7 @@ int mb_fix_col(int col, int row)
return col; return col;
} }
static int enc_alias_search __ARGS((char_u *name)); static int enc_alias_search(char_u *name);
/* /*
* Skip the Vim specific head of a 'encoding' name. * Skip the Vim specific head of a 'encoding' name.
@ -3526,8 +3526,8 @@ char_u * enc_locale() {
# if defined(USE_ICONV) || defined(PROTO) # if defined(USE_ICONV) || defined(PROTO)
static char_u * static char_u *
iconv_string __ARGS((vimconv_T *vcp, char_u *str, int slen, int *unconvlenp, iconv_string(vimconv_T *vcp, char_u *str, int slen, int *unconvlenp,
int *resultlenp)); int *resultlenp);
/* /*
* Call iconv_open() with a check if iconv() works properly (there are broken * Call iconv_open() with a check if iconv() works properly (there are broken

194
src/mbyte.h
View File

@ -1,103 +1,103 @@
#ifndef NEOVIM_MBYTE_H #ifndef NEOVIM_MBYTE_H
#define NEOVIM_MBYTE_H #define NEOVIM_MBYTE_H
/* mbyte.c */ /* mbyte.c */
int enc_canon_props __ARGS((char_u *name)); int enc_canon_props(char_u *name);
char_u *mb_init __ARGS((void)); char_u *mb_init(void);
int bomb_size __ARGS((void)); int bomb_size(void);
void remove_bom __ARGS((char_u *s)); void remove_bom(char_u *s);
int mb_get_class __ARGS((char_u *p)); int mb_get_class(char_u *p);
int mb_get_class_buf __ARGS((char_u *p, buf_T *buf)); int mb_get_class_buf(char_u *p, buf_T *buf);
int dbcs_class __ARGS((unsigned lead, unsigned trail)); int dbcs_class(unsigned lead, unsigned trail);
int latin_char2len __ARGS((int c)); int latin_char2len(int c);
int latin_char2bytes __ARGS((int c, char_u *buf)); int latin_char2bytes(int c, char_u *buf);
int latin_ptr2len __ARGS((char_u *p)); int latin_ptr2len(char_u *p);
int latin_ptr2len_len __ARGS((char_u *p, int size)); int latin_ptr2len_len(char_u *p, int size);
int utf_char2cells __ARGS((int c)); int utf_char2cells(int c);
int latin_ptr2cells __ARGS((char_u *p)); int latin_ptr2cells(char_u *p);
int utf_ptr2cells __ARGS((char_u *p)); int utf_ptr2cells(char_u *p);
int dbcs_ptr2cells __ARGS((char_u *p)); int dbcs_ptr2cells(char_u *p);
int latin_ptr2cells_len __ARGS((char_u *p, int size)); int latin_ptr2cells_len(char_u *p, int size);
int latin_char2cells __ARGS((int c)); int latin_char2cells(int c);
int mb_string2cells __ARGS((char_u *p, int len)); int mb_string2cells(char_u *p, int len);
int latin_off2cells __ARGS((unsigned off, unsigned max_off)); int latin_off2cells(unsigned off, unsigned max_off);
int dbcs_off2cells __ARGS((unsigned off, unsigned max_off)); int dbcs_off2cells(unsigned off, unsigned max_off);
int utf_off2cells __ARGS((unsigned off, unsigned max_off)); int utf_off2cells(unsigned off, unsigned max_off);
int latin_ptr2char __ARGS((char_u *p)); int latin_ptr2char(char_u *p);
int utf_ptr2char __ARGS((char_u *p)); int utf_ptr2char(char_u *p);
int mb_ptr2char_adv __ARGS((char_u **pp)); int mb_ptr2char_adv(char_u **pp);
int mb_cptr2char_adv __ARGS((char_u **pp)); int mb_cptr2char_adv(char_u **pp);
int arabic_combine __ARGS((int one, int two)); int arabic_combine(int one, int two);
int arabic_maycombine __ARGS((int two)); int arabic_maycombine(int two);
int utf_composinglike __ARGS((char_u *p1, char_u *p2)); int utf_composinglike(char_u *p1, char_u *p2);
int utfc_ptr2char __ARGS((char_u *p, int *pcc)); int utfc_ptr2char(char_u *p, int *pcc);
int utfc_ptr2char_len __ARGS((char_u *p, int *pcc, int maxlen)); int utfc_ptr2char_len(char_u *p, int *pcc, int maxlen);
int utfc_char2bytes __ARGS((int off, char_u *buf)); int utfc_char2bytes(int off, char_u *buf);
int utf_ptr2len __ARGS((char_u *p)); int utf_ptr2len(char_u *p);
int utf_byte2len __ARGS((int b)); int utf_byte2len(int b);
int utf_ptr2len_len __ARGS((char_u *p, int size)); int utf_ptr2len_len(char_u *p, int size);
int utfc_ptr2len __ARGS((char_u *p)); int utfc_ptr2len(char_u *p);
int utfc_ptr2len_len __ARGS((char_u *p, int size)); int utfc_ptr2len_len(char_u *p, int size);
int utf_char2len __ARGS((int c)); int utf_char2len(int c);
int utf_char2bytes __ARGS((int c, char_u *buf)); int utf_char2bytes(int c, char_u *buf);
int utf_iscomposing __ARGS((int c)); int utf_iscomposing(int c);
int utf_printable __ARGS((int c)); int utf_printable(int c);
int utf_class __ARGS((int c)); int utf_class(int c);
int utf_fold __ARGS((int a)); int utf_fold(int a);
int utf_toupper __ARGS((int a)); int utf_toupper(int a);
int utf_islower __ARGS((int a)); int utf_islower(int a);
int utf_tolower __ARGS((int a)); int utf_tolower(int a);
int utf_isupper __ARGS((int a)); int utf_isupper(int a);
int mb_strnicmp __ARGS((char_u *s1, char_u *s2, size_t nn)); int mb_strnicmp(char_u *s1, char_u *s2, size_t nn);
void show_utf8 __ARGS((void)); void show_utf8(void);
int latin_head_off __ARGS((char_u *base, char_u *p)); int latin_head_off(char_u *base, char_u *p);
int dbcs_head_off __ARGS((char_u *base, char_u *p)); int dbcs_head_off(char_u *base, char_u *p);
int dbcs_screen_head_off __ARGS((char_u *base, char_u *p)); int dbcs_screen_head_off(char_u *base, char_u *p);
int utf_head_off __ARGS((char_u *base, char_u *p)); int utf_head_off(char_u *base, char_u *p);
void mb_copy_char __ARGS((char_u **fp, char_u **tp)); void mb_copy_char(char_u **fp, char_u **tp);
int mb_off_next __ARGS((char_u *base, char_u *p)); int mb_off_next(char_u *base, char_u *p);
int mb_tail_off __ARGS((char_u *base, char_u *p)); int mb_tail_off(char_u *base, char_u *p);
void utf_find_illegal __ARGS((void)); void utf_find_illegal(void);
int utf_valid_string __ARGS((char_u *s, char_u *end)); int utf_valid_string(char_u *s, char_u *end);
int dbcs_screen_tail_off __ARGS((char_u *base, char_u *p)); int dbcs_screen_tail_off(char_u *base, char_u *p);
void mb_adjust_cursor __ARGS((void)); void mb_adjust_cursor(void);
void mb_adjustpos __ARGS((buf_T *buf, pos_T *lp)); void mb_adjustpos(buf_T *buf, pos_T *lp);
char_u *mb_prevptr __ARGS((char_u *line, char_u *p)); char_u *mb_prevptr(char_u *line, char_u *p);
int mb_charlen __ARGS((char_u *str)); int mb_charlen(char_u *str);
int mb_charlen_len __ARGS((char_u *str, int len)); int mb_charlen_len(char_u *str, int len);
char_u *mb_unescape __ARGS((char_u **pp)); char_u *mb_unescape(char_u **pp);
int mb_lefthalve __ARGS((int row, int col)); int mb_lefthalve(int row, int col);
int mb_fix_col __ARGS((int col, int row)); int mb_fix_col(int col, int row);
char_u *enc_skip __ARGS((char_u *p)); char_u *enc_skip(char_u *p);
char_u *enc_canonize __ARGS((char_u *enc)); char_u *enc_canonize(char_u *enc);
char_u *enc_locale __ARGS((void)); char_u *enc_locale(void);
int encname2codepage __ARGS((char_u *name)); int encname2codepage(char_u *name);
void *my_iconv_open __ARGS((char_u *to, char_u *from)); void *my_iconv_open(char_u *to, char_u *from);
int iconv_enabled __ARGS((int verbose)); int iconv_enabled(int verbose);
void iconv_end __ARGS((void)); void iconv_end(void);
void im_set_active __ARGS((int active)); void im_set_active(int active);
void xim_set_focus __ARGS((int focus)); void xim_set_focus(int focus);
void im_set_position __ARGS((int row, int col)); void im_set_position(int row, int col);
void xim_set_preedit __ARGS((void)); void xim_set_preedit(void);
int im_get_feedback_attr __ARGS((int col)); int im_get_feedback_attr(int col);
void xim_init __ARGS((void)); void xim_init(void);
void im_shutdown __ARGS((void)); void im_shutdown(void);
int im_xim_isvalid_imactivate __ARGS((void)); int im_xim_isvalid_imactivate(void);
void xim_reset __ARGS((void)); void xim_reset(void);
int xim_queue_key_press_event __ARGS((GdkEventKey *event, int down)); int xim_queue_key_press_event(GdkEventKey *event, int down);
int im_get_status __ARGS((void)); int im_get_status(void);
int preedit_get_status __ARGS((void)); int preedit_get_status(void);
int im_is_preediting __ARGS((void)); int im_is_preediting(void);
void xim_set_status_area __ARGS((void)); void xim_set_status_area(void);
int xim_get_status_area_height __ARGS((void)); int xim_get_status_area_height(void);
int convert_setup __ARGS((vimconv_T *vcp, char_u *from, char_u *to)); int convert_setup(vimconv_T *vcp, char_u *from, char_u *to);
int convert_setup_ext __ARGS((vimconv_T *vcp, char_u *from, int convert_setup_ext(vimconv_T *vcp, char_u *from,
int from_unicode_is_utf8, char_u *to, int from_unicode_is_utf8, char_u *to,
int to_unicode_is_utf8)); int to_unicode_is_utf8);
int convert_input __ARGS((char_u *ptr, int len, int maxlen)); int convert_input(char_u *ptr, int len, int maxlen);
int convert_input_safe __ARGS((char_u *ptr, int len, int maxlen, char_u **restp, int convert_input_safe(char_u *ptr, int len, int maxlen, char_u **restp,
int *restlenp)); int *restlenp);
char_u *string_convert __ARGS((vimconv_T *vcp, char_u *ptr, int *lenp)); char_u *string_convert(vimconv_T *vcp, char_u *ptr, int *lenp);
char_u *string_convert_ext __ARGS((vimconv_T *vcp, char_u *ptr, int *lenp, char_u *string_convert_ext(vimconv_T *vcp, char_u *ptr, int *lenp,
int *unconvlenp)); int *unconvlenp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MBYTE_H */ #endif /* NEOVIM_MBYTE_H */

46
src/memfile.c
View File

@ -65,29 +65,29 @@
static long_u total_mem_used = 0; /* total memory used for memfiles */ static long_u total_mem_used = 0; /* total memory used for memfiles */
static void mf_ins_hash __ARGS((memfile_T *, bhdr_T *)); static void mf_ins_hash(memfile_T *, bhdr_T *);
static void mf_rem_hash __ARGS((memfile_T *, bhdr_T *)); static void mf_rem_hash(memfile_T *, bhdr_T *);
static bhdr_T *mf_find_hash __ARGS((memfile_T *, blocknr_T)); static bhdr_T *mf_find_hash(memfile_T *, blocknr_T);
static void mf_ins_used __ARGS((memfile_T *, bhdr_T *)); static void mf_ins_used(memfile_T *, bhdr_T *);
static void mf_rem_used __ARGS((memfile_T *, bhdr_T *)); static void mf_rem_used(memfile_T *, bhdr_T *);
static bhdr_T *mf_release __ARGS((memfile_T *, int)); static bhdr_T *mf_release(memfile_T *, int);
static bhdr_T *mf_alloc_bhdr __ARGS((memfile_T *, int)); static bhdr_T *mf_alloc_bhdr(memfile_T *, int);
static void mf_free_bhdr __ARGS((bhdr_T *)); static void mf_free_bhdr(bhdr_T *);
static void mf_ins_free __ARGS((memfile_T *, bhdr_T *)); static void mf_ins_free(memfile_T *, bhdr_T *);
static bhdr_T *mf_rem_free __ARGS((memfile_T *)); static bhdr_T *mf_rem_free(memfile_T *);
static int mf_read __ARGS((memfile_T *, bhdr_T *)); static int mf_read(memfile_T *, bhdr_T *);
static int mf_write __ARGS((memfile_T *, bhdr_T *)); static int mf_write(memfile_T *, bhdr_T *);
static int mf_write_block __ARGS((memfile_T *mfp, bhdr_T *hp, off_t offset, static int mf_write_block(memfile_T *mfp, bhdr_T *hp, off_t offset,
unsigned size)); unsigned size);
static int mf_trans_add __ARGS((memfile_T *, bhdr_T *)); static int mf_trans_add(memfile_T *, bhdr_T *);
static void mf_do_open __ARGS((memfile_T *, char_u *, int)); static void mf_do_open(memfile_T *, char_u *, int);
static void mf_hash_init __ARGS((mf_hashtab_T *)); static void mf_hash_init(mf_hashtab_T *);
static void mf_hash_free __ARGS((mf_hashtab_T *)); static void mf_hash_free(mf_hashtab_T *);
static void mf_hash_free_all __ARGS((mf_hashtab_T *)); static void mf_hash_free_all(mf_hashtab_T *);
static mf_hashitem_T *mf_hash_find __ARGS((mf_hashtab_T *, blocknr_T)); static mf_hashitem_T *mf_hash_find(mf_hashtab_T *, blocknr_T);
static void mf_hash_add_item __ARGS((mf_hashtab_T *, mf_hashitem_T *)); static void mf_hash_add_item(mf_hashtab_T *, mf_hashitem_T *);
static void mf_hash_rem_item __ARGS((mf_hashtab_T *, mf_hashitem_T *)); static void mf_hash_rem_item(mf_hashtab_T *, mf_hashitem_T *);
static int mf_hash_grow __ARGS((mf_hashtab_T *)); static int mf_hash_grow(mf_hashtab_T *);
/* /*
* The functions for using a memfile: * The functions for using a memfile:

32
src/memfile.h
View File

@ -1,21 +1,21 @@
#ifndef NEOVIM_MEMFILE_H #ifndef NEOVIM_MEMFILE_H
#define NEOVIM_MEMFILE_H #define NEOVIM_MEMFILE_H
/* memfile.c */ /* memfile.c */
memfile_T *mf_open __ARGS((char_u *fname, int flags)); memfile_T *mf_open(char_u *fname, int flags);
int mf_open_file __ARGS((memfile_T *mfp, char_u *fname)); int mf_open_file(memfile_T *mfp, char_u *fname);
void mf_close __ARGS((memfile_T *mfp, int del_file)); void mf_close(memfile_T *mfp, int del_file);
void mf_close_file __ARGS((buf_T *buf, int getlines)); void mf_close_file(buf_T *buf, int getlines);
void mf_new_page_size __ARGS((memfile_T *mfp, unsigned new_size)); void mf_new_page_size(memfile_T *mfp, unsigned new_size);
bhdr_T *mf_new __ARGS((memfile_T *mfp, int negative, int page_count)); bhdr_T *mf_new(memfile_T *mfp, int negative, int page_count);
bhdr_T *mf_get __ARGS((memfile_T *mfp, blocknr_T nr, int page_count)); bhdr_T *mf_get(memfile_T *mfp, blocknr_T nr, int page_count);
void mf_put __ARGS((memfile_T *mfp, bhdr_T *hp, int dirty, int infile)); void mf_put(memfile_T *mfp, bhdr_T *hp, int dirty, int infile);
void mf_free __ARGS((memfile_T *mfp, bhdr_T *hp)); void mf_free(memfile_T *mfp, bhdr_T *hp);
int mf_sync __ARGS((memfile_T *mfp, int flags)); int mf_sync(memfile_T *mfp, int flags);
void mf_set_dirty __ARGS((memfile_T *mfp)); void mf_set_dirty(memfile_T *mfp);
int mf_release_all __ARGS((void)); int mf_release_all(void);
blocknr_T mf_trans_del __ARGS((memfile_T *mfp, blocknr_T old_nr)); blocknr_T mf_trans_del(memfile_T *mfp, blocknr_T old_nr);
void mf_set_ffname __ARGS((memfile_T *mfp)); void mf_set_ffname(memfile_T *mfp);
void mf_fullname __ARGS((memfile_T *mfp)); void mf_fullname(memfile_T *mfp);
int mf_need_trans __ARGS((memfile_T *mfp)); int mf_need_trans(memfile_T *mfp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MEMFILE_H */ #endif /* NEOVIM_MEMFILE_H */

52
src/memline.c
View File

@ -243,34 +243,34 @@ typedef enum {
, UB_CRYPT /* update crypt key */ , UB_CRYPT /* update crypt key */
} upd_block0_T; } upd_block0_T;
static void ml_set_b0_crypt __ARGS((buf_T *buf, ZERO_BL *b0p)); static void ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p);
static int ml_check_b0_id __ARGS((ZERO_BL *b0p)); static int ml_check_b0_id(ZERO_BL *b0p);
static void ml_upd_block0 __ARGS((buf_T *buf, upd_block0_T what)); static void ml_upd_block0(buf_T *buf, upd_block0_T what);
static void set_b0_fname __ARGS((ZERO_BL *, buf_T *buf)); static void set_b0_fname(ZERO_BL *, buf_T *buf);
static void set_b0_dir_flag __ARGS((ZERO_BL *b0p, buf_T *buf)); static void set_b0_dir_flag(ZERO_BL *b0p, buf_T *buf);
static void add_b0_fenc __ARGS((ZERO_BL *b0p, buf_T *buf)); static void add_b0_fenc(ZERO_BL *b0p, buf_T *buf);
static time_t swapfile_info __ARGS((char_u *)); static time_t swapfile_info(char_u *);
static int recov_file_names __ARGS((char_u **, char_u *, int prepend_dot)); static int recov_file_names(char_u **, char_u *, int prepend_dot);
static int ml_append_int __ARGS((buf_T *, linenr_T, char_u *, colnr_T, int, int)); static int ml_append_int(buf_T *, linenr_T, char_u *, colnr_T, int, int);
static int ml_delete_int __ARGS((buf_T *, linenr_T, int)); static int ml_delete_int(buf_T *, linenr_T, int);
static char_u *findswapname __ARGS((buf_T *, char_u **, char_u *)); static char_u *findswapname(buf_T *, char_u **, char_u *);
static void ml_flush_line __ARGS((buf_T *)); static void ml_flush_line(buf_T *);
static bhdr_T *ml_new_data __ARGS((memfile_T *, int, int)); static bhdr_T *ml_new_data(memfile_T *, int, int);
static bhdr_T *ml_new_ptr __ARGS((memfile_T *)); static bhdr_T *ml_new_ptr(memfile_T *);
static bhdr_T *ml_find_line __ARGS((buf_T *, linenr_T, int)); static bhdr_T *ml_find_line(buf_T *, linenr_T, int);
static int ml_add_stack __ARGS((buf_T *)); static int ml_add_stack(buf_T *);
static void ml_lineadd __ARGS((buf_T *, int)); static void ml_lineadd(buf_T *, int);
static int b0_magic_wrong __ARGS((ZERO_BL *)); static int b0_magic_wrong(ZERO_BL *);
#ifdef CHECK_INODE #ifdef CHECK_INODE
static int fnamecmp_ino __ARGS((char_u *, char_u *, long)); static int fnamecmp_ino(char_u *, char_u *, long);
#endif #endif
static void long_to_char __ARGS((long, char_u *)); static void long_to_char(long, char_u *);
static long char_to_long __ARGS((char_u *)); static long char_to_long(char_u *);
#if defined(UNIX) || defined(WIN3264) #if defined(UNIX) || defined(WIN3264)
static char_u *make_percent_swname __ARGS((char_u *dir, char_u *name)); static char_u *make_percent_swname(char_u *dir, char_u *name);
#endif #endif
static void ml_crypt_prepare __ARGS((memfile_T *mfp, off_t offset, int reading)); static void ml_crypt_prepare(memfile_T *mfp, off_t offset, int reading);
static void ml_updatechunk __ARGS((buf_T *buf, long line, long len, int updtype)); static void ml_updatechunk(buf_T *buf, long line, long len, int updtype);
/* /*
* Open a new memline for "buf". * Open a new memline for "buf".
@ -3506,7 +3506,7 @@ get_file_in_dir (
return retval; return retval;
} }
static void attention_message __ARGS((buf_T *buf, char_u *fname)); static void attention_message(buf_T *buf, char_u *fname);
/* /*
* Print the ATTENTION message: info about an existing swap file. * Print the ATTENTION message: info about an existing swap file.
@ -3557,7 +3557,7 @@ attention_message (
--no_wait_return; --no_wait_return;
} }
static int do_swapexists __ARGS((buf_T *buf, char_u *fname)); static int do_swapexists(buf_T *buf, char_u *fname);
/* /*
* Trigger the SwapExists autocommands. * Trigger the SwapExists autocommands.

78
src/memline.h
View File

@ -1,44 +1,44 @@
#ifndef NEOVIM_MEMLINE_H #ifndef NEOVIM_MEMLINE_H
#define NEOVIM_MEMLINE_H #define NEOVIM_MEMLINE_H
/* memline.c */ /* memline.c */
int ml_open __ARGS((buf_T *buf)); int ml_open(buf_T *buf);
void ml_set_crypt_key __ARGS((buf_T *buf, char_u *old_key, int old_cm)); void ml_set_crypt_key(buf_T *buf, char_u *old_key, int old_cm);
void ml_setname __ARGS((buf_T *buf)); void ml_setname(buf_T *buf);
void ml_open_files __ARGS((void)); void ml_open_files(void);
void ml_open_file __ARGS((buf_T *buf)); void ml_open_file(buf_T *buf);
void check_need_swap __ARGS((int newfile)); void check_need_swap(int newfile);
void ml_close __ARGS((buf_T *buf, int del_file)); void ml_close(buf_T *buf, int del_file);
void ml_close_all __ARGS((int del_file)); void ml_close_all(int del_file);
void ml_close_notmod __ARGS((void)); void ml_close_notmod(void);
void ml_timestamp __ARGS((buf_T *buf)); void ml_timestamp(buf_T *buf);
void ml_recover __ARGS((void)); void ml_recover(void);
int recover_names __ARGS((char_u *fname, int list, int nr, char_u **fname_out)); int recover_names(char_u *fname, int list, int nr, char_u **fname_out);
void ml_sync_all __ARGS((int check_file, int check_char)); void ml_sync_all(int check_file, int check_char);
void ml_preserve __ARGS((buf_T *buf, int message)); void ml_preserve(buf_T *buf, int message);
char_u *ml_get __ARGS((linenr_T lnum)); char_u *ml_get(linenr_T lnum);
char_u *ml_get_pos __ARGS((pos_T *pos)); char_u *ml_get_pos(pos_T *pos);
char_u *ml_get_curline __ARGS((void)); char_u *ml_get_curline(void);
char_u *ml_get_cursor __ARGS((void)); char_u *ml_get_cursor(void);
char_u *ml_get_buf __ARGS((buf_T *buf, linenr_T lnum, int will_change)); char_u *ml_get_buf(buf_T *buf, linenr_T lnum, int will_change);
int ml_line_alloced __ARGS((void)); int ml_line_alloced(void);
int ml_append __ARGS((linenr_T lnum, char_u *line, colnr_T len, int newfile)); int ml_append(linenr_T lnum, char_u *line, colnr_T len, int newfile);
int ml_append_buf __ARGS((buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len,
int newfile)); int newfile);
int ml_replace __ARGS((linenr_T lnum, char_u *line, int copy)); int ml_replace(linenr_T lnum, char_u *line, int copy);
int ml_delete __ARGS((linenr_T lnum, int message)); int ml_delete(linenr_T lnum, int message);
void ml_setmarked __ARGS((linenr_T lnum)); void ml_setmarked(linenr_T lnum);
linenr_T ml_firstmarked __ARGS((void)); linenr_T ml_firstmarked(void);
void ml_clearmarked __ARGS((void)); void ml_clearmarked(void);
int resolve_symlink __ARGS((char_u *fname, char_u *buf)); int resolve_symlink(char_u *fname, char_u *buf);
char_u *makeswapname __ARGS((char_u *fname, char_u *ffname, buf_T *buf, char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf,
char_u *dir_name)); char_u *dir_name);
char_u *get_file_in_dir __ARGS((char_u *fname, char_u *dname)); char_u *get_file_in_dir(char_u *fname, char_u *dname);
void ml_setflags __ARGS((buf_T *buf)); void ml_setflags(buf_T *buf);
char_u *ml_encrypt_data __ARGS((memfile_T *mfp, char_u *data, off_t offset, char_u *ml_encrypt_data(memfile_T *mfp, char_u *data, off_t offset,
unsigned size)); unsigned size);
void ml_decrypt_data __ARGS((memfile_T *mfp, char_u *data, off_t offset, void ml_decrypt_data(memfile_T *mfp, char_u *data, off_t offset,
unsigned size)); unsigned size);
long ml_find_line_or_offset __ARGS((buf_T *buf, linenr_T lnum, long *offp)); long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp);
void goto_byte __ARGS((long cnt)); void goto_byte(long cnt);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MEMLINE_H */ #endif /* NEOVIM_MEMLINE_H */

38
src/menu.c
View File

@ -27,29 +27,29 @@
#define MENUDEPTH 10 /* maximum depth of menus */ #define MENUDEPTH 10 /* maximum depth of menus */
static int add_menu_path __ARGS((char_u *, vimmenu_T *, int *, char_u *)); static int add_menu_path(char_u *, vimmenu_T *, int *, char_u *);
static int menu_nable_recurse __ARGS((vimmenu_T *menu, char_u *name, int modes, static int menu_nable_recurse(vimmenu_T *menu, char_u *name, int modes,
int enable)); int enable);
static int remove_menu __ARGS((vimmenu_T **, char_u *, int, int silent)); static int remove_menu(vimmenu_T **, char_u *, int, int silent);
static void free_menu __ARGS((vimmenu_T **menup)); static void free_menu(vimmenu_T **menup);
static void free_menu_string __ARGS((vimmenu_T *, int)); static void free_menu_string(vimmenu_T *, int);
static int show_menus __ARGS((char_u *, int)); static int show_menus(char_u *, int);
static void show_menus_recursive __ARGS((vimmenu_T *, int, int)); static void show_menus_recursive(vimmenu_T *, int, int);
static int menu_name_equal __ARGS((char_u *name, vimmenu_T *menu)); static int menu_name_equal(char_u *name, vimmenu_T *menu);
static int menu_namecmp __ARGS((char_u *name, char_u *mname)); static int menu_namecmp(char_u *name, char_u *mname);
static int get_menu_cmd_modes __ARGS((char_u *, int, int *, int *)); static int get_menu_cmd_modes(char_u *, int, int *, int *);
static char_u *popup_mode_name __ARGS((char_u *name, int idx)); static char_u *popup_mode_name(char_u *name, int idx);
static char_u *menu_text __ARGS((char_u *text, int *mnemonic, char_u **actext)); static char_u *menu_text(char_u *text, int *mnemonic, char_u **actext);
static int menu_is_hidden __ARGS((char_u *name)); static int menu_is_hidden(char_u *name);
static int menu_is_tearoff __ARGS((char_u *name)); static int menu_is_tearoff(char_u *name);
static char_u *menu_skip_part __ARGS((char_u *p)); static char_u *menu_skip_part(char_u *p);
static char_u *menutrans_lookup __ARGS((char_u *name, int len)); static char_u *menutrans_lookup(char_u *name, int len);
static void menu_unescape_name __ARGS((char_u *p)); static void menu_unescape_name(char_u *p);
static char_u *menu_translate_tab_and_shift __ARGS((char_u *arg_start)); static char_u *menu_translate_tab_and_shift(char_u *arg_start);
/* The character for each menu mode */ /* The character for each menu mode */
static char_u menu_mode_chars[] = {'n', 'v', 's', 'o', 'i', 'c', 't'}; static char_u menu_mode_chars[] = {'n', 'v', 's', 'o', 'i', 'c', 't'};

42
src/menu.h
View File

@ -1,26 +1,26 @@
#ifndef NEOVIM_MENU_H #ifndef NEOVIM_MENU_H
#define NEOVIM_MENU_H #define NEOVIM_MENU_H
/* menu.c */ /* menu.c */
void ex_menu __ARGS((exarg_T *eap)); void ex_menu(exarg_T *eap);
char_u *set_context_in_menu_cmd __ARGS((expand_T *xp, char_u *cmd, char_u *arg, char_u *set_context_in_menu_cmd(expand_T *xp, char_u *cmd, char_u *arg,
int forceit)); int forceit);
char_u *get_menu_name __ARGS((expand_T *xp, int idx)); char_u *get_menu_name(expand_T *xp, int idx);
char_u *get_menu_names __ARGS((expand_T *xp, int idx)); char_u *get_menu_names(expand_T *xp, int idx);
char_u *menu_name_skip __ARGS((char_u *name)); char_u *menu_name_skip(char_u *name);
int get_menu_index __ARGS((vimmenu_T *menu, int state)); int get_menu_index(vimmenu_T *menu, int state);
int menu_is_menubar __ARGS((char_u *name)); int menu_is_menubar(char_u *name);
int menu_is_popup __ARGS((char_u *name)); int menu_is_popup(char_u *name);
int menu_is_child_of_popup __ARGS((vimmenu_T *menu)); int menu_is_child_of_popup(vimmenu_T *menu);
int menu_is_toolbar __ARGS((char_u *name)); int menu_is_toolbar(char_u *name);
int menu_is_separator __ARGS((char_u *name)); int menu_is_separator(char_u *name);
int check_menu_pointer __ARGS((vimmenu_T *root, vimmenu_T *menu_to_check)); int check_menu_pointer(vimmenu_T *root, vimmenu_T *menu_to_check);
void gui_create_initial_menus __ARGS((vimmenu_T *menu)); void gui_create_initial_menus(vimmenu_T *menu);
void gui_update_menus __ARGS((int modes)); void gui_update_menus(int modes);
int gui_is_menu_shortcut __ARGS((int key)); int gui_is_menu_shortcut(int key);
void gui_show_popupmenu __ARGS((void)); void gui_show_popupmenu(void);
void gui_mch_toggle_tearoffs __ARGS((int enable)); void gui_mch_toggle_tearoffs(int enable);
void ex_emenu __ARGS((exarg_T *eap)); void ex_emenu(exarg_T *eap);
vimmenu_T *gui_find_menu __ARGS((char_u *path_name)); vimmenu_T *gui_find_menu(char_u *path_name);
void ex_menutranslate __ARGS((exarg_T *eap)); void ex_menutranslate(exarg_T *eap);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MENU_H */ #endif /* NEOVIM_MENU_H */

68
src/message.c
View File

@ -34,29 +34,29 @@
# include <math.h> # include <math.h>
#endif #endif
static int other_sourcing_name __ARGS((void)); static int other_sourcing_name(void);
static char_u *get_emsg_source __ARGS((void)); static char_u *get_emsg_source(void);
static char_u *get_emsg_lnum __ARGS((void)); static char_u *get_emsg_lnum(void);
static void add_msg_hist __ARGS((char_u *s, int len, int attr)); static void add_msg_hist(char_u *s, int len, int attr);
static void hit_return_msg __ARGS((void)); static void hit_return_msg(void);
static void msg_home_replace_attr __ARGS((char_u *fname, int attr)); static void msg_home_replace_attr(char_u *fname, int attr);
static char_u *screen_puts_mbyte __ARGS((char_u *s, int l, int attr)); static char_u *screen_puts_mbyte(char_u *s, int l, int attr);
static void msg_puts_attr_len __ARGS((char_u *str, int maxlen, int attr)); static void msg_puts_attr_len(char_u *str, int maxlen, int attr);
static void msg_puts_display __ARGS((char_u *str, int maxlen, int attr, static void msg_puts_display(char_u *str, int maxlen, int attr,
int recurse)); int recurse);
static void msg_scroll_up __ARGS((void)); static void msg_scroll_up(void);
static void inc_msg_scrolled __ARGS((void)); static void inc_msg_scrolled(void);
static void store_sb_text __ARGS((char_u **sb_str, char_u *s, int attr, static void store_sb_text(char_u **sb_str, char_u *s, int attr,
int *sb_col, int *sb_col,
int finish)); int finish);
static void t_puts __ARGS((int *t_col, char_u *t_s, char_u *s, int attr)); static void t_puts(int *t_col, char_u *t_s, char_u *s, int attr);
static void msg_puts_printf __ARGS((char_u *str, int maxlen)); static void msg_puts_printf(char_u *str, int maxlen);
static int do_more_prompt __ARGS((int typed_char)); static int do_more_prompt(int typed_char);
static void msg_screen_putchar __ARGS((int c, int attr)); static void msg_screen_putchar(int c, int attr);
static int msg_check_screen __ARGS((void)); static int msg_check_screen(void);
static void redir_write __ARGS((char_u *s, int maxlen)); static void redir_write(char_u *s, int maxlen);
static char_u *msg_show_console_dialog __ARGS((char_u *message, char_u *buttons, static char_u *msg_show_console_dialog(char_u *message, char_u *buttons,
int dfltbutton)); int dfltbutton);
static int confirm_msg_used = FALSE; /* displaying confirm_msg */ static int confirm_msg_used = FALSE; /* displaying confirm_msg */
static char_u *confirm_msg = NULL; /* ":confirm" message */ static char_u *confirm_msg = NULL; /* ":confirm" message */
static char_u *confirm_msg_tail; /* tail of confirm_msg */ static char_u *confirm_msg_tail; /* tail of confirm_msg */
@ -326,14 +326,14 @@ void trunc_string(char_u *s, char_u *buf, int room, int buflen)
# ifndef HAVE_STDARG_H # ifndef HAVE_STDARG_H
int int
smsg __ARGS((char_u *, long, long, long, smsg(char_u *, long, long, long,
long, long, long, long, long, long, long)); long, long, long, long, long, long, long);
int int
smsg_attr __ARGS((int, char_u *, long, long, long, smsg_attr(int, char_u *, long, long, long,
long, long, long, long, long, long, long)); long, long, long, long, long, long, long);
int vim_snprintf __ARGS((char *, size_t, char *, long, long, long, int vim_snprintf(char *, size_t, char *, long, long, long,
long, long, long, long, long, long, long)); long, long, long, long, long, long, long);
/* /*
* smsg(str, arg, ...) is like using sprintf(buf, str, arg, ...) and then * smsg(str, arg, ...) is like using sprintf(buf, str, arg, ...) and then
@ -1861,8 +1861,8 @@ struct msgchunk_S {
static msgchunk_T *last_msgchunk = NULL; /* last displayed text */ static msgchunk_T *last_msgchunk = NULL; /* last displayed text */
static msgchunk_T *msg_sb_start __ARGS((msgchunk_T *mps)); static msgchunk_T *msg_sb_start(msgchunk_T *mps);
static msgchunk_T *disp_sb_line __ARGS((int row, msgchunk_T *smp)); static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp);
static int do_clear_sb_text = FALSE; /* clear text on next msg */ static int do_clear_sb_text = FALSE; /* clear text on next msg */
@ -2798,7 +2798,7 @@ do_dialog (
return retval; return retval;
} }
static int copy_char __ARGS((char_u *from, char_u *to, int lowercase)); static int copy_char(char_u *from, char_u *to, int lowercase);
/* /*
* Copy one character from "*from" to "*to", taking care of multi-byte * Copy one character from "*from" to "*to", taking care of multi-byte
@ -3023,9 +3023,9 @@ int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message, int dflt
#if defined(HAVE_STDARG_H) && defined(FEAT_EVAL) #if defined(HAVE_STDARG_H) && defined(FEAT_EVAL)
static char *e_printf = N_("E766: Insufficient arguments for printf()"); static char *e_printf = N_("E766: Insufficient arguments for printf()");
static long tv_nr __ARGS((typval_T *tvs, int *idxp)); static long tv_nr(typval_T *tvs, int *idxp);
static char *tv_str __ARGS((typval_T *tvs, int *idxp)); static char *tv_str(typval_T *tvs, int *idxp);
static double tv_float __ARGS((typval_T *tvs, int *idxp)); static double tv_float(typval_T *tvs, int *idxp);
/* /*
* Get number argument from "idxp" entry in "tvs". First entry is 1. * Get number argument from "idxp" entry in "tvs". First entry is 1.

154
src/message.h
View File

@ -1,83 +1,85 @@
#ifndef NEOVIM_MESSAGE_H #ifndef NEOVIM_MESSAGE_H
#define NEOVIM_MESSAGE_H #define NEOVIM_MESSAGE_H
/* message.c */ /* message.c */
int msg __ARGS((char_u *s)); int msg(char_u *s);
int verb_msg __ARGS((char_u *s)); int verb_msg(char_u *s);
int msg_attr __ARGS((char_u *s, int attr)); int msg_attr(char_u *s, int attr);
int msg_attr_keep __ARGS((char_u *s, int attr, int keep)); int msg_attr_keep(char_u *s, int attr, int keep);
char_u *msg_strtrunc __ARGS((char_u *s, int force)); char_u *msg_strtrunc(char_u *s, int force);
void trunc_string __ARGS((char_u *s, char_u *buf, int room, int buflen)); void trunc_string(char_u *s, char_u *buf, int room, int buflen);
void reset_last_sourcing __ARGS((void)); void reset_last_sourcing(void);
void msg_source __ARGS((int attr)); void msg_source(int attr);
int emsg_not_now __ARGS((void)); int emsg_not_now(void);
int emsg __ARGS((char_u *s)); int emsg(char_u *s);
int emsg2 __ARGS((char_u *s, char_u *a1)); int emsg2(char_u *s, char_u *a1);
void emsg_invreg __ARGS((int name)); void emsg_invreg(int name);
char_u *msg_trunc_attr __ARGS((char_u *s, int force, int attr)); char_u *msg_trunc_attr(char_u *s, int force, int attr);
char_u *msg_may_trunc __ARGS((int force, char_u *s)); char_u *msg_may_trunc(int force, char_u *s);
int delete_first_msg __ARGS((void)); int delete_first_msg(void);
void ex_messages __ARGS((exarg_T *eap)); void ex_messages(exarg_T *eap);
void msg_end_prompt __ARGS((void)); void msg_end_prompt(void);
void wait_return __ARGS((int redraw)); void wait_return(int redraw);
void set_keep_msg __ARGS((char_u *s, int attr)); void set_keep_msg(char_u *s, int attr);
void set_keep_msg_from_hist __ARGS((void)); void set_keep_msg_from_hist(void);
void msg_start __ARGS((void)); void msg_start(void);
void msg_starthere __ARGS((void)); void msg_starthere(void);
void msg_putchar __ARGS((int c)); void msg_putchar(int c);
void msg_putchar_attr __ARGS((int c, int attr)); void msg_putchar_attr(int c, int attr);
void msg_outnum __ARGS((long n)); void msg_outnum(long n);
void msg_home_replace __ARGS((char_u *fname)); void msg_home_replace(char_u *fname);
void msg_home_replace_hl __ARGS((char_u *fname)); void msg_home_replace_hl(char_u *fname);
int msg_outtrans __ARGS((char_u *str)); int msg_outtrans(char_u *str);
int msg_outtrans_attr __ARGS((char_u *str, int attr)); int msg_outtrans_attr(char_u *str, int attr);
int msg_outtrans_len __ARGS((char_u *str, int len)); int msg_outtrans_len(char_u *str, int len);
char_u *msg_outtrans_one __ARGS((char_u *p, int attr)); char_u *msg_outtrans_one(char_u *p, int attr);
int msg_outtrans_len_attr __ARGS((char_u *msgstr, int len, int attr)); int msg_outtrans_len_attr(char_u *msgstr, int len, int attr);
void msg_make __ARGS((char_u *arg)); void msg_make(char_u *arg);
int msg_outtrans_special __ARGS((char_u *strstart, int from)); int msg_outtrans_special(char_u *strstart, int from);
char_u *str2special_save __ARGS((char_u *str, int is_lhs)); char_u *str2special_save(char_u *str, int is_lhs);
char_u *str2special __ARGS((char_u **sp, int from)); char_u *str2special(char_u **sp, int from);
void str2specialbuf __ARGS((char_u *sp, char_u *buf, int len)); void str2specialbuf(char_u *sp, char_u *buf, int len);
void msg_prt_line __ARGS((char_u *s, int list)); void msg_prt_line(char_u *s, int list);
void msg_puts __ARGS((char_u *s)); void msg_puts(char_u *s);
void msg_puts_title __ARGS((char_u *s)); void msg_puts_title(char_u *s);
void msg_puts_long_attr __ARGS((char_u *longstr, int attr)); void msg_puts_long_attr(char_u *longstr, int attr);
void msg_puts_long_len_attr __ARGS((char_u *longstr, int len, int attr)); void msg_puts_long_len_attr(char_u *longstr, int len, int attr);
void msg_puts_attr __ARGS((char_u *s, int attr)); void msg_puts_attr(char_u *s, int attr);
void may_clear_sb_text __ARGS((void)); void may_clear_sb_text(void);
void clear_sb_text __ARGS((void)); void clear_sb_text(void);
void show_sb_text __ARGS((void)); void show_sb_text(void);
void msg_sb_eol __ARGS((void)); void msg_sb_eol(void);
int msg_use_printf __ARGS((void)); int msg_use_printf(void);
void mch_errmsg __ARGS((char *str)); #ifdef USE_MCH_ERRMSG
void mch_msg __ARGS((char *str)); void mch_errmsg(char *str);
void msg_moremsg __ARGS((int full)); void mch_msg(char *str);
void repeat_message __ARGS((void)); #endif
void msg_clr_eos __ARGS((void)); void msg_moremsg(int full);
void msg_clr_eos_force __ARGS((void)); void repeat_message(void);
void msg_clr_cmdline __ARGS((void)); void msg_clr_eos(void);
int msg_end __ARGS((void)); void msg_clr_eos_force(void);
void msg_check __ARGS((void)); void msg_clr_cmdline(void);
int redirecting __ARGS((void)); int msg_end(void);
void verbose_enter __ARGS((void)); void msg_check(void);
void verbose_leave __ARGS((void)); int redirecting(void);
void verbose_enter_scroll __ARGS((void)); void verbose_enter(void);
void verbose_leave_scroll __ARGS((void)); void verbose_leave(void);
void verbose_stop __ARGS((void)); void verbose_enter_scroll(void);
int verbose_open __ARGS((void)); void verbose_leave_scroll(void);
void give_warning __ARGS((char_u *message, int hl)); void verbose_stop(void);
void msg_advance __ARGS((int col)); int verbose_open(void);
int do_dialog __ARGS((int type, char_u *title, char_u *message, char_u *buttons, void give_warning(char_u *message, int hl);
void msg_advance(int col);
int do_dialog(int type, char_u *title, char_u *message, char_u *buttons,
int dfltbutton, char_u *textfield, int dfltbutton, char_u *textfield,
int ex_cmd)); int ex_cmd);
void display_confirm_msg __ARGS((void)); void display_confirm_msg(void);
int vim_dialog_yesno __ARGS((int type, char_u *title, char_u *message, int dflt)); int vim_dialog_yesno(int type, char_u *title, char_u *message, int dflt);
int vim_dialog_yesnocancel __ARGS((int type, char_u *title, char_u *message, int vim_dialog_yesnocancel(int type, char_u *title, char_u *message,
int dflt)); int dflt);
int vim_dialog_yesnoallcancel __ARGS((int type, char_u *title, char_u *message, int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message,
int dflt)); int dflt);
char_u *do_browse __ARGS((int flags, char_u *title, char_u *dflt, char_u *ext, char_u *do_browse(int flags, char_u *title, char_u *dflt, char_u *ext,
char_u *initdir, char_u *filter, char_u *initdir, char_u *filter,
buf_T *buf)); buf_T *buf);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MESSAGE_H */ #endif /* NEOVIM_MESSAGE_H */

120
src/misc1.c
View File

@ -49,10 +49,10 @@
#include <crt_externs.h> #include <crt_externs.h>
#endif #endif
static char_u *vim_version_dir __ARGS((char_u *vimdir)); static char_u *vim_version_dir(char_u *vimdir);
static char_u *remove_tail __ARGS((char_u *p, char_u *pend, char_u *name)); static char_u *remove_tail(char_u *p, char_u *pend, char_u *name);
static void init_users __ARGS((void)); static void init_users(void);
static int copy_indent __ARGS((int size, char_u *src)); static int copy_indent(int size, char_u *src);
/* All user names (for ~user completion as done by shell). */ /* All user names (for ~user completion as done by shell). */
static garray_T ga_users; static garray_T ga_users;
@ -451,7 +451,7 @@ int get_number_indent(linenr_T lnum)
} }
static int cin_is_cinword __ARGS((char_u *line)); static int cin_is_cinword(char_u *line);
/* /*
* Return TRUE if the string "line" starts with a word from 'cinwords'. * Return TRUE if the string "line" starts with a word from 'cinwords'.
@ -2342,11 +2342,11 @@ void changed_int(void) {
need_maketitle = TRUE; /* set window title later */ need_maketitle = TRUE; /* set window title later */
} }
static void changedOneline __ARGS((buf_T *buf, linenr_T lnum)); static void changedOneline(buf_T *buf, linenr_T lnum);
static void changed_lines_buf __ARGS((buf_T *buf, linenr_T lnum, linenr_T lnume, static void changed_lines_buf(buf_T *buf, linenr_T lnum, linenr_T lnume,
long xtra)); long xtra);
static void changed_common __ARGS((linenr_T lnum, colnr_T col, linenr_T lnume, static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume,
long xtra)); long xtra);
/* /*
* Changed bytes within a single line for the current buffer. * Changed bytes within a single line for the current buffer.
@ -3982,7 +3982,7 @@ char_u *gettail(char_u *fname)
return p1; return p1;
} }
static char_u *gettail_dir __ARGS((char_u *fname)); static char_u *gettail_dir(char_u *fname);
/* /*
* Return the end of the directory name, on the first path * Return the end of the directory name, on the first path
@ -4276,8 +4276,8 @@ FullName_save (
} }
static char_u *skip_string __ARGS((char_u *p)); static char_u *skip_string(char_u *p);
static pos_T *ind_find_start_comment __ARGS((void)); static pos_T *ind_find_start_comment(void);
/* /*
* Find the start of a comment, not knowing if we are in a comment right now. * Find the start of a comment, not knowing if we are in a comment right now.
@ -4381,41 +4381,41 @@ void do_c_expr_indent(void) {
* Below "XXX" means that this function may unlock the current line. * Below "XXX" means that this function may unlock the current line.
*/ */
static char_u *cin_skipcomment __ARGS((char_u *)); static char_u *cin_skipcomment(char_u *);
static int cin_nocode __ARGS((char_u *)); static int cin_nocode(char_u *);
static pos_T *find_line_comment __ARGS((void)); static pos_T *find_line_comment(void);
static int cin_islabel_skip __ARGS((char_u **)); static int cin_islabel_skip(char_u **);
static int cin_isdefault __ARGS((char_u *)); static int cin_isdefault(char_u *);
static char_u *after_label __ARGS((char_u *l)); static char_u *after_label(char_u *l);
static int get_indent_nolabel __ARGS((linenr_T lnum)); static int get_indent_nolabel(linenr_T lnum);
static int skip_label __ARGS((linenr_T, char_u **pp)); static int skip_label(linenr_T, char_u **pp);
static int cin_first_id_amount __ARGS((void)); static int cin_first_id_amount(void);
static int cin_get_equal_amount __ARGS((linenr_T lnum)); static int cin_get_equal_amount(linenr_T lnum);
static int cin_ispreproc __ARGS((char_u *)); static int cin_ispreproc(char_u *);
static int cin_ispreproc_cont __ARGS((char_u **pp, linenr_T *lnump)); static int cin_ispreproc_cont(char_u **pp, linenr_T *lnump);
static int cin_iscomment __ARGS((char_u *)); static int cin_iscomment(char_u *);
static int cin_islinecomment __ARGS((char_u *)); static int cin_islinecomment(char_u *);
static int cin_isterminated __ARGS((char_u *, int, int)); static int cin_isterminated(char_u *, int, int);
static int cin_isinit __ARGS((void)); static int cin_isinit(void);
static int cin_isfuncdecl __ARGS((char_u **, linenr_T, linenr_T)); static int cin_isfuncdecl(char_u **, linenr_T, linenr_T);
static int cin_isif __ARGS((char_u *)); static int cin_isif(char_u *);
static int cin_iselse __ARGS((char_u *)); static int cin_iselse(char_u *);
static int cin_isdo __ARGS((char_u *)); static int cin_isdo(char_u *);
static int cin_iswhileofdo __ARGS((char_u *, linenr_T)); static int cin_iswhileofdo(char_u *, linenr_T);
static int cin_is_if_for_while_before_offset __ARGS((char_u *line, int *poffset)); static int cin_is_if_for_while_before_offset(char_u *line, int *poffset);
static int cin_iswhileofdo_end __ARGS((int terminated)); static int cin_iswhileofdo_end(int terminated);
static int cin_isbreak __ARGS((char_u *)); static int cin_isbreak(char_u *);
static int cin_is_cpp_baseclass __ARGS((colnr_T *col)); static int cin_is_cpp_baseclass(colnr_T *col);
static int get_baseclass_amount __ARGS((int col)); static int get_baseclass_amount(int col);
static int cin_ends_in __ARGS((char_u *, char_u *, char_u *)); static int cin_ends_in(char_u *, char_u *, char_u *);
static int cin_starts_with __ARGS((char_u *s, char *word)); static int cin_starts_with(char_u *s, char *word);
static int cin_skip2pos __ARGS((pos_T *trypos)); static int cin_skip2pos(pos_T *trypos);
static pos_T *find_start_brace __ARGS((void)); static pos_T *find_start_brace(void);
static pos_T *find_match_paren __ARGS((int)); static pos_T *find_match_paren(int);
static int corr_ind_maxparen __ARGS((pos_T *startpos)); static int corr_ind_maxparen(pos_T *startpos);
static int find_last_paren __ARGS((char_u *l, int start, int end)); static int find_last_paren(char_u *l, int start, int end);
static int find_match __ARGS((int lookfor, linenr_T ourscope)); static int find_match(int lookfor, linenr_T ourscope);
static int cin_is_cpp_namespace __ARGS((char_u *)); static int cin_is_cpp_namespace(char_u *);
/* /*
* Skip over white space and C comments within the line. * Skip over white space and C comments within the line.
@ -7586,7 +7586,7 @@ int get_expr_indent(void) {
return indent; return indent;
} }
static int lisp_match __ARGS((char_u *p)); static int lisp_match(char_u *p);
static int lisp_match(char_u *p) static int lisp_match(char_u *p)
{ {
@ -8023,8 +8023,8 @@ int match_suffix(char_u *fname)
#if !defined(NO_EXPANDPATH) || defined(PROTO) #if !defined(NO_EXPANDPATH) || defined(PROTO)
static int vim_backtick __ARGS((char_u *p)); static int vim_backtick(char_u *p);
static int expand_backtick __ARGS((garray_T *gap, char_u *pat, int flags)); static int expand_backtick(garray_T *gap, char_u *pat, int flags);
#if (defined(UNIX) && !defined(VMS)) || defined(USE_UNIXFILENAME) \ #if (defined(UNIX) && !defined(VMS)) || defined(USE_UNIXFILENAME) \
@ -8033,7 +8033,7 @@ static int expand_backtick __ARGS((garray_T *gap, char_u *pat, int flags));
* Unix style wildcard expansion code. * Unix style wildcard expansion code.
* It's here because it's used both for Unix and Mac. * It's here because it's used both for Unix and Mac.
*/ */
static int pstrcmp __ARGS((const void *, const void *)); static int pstrcmp(const void *, const void *);
static int pstrcmp(const void *a, const void *b) static int pstrcmp(const void *a, const void *b)
{ {
@ -8237,12 +8237,12 @@ unix_expandpath (
} }
#endif #endif
static int find_previous_pathsep __ARGS((char_u *path, char_u **psep)); static int find_previous_pathsep(char_u *path, char_u **psep);
static int is_unique __ARGS((char_u *maybe_unique, garray_T *gap, int i)); static int is_unique(char_u *maybe_unique, garray_T *gap, int i);
static void expand_path_option __ARGS((char_u *curdir, garray_T *gap)); static void expand_path_option(char_u *curdir, garray_T *gap);
static char_u *get_path_cutoff __ARGS((char_u *fname, garray_T *gap)); static char_u *get_path_cutoff(char_u *fname, garray_T *gap);
static void uniquefy_paths __ARGS((garray_T *gap, char_u *pattern)); static void uniquefy_paths(garray_T *gap, char_u *pattern);
static int expand_in_path __ARGS((garray_T *gap, char_u *pattern, int flags)); static int expand_in_path(garray_T *gap, char_u *pattern, int flags);
/* /*
* Moves "*psep" back to the previous path separator in "path". * Moves "*psep" back to the previous path separator in "path".
@ -8629,7 +8629,7 @@ void remove_duplicates(garray_T *gap)
} }
} }
static int has_env_var __ARGS((char_u *p)); static int has_env_var(char_u *p);
/* /*
* Return TRUE if "p" contains what looks like an environment variable. * Return TRUE if "p" contains what looks like an environment variable.
@ -8649,7 +8649,7 @@ static int has_env_var(char_u *p)
} }
#ifdef SPECIAL_WILDCHAR #ifdef SPECIAL_WILDCHAR
static int has_special_wildchar __ARGS((char_u *p)); static int has_special_wildchar(char_u *p);
/* /*
* Return TRUE if "p" contains a special wildcard character. * Return TRUE if "p" contains a special wildcard character.

224
src/misc1.h
View File

@ -1,120 +1,120 @@
#ifndef NEOVIM_MISC1_H #ifndef NEOVIM_MISC1_H
#define NEOVIM_MISC1_H #define NEOVIM_MISC1_H
/* misc1.c */ /* misc1.c */
int get_indent __ARGS((void)); int get_indent(void);
int get_indent_lnum __ARGS((linenr_T lnum)); int get_indent_lnum(linenr_T lnum);
int get_indent_buf __ARGS((buf_T *buf, linenr_T lnum)); int get_indent_buf(buf_T *buf, linenr_T lnum);
int get_indent_str __ARGS((char_u *ptr, int ts)); int get_indent_str(char_u *ptr, int ts);
int set_indent __ARGS((int size, int flags)); int set_indent(int size, int flags);
int get_number_indent __ARGS((linenr_T lnum)); int get_number_indent(linenr_T lnum);
int open_line __ARGS((int dir, int flags, int second_line_indent)); int open_line(int dir, int flags, int second_line_indent);
int get_leader_len __ARGS((char_u *line, char_u **flags, int backward, int get_leader_len(char_u *line, char_u **flags, int backward,
int include_space)); int include_space);
int get_last_leader_offset __ARGS((char_u *line, char_u **flags)); int get_last_leader_offset(char_u *line, char_u **flags);
int plines __ARGS((linenr_T lnum)); int plines(linenr_T lnum);
int plines_win __ARGS((win_T *wp, linenr_T lnum, int winheight)); int plines_win(win_T *wp, linenr_T lnum, int winheight);
int plines_nofill __ARGS((linenr_T lnum)); int plines_nofill(linenr_T lnum);
int plines_win_nofill __ARGS((win_T *wp, linenr_T lnum, int winheight)); int plines_win_nofill(win_T *wp, linenr_T lnum, int winheight);
int plines_win_nofold __ARGS((win_T *wp, linenr_T lnum)); int plines_win_nofold(win_T *wp, linenr_T lnum);
int plines_win_col __ARGS((win_T *wp, linenr_T lnum, long column)); int plines_win_col(win_T *wp, linenr_T lnum, long column);
int plines_m_win __ARGS((win_T *wp, linenr_T first, linenr_T last)); int plines_m_win(win_T *wp, linenr_T first, linenr_T last);
void ins_bytes __ARGS((char_u *p)); void ins_bytes(char_u *p);
void ins_bytes_len __ARGS((char_u *p, int len)); void ins_bytes_len(char_u *p, int len);
void ins_char __ARGS((int c)); void ins_char(int c);
void ins_char_bytes __ARGS((char_u *buf, int charlen)); void ins_char_bytes(char_u *buf, int charlen);
void ins_str __ARGS((char_u *s)); void ins_str(char_u *s);
int del_char __ARGS((int fixpos)); int del_char(int fixpos);
int del_chars __ARGS((long count, int fixpos)); int del_chars(long count, int fixpos);
int del_bytes __ARGS((long count, int fixpos_arg, int use_delcombine)); int del_bytes(long count, int fixpos_arg, int use_delcombine);
int truncate_line __ARGS((int fixpos)); int truncate_line(int fixpos);
void del_lines __ARGS((long nlines, int undo)); void del_lines(long nlines, int undo);
int gchar_pos __ARGS((pos_T *pos)); int gchar_pos(pos_T *pos);
int gchar_cursor __ARGS((void)); int gchar_cursor(void);
void pchar_cursor __ARGS((int c)); void pchar_cursor(int c);
int inindent __ARGS((int extra)); int inindent(int extra);
char_u *skip_to_option_part __ARGS((char_u *p)); char_u *skip_to_option_part(char_u *p);
void changed __ARGS((void)); void changed(void);
void changed_int __ARGS((void)); void changed_int(void);
void changed_bytes __ARGS((linenr_T lnum, colnr_T col)); void changed_bytes(linenr_T lnum, colnr_T col);
void appended_lines __ARGS((linenr_T lnum, long count)); void appended_lines(linenr_T lnum, long count);
void appended_lines_mark __ARGS((linenr_T lnum, long count)); void appended_lines_mark(linenr_T lnum, long count);
void deleted_lines __ARGS((linenr_T lnum, long count)); void deleted_lines(linenr_T lnum, long count);
void deleted_lines_mark __ARGS((linenr_T lnum, long count)); void deleted_lines_mark(linenr_T lnum, long count);
void changed_lines __ARGS((linenr_T lnum, colnr_T col, linenr_T lnume, void changed_lines(linenr_T lnum, colnr_T col, linenr_T lnume,
long xtra)); long xtra);
void unchanged __ARGS((buf_T *buf, int ff)); void unchanged(buf_T *buf, int ff);
void check_status __ARGS((buf_T *buf)); void check_status(buf_T *buf);
void change_warning __ARGS((int col)); void change_warning(int col);
int ask_yesno __ARGS((char_u *str, int direct)); int ask_yesno(char_u *str, int direct);
int is_mouse_key __ARGS((int c)); int is_mouse_key(int c);
int get_keystroke __ARGS((void)); int get_keystroke(void);
int get_number __ARGS((int colon, int *mouse_used)); int get_number(int colon, int *mouse_used);
int prompt_for_number __ARGS((int *mouse_used)); int prompt_for_number(int *mouse_used);
void msgmore __ARGS((long n)); void msgmore(long n);
void beep_flush __ARGS((void)); void beep_flush(void);
void vim_beep __ARGS((void)); void vim_beep(void);
void init_homedir __ARGS((void)); void init_homedir(void);
void free_homedir __ARGS((void)); void free_homedir(void);
void free_users __ARGS((void)); void free_users(void);
char_u *expand_env_save __ARGS((char_u *src)); char_u *expand_env_save(char_u *src);
char_u *expand_env_save_opt __ARGS((char_u *src, int one)); char_u *expand_env_save_opt(char_u *src, int one);
void expand_env __ARGS((char_u *src, char_u *dst, int dstlen)); void expand_env(char_u *src, char_u *dst, int dstlen);
void expand_env_esc __ARGS((char_u *srcp, char_u *dst, int dstlen, int esc, void expand_env_esc(char_u *srcp, char_u *dst, int dstlen, int esc,
int one, int one,
char_u *startstr)); char_u *startstr);
char_u *vim_getenv __ARGS((char_u *name, int *mustfree)); char_u *vim_getenv(char_u *name, int *mustfree);
void vim_setenv __ARGS((char_u *name, char_u *val)); void vim_setenv(char_u *name, char_u *val);
char_u *get_env_name __ARGS((expand_T *xp, int idx)); char_u *get_env_name(expand_T *xp, int idx);
char_u *get_users __ARGS((expand_T *xp, int idx)); char_u *get_users(expand_T *xp, int idx);
int match_user __ARGS((char_u *name)); int match_user(char_u *name);
void home_replace __ARGS((buf_T *buf, char_u *src, char_u *dst, int dstlen, void home_replace(buf_T *buf, char_u *src, char_u *dst, int dstlen,
int one)); int one);
char_u *home_replace_save __ARGS((buf_T *buf, char_u *src)); char_u *home_replace_save(buf_T *buf, char_u *src);
int fullpathcmp __ARGS((char_u *s1, char_u *s2, int checkname)); int fullpathcmp(char_u *s1, char_u *s2, int checkname);
char_u *gettail __ARGS((char_u *fname)); char_u *gettail(char_u *fname);
char_u *gettail_sep __ARGS((char_u *fname)); char_u *gettail_sep(char_u *fname);
char_u *getnextcomp __ARGS((char_u *fname)); char_u *getnextcomp(char_u *fname);
char_u *get_past_head __ARGS((char_u *path)); char_u *get_past_head(char_u *path);
int vim_ispathsep __ARGS((int c)); int vim_ispathsep(int c);
int vim_ispathsep_nocolon __ARGS((int c)); int vim_ispathsep_nocolon(int c);
int vim_ispathlistsep __ARGS((int c)); int vim_ispathlistsep(int c);
void shorten_dir __ARGS((char_u *str)); void shorten_dir(char_u *str);
int dir_of_file_exists __ARGS((char_u *fname)); int dir_of_file_exists(char_u *fname);
int vim_fnamecmp __ARGS((char_u *x, char_u *y)); int vim_fnamecmp(char_u *x, char_u *y);
int vim_fnamencmp __ARGS((char_u *x, char_u *y, size_t len)); int vim_fnamencmp(char_u *x, char_u *y, size_t len);
char_u *concat_fnames __ARGS((char_u *fname1, char_u *fname2, int sep)); char_u *concat_fnames(char_u *fname1, char_u *fname2, int sep);
char_u *concat_str __ARGS((char_u *str1, char_u *str2)); char_u *concat_str(char_u *str1, char_u *str2);
void add_pathsep __ARGS((char_u *p)); void add_pathsep(char_u *p);
char_u *FullName_save __ARGS((char_u *fname, int force)); char_u *FullName_save(char_u *fname, int force);
pos_T *find_start_comment __ARGS((int ind_maxcomment)); pos_T *find_start_comment(int ind_maxcomment);
void do_c_expr_indent __ARGS((void)); void do_c_expr_indent(void);
int cin_islabel __ARGS((void)); int cin_islabel(void);
int cin_iscase __ARGS((char_u *s, int strict)); int cin_iscase(char_u *s, int strict);
int cin_isscopedecl __ARGS((char_u *s)); int cin_isscopedecl(char_u *s);
void parse_cino __ARGS((buf_T *buf)); void parse_cino(buf_T *buf);
int get_c_indent __ARGS((void)); int get_c_indent(void);
int get_expr_indent __ARGS((void)); int get_expr_indent(void);
int get_lisp_indent __ARGS((void)); int get_lisp_indent(void);
void prepare_to_exit __ARGS((void)); void prepare_to_exit(void);
void preserve_exit __ARGS((void)); void preserve_exit(void);
int vim_fexists __ARGS((char_u *fname)); int vim_fexists(char_u *fname);
void line_breakcheck __ARGS((void)); void line_breakcheck(void);
void fast_breakcheck __ARGS((void)); void fast_breakcheck(void);
int expand_wildcards_eval __ARGS((char_u **pat, int *num_file, char_u ***file, int expand_wildcards_eval(char_u **pat, int *num_file, char_u ***file,
int flags)); int flags);
int expand_wildcards __ARGS((int num_pat, char_u **pat, int *num_file, char_u * int expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u *
**file, **file,
int flags)); int flags);
int match_suffix __ARGS((char_u *fname)); int match_suffix(char_u *fname);
int unix_expandpath __ARGS((garray_T *gap, char_u *path, int wildoff, int flags, int unix_expandpath(garray_T *gap, char_u *path, int wildoff, int flags,
int didstar)); int didstar);
void remove_duplicates __ARGS((garray_T *gap)); void remove_duplicates(garray_T *gap);
int gen_expand_wildcards __ARGS((int num_pat, char_u **pat, int *num_file, int gen_expand_wildcards(int num_pat, char_u **pat, int *num_file,
char_u ***file, char_u ***file,
int flags)); int flags);
void addfile __ARGS((garray_T *gap, char_u *f, int flags)); void addfile(garray_T *gap, char_u *f, int flags);
char_u *get_cmd_output __ARGS((char_u *cmd, char_u *infile, int flags)); char_u *get_cmd_output(char_u *cmd, char_u *infile, int flags);
void FreeWild __ARGS((int count, char_u **files)); void FreeWild(int count, char_u **files);
int goto_im __ARGS((void)); int goto_im(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MISC1_H */ #endif /* NEOVIM_MISC1_H */

24
src/misc2.c
View File

@ -38,8 +38,8 @@
static char_u *username = NULL; /* cached result of mch_get_user_name() */ static char_u *username = NULL; /* cached result of mch_get_user_name() */
static int coladvance2 __ARGS((pos_T *pos, int addspaces, int finetune, static int coladvance2(pos_T *pos, int addspaces, int finetune,
colnr_T wcol)); colnr_T wcol);
/* /*
* Return TRUE if in the current mode we need to use virtual. * Return TRUE if in the current mode we need to use virtual.
@ -589,10 +589,10 @@ static long_u mem_peak;
static long_u num_alloc; static long_u num_alloc;
static long_u num_freed; static long_u num_freed;
static void mem_pre_alloc_s __ARGS((size_t *sizep)); static void mem_pre_alloc_s(size_t *sizep);
static void mem_pre_alloc_l __ARGS((long_u *sizep)); static void mem_pre_alloc_l(long_u *sizep);
static void mem_post_alloc __ARGS((void **pp, size_t size)); static void mem_post_alloc(void **pp, size_t size);
static void mem_pre_free __ARGS((void **pp)); static void mem_pre_free(void **pp);
static void mem_pre_alloc_s(size_t *sizep) static void mem_pre_alloc_s(size_t *sizep)
{ {
@ -2883,7 +2883,7 @@ int get_shape_idx(int mouse)
typedef unsigned short ush; /* unsigned 16-bit value */ typedef unsigned short ush; /* unsigned 16-bit value */
typedef unsigned long ulg; /* unsigned 32-bit value */ typedef unsigned long ulg; /* unsigned 32-bit value */
static void make_crc_tab __ARGS((void)); static void make_crc_tab(void);
static ulg crc_32_tab[256]; static ulg crc_32_tab[256];
@ -3183,7 +3183,7 @@ void qsort(base, elm_count, elm_size, cmp)
void *base; void *base;
size_t elm_count; size_t elm_count;
size_t elm_size; size_t elm_size;
int (*cmp)__ARGS((const void *, const void *)); int (*cmp)(const void *, const void *);
{ {
char_u *buf; char_u *buf;
char_u *p1; char_u *p1;
@ -3217,7 +3217,7 @@ int (*cmp)__ARGS((const void *, const void *));
* Sort an array of strings. * Sort an array of strings.
*/ */
static int static int
sort_compare __ARGS((const void *s1, const void *s2)); sort_compare(const void *s1, const void *s2);
static int sort_compare(const void *s1, const void *s2) static int sort_compare(const void *s1, const void *s2)
{ {
@ -3330,9 +3330,9 @@ static int envsize = -1; /* current size of environment */
extern extern
char **environ; /* the global which is your env. */ char **environ; /* the global which is your env. */
static int findenv __ARGS((char *name)); /* look for a name in the env. */ static int findenv(char *name); /* look for a name in the env. */
static int newenv __ARGS((void)); /* copy env. from stack to heap */ static int newenv(void); /* copy env. from stack to heap */
static int moreenv __ARGS((void)); /* incr. size of env. */ static int moreenv(void); /* incr. size of env. */
int putenv(const char *string) int putenv(const char *string)
{ {

208
src/misc2.h
View File

@ -1,110 +1,110 @@
#ifndef NEOVIM_MISC2_H #ifndef NEOVIM_MISC2_H
#define NEOVIM_MISC2_H #define NEOVIM_MISC2_H
/* misc2.c */ /* misc2.c */
int virtual_active __ARGS((void)); int virtual_active(void);
int getviscol __ARGS((void)); int getviscol(void);
int getviscol2 __ARGS((colnr_T col, colnr_T coladd)); int getviscol2(colnr_T col, colnr_T coladd);
int coladvance_force __ARGS((colnr_T wcol)); int coladvance_force(colnr_T wcol);
int coladvance __ARGS((colnr_T wcol)); int coladvance(colnr_T wcol);
int getvpos __ARGS((pos_T *pos, colnr_T wcol)); int getvpos(pos_T *pos, colnr_T wcol);
int inc_cursor __ARGS((void)); int inc_cursor(void);
int inc __ARGS((pos_T *lp)); int inc(pos_T *lp);
int incl __ARGS((pos_T *lp)); int incl(pos_T *lp);
int dec_cursor __ARGS((void)); int dec_cursor(void);
int dec __ARGS((pos_T *lp)); int dec(pos_T *lp);
int decl __ARGS((pos_T *lp)); int decl(pos_T *lp);
linenr_T get_cursor_rel_lnum __ARGS((win_T *wp, linenr_T lnum)); linenr_T get_cursor_rel_lnum(win_T *wp, linenr_T lnum);
void check_cursor_lnum __ARGS((void)); void check_cursor_lnum(void);
void check_cursor_col __ARGS((void)); void check_cursor_col(void);
void check_cursor_col_win __ARGS((win_T *win)); void check_cursor_col_win(win_T *win);
void check_cursor __ARGS((void)); void check_cursor(void);
void adjust_cursor_col __ARGS((void)); void adjust_cursor_col(void);
int leftcol_changed __ARGS((void)); int leftcol_changed(void);
void vim_mem_profile_dump __ARGS((void)); void vim_mem_profile_dump(void);
char_u *alloc __ARGS((unsigned size)); char_u *alloc(unsigned size);
char_u *alloc_clear __ARGS((unsigned size)); char_u *alloc_clear(unsigned size);
char_u *alloc_check __ARGS((unsigned size)); char_u *alloc_check(unsigned size);
char_u *lalloc_clear __ARGS((long_u size, int message)); char_u *lalloc_clear(long_u size, int message);
char_u *lalloc __ARGS((long_u size, int message)); char_u *lalloc(long_u size, int message);
void *mem_realloc __ARGS((void *ptr, size_t size)); void *mem_realloc(void *ptr, size_t size);
void do_outofmem_msg __ARGS((long_u size)); void do_outofmem_msg(long_u size);
void free_all_mem __ARGS((void)); void free_all_mem(void);
char_u *vim_strsave __ARGS((char_u *string)); char_u *vim_strsave(char_u *string);
char_u *vim_strnsave __ARGS((char_u *string, int len)); char_u *vim_strnsave(char_u *string, int len);
char_u *vim_strsave_escaped __ARGS((char_u *string, char_u *esc_chars)); char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars);
char_u *vim_strsave_escaped_ext __ARGS((char_u *string, char_u *esc_chars, char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars,
int cc, int cc,
int bsl)); int bsl);
int csh_like_shell __ARGS((void)); int csh_like_shell(void);
char_u *vim_strsave_shellescape __ARGS((char_u *string, int do_special)); char_u *vim_strsave_shellescape(char_u *string, int do_special);
char_u *vim_strsave_up __ARGS((char_u *string)); char_u *vim_strsave_up(char_u *string);
char_u *vim_strnsave_up __ARGS((char_u *string, int len)); char_u *vim_strnsave_up(char_u *string, int len);
void vim_strup __ARGS((char_u *p)); void vim_strup(char_u *p);
char_u *strup_save __ARGS((char_u *orig)); char_u *strup_save(char_u *orig);
void copy_spaces __ARGS((char_u *ptr, size_t count)); void copy_spaces(char_u *ptr, size_t count);
void copy_chars __ARGS((char_u *ptr, size_t count, int c)); void copy_chars(char_u *ptr, size_t count, int c);
void del_trailing_spaces __ARGS((char_u *ptr)); void del_trailing_spaces(char_u *ptr);
void vim_strncpy __ARGS((char_u *to, char_u *from, size_t len)); void vim_strncpy(char_u *to, char_u *from, size_t len);
void vim_strcat __ARGS((char_u *to, char_u *from, size_t tosize)); void vim_strcat(char_u *to, char_u *from, size_t tosize);
int copy_option_part __ARGS((char_u **option, char_u *buf, int maxlen, int copy_option_part(char_u **option, char_u *buf, int maxlen,
char *sep_chars)); char *sep_chars);
void vim_free __ARGS((void *x)); void vim_free(void *x);
int vim_stricmp __ARGS((char *s1, char *s2)); int vim_stricmp(char *s1, char *s2);
int vim_strnicmp __ARGS((char *s1, char *s2, size_t len)); int vim_strnicmp(char *s1, char *s2, size_t len);
char_u *vim_strchr __ARGS((char_u *string, int c)); char_u *vim_strchr(char_u *string, int c);
char_u *vim_strbyte __ARGS((char_u *string, int c)); char_u *vim_strbyte(char_u *string, int c);
char_u *vim_strrchr __ARGS((char_u *string, int c)); char_u *vim_strrchr(char_u *string, int c);
int vim_isspace __ARGS((int x)); int vim_isspace(int x);
int name_to_mod_mask __ARGS((int c)); int name_to_mod_mask(int c);
int simplify_key __ARGS((int key, int *modifiers)); int simplify_key(int key, int *modifiers);
int handle_x_keys __ARGS((int key)); int handle_x_keys(int key);
char_u *get_special_key_name __ARGS((int c, int modifiers)); char_u *get_special_key_name(int c, int modifiers);
int trans_special __ARGS((char_u **srcp, char_u *dst, int keycode)); int trans_special(char_u **srcp, char_u *dst, int keycode);
int find_special_key __ARGS((char_u **srcp, int *modp, int keycode, int find_special_key(char_u **srcp, int *modp, int keycode,
int keep_x_key)); int keep_x_key);
int extract_modifiers __ARGS((int key, int *modp)); int extract_modifiers(int key, int *modp);
int find_special_key_in_table __ARGS((int c)); int find_special_key_in_table(int c);
int get_special_key_code __ARGS((char_u *name)); int get_special_key_code(char_u *name);
char_u *get_key_name __ARGS((int i)); char_u *get_key_name(int i);
int get_mouse_button __ARGS((int code, int *is_click, int *is_drag)); int get_mouse_button(int code, int *is_click, int *is_drag);
int get_pseudo_mouse_code __ARGS((int button, int is_click, int is_drag)); int get_pseudo_mouse_code(int button, int is_click, int is_drag);
int get_fileformat __ARGS((buf_T *buf)); int get_fileformat(buf_T *buf);
int get_fileformat_force __ARGS((buf_T *buf, exarg_T *eap)); int get_fileformat_force(buf_T *buf, exarg_T *eap);
void set_fileformat __ARGS((int t, int opt_flags)); void set_fileformat(int t, int opt_flags);
int default_fileformat __ARGS((void)); int default_fileformat(void);
int call_shell __ARGS((char_u *cmd, int opt)); int call_shell(char_u *cmd, int opt);
int get_real_state __ARGS((void)); int get_real_state(void);
int after_pathsep __ARGS((char_u *b, char_u *p)); int after_pathsep(char_u *b, char_u *p);
int same_directory __ARGS((char_u *f1, char_u *f2)); int same_directory(char_u *f1, char_u *f2);
int vim_chdirfile __ARGS((char_u *fname)); int vim_chdirfile(char_u *fname);
int illegal_slash __ARGS((char *name)); int illegal_slash(char *name);
char_u *parse_shape_opt __ARGS((int what)); char_u *parse_shape_opt(int what);
int get_shape_idx __ARGS((int mouse)); int get_shape_idx(int mouse);
void update_mouseshape __ARGS((int shape_idx)); void update_mouseshape(int shape_idx);
int crypt_method_from_string __ARGS((char_u *s)); int crypt_method_from_string(char_u *s);
int get_crypt_method __ARGS((buf_T *buf)); int get_crypt_method(buf_T *buf);
void set_crypt_method __ARGS((buf_T *buf, int method)); void set_crypt_method(buf_T *buf, int method);
void crypt_push_state __ARGS((void)); void crypt_push_state(void);
void crypt_pop_state __ARGS((void)); void crypt_pop_state(void);
void crypt_encode __ARGS((char_u *from, size_t len, char_u *to)); void crypt_encode(char_u *from, size_t len, char_u *to);
void crypt_decode __ARGS((char_u *ptr, long len)); void crypt_decode(char_u *ptr, long len);
void crypt_init_keys __ARGS((char_u *passwd)); void crypt_init_keys(char_u *passwd);
void free_crypt_key __ARGS((char_u *key)); void free_crypt_key(char_u *key);
char_u *get_crypt_key __ARGS((int store, int twice)); char_u *get_crypt_key(int store, int twice);
int vim_chdir __ARGS((char_u *new_dir)); int vim_chdir(char_u *new_dir);
int get_user_name __ARGS((char_u *buf, int len)); int get_user_name(char_u *buf, int len);
void sort_strings __ARGS((char_u **files, int count)); void sort_strings(char_u **files, int count);
int pathcmp __ARGS((const char *p, const char *q, int maxlen)); int pathcmp(const char *p, const char *q, int maxlen);
int filewritable __ARGS((char_u *fname)); int filewritable(char_u *fname);
int emsg3 __ARGS((char_u *s, char_u *a1, char_u *a2)); int emsg3(char_u *s, char_u *a1, char_u *a2);
int emsgn __ARGS((char_u *s, long n)); int emsgn(char_u *s, long n);
int get2c __ARGS((FILE *fd)); int get2c(FILE *fd);
int get3c __ARGS((FILE *fd)); int get3c(FILE *fd);
int get4c __ARGS((FILE *fd)); int get4c(FILE *fd);
time_t get8ctime __ARGS((FILE *fd)); time_t get8ctime(FILE *fd);
char_u *read_string __ARGS((FILE *fd, int cnt)); char_u *read_string(FILE *fd, int cnt);
int put_bytes __ARGS((FILE *fd, long_u nr, int len)); int put_bytes(FILE *fd, long_u nr, int len);
void put_time __ARGS((FILE *fd, time_t the_time)); void put_time(FILE *fd, time_t the_time);
int has_non_ascii __ARGS((char_u *s)); int has_non_ascii(char_u *s);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MISC2_H */ #endif /* NEOVIM_MISC2_H */

24
src/move.c
View File

@ -30,12 +30,12 @@
#include "popupmnu.h" #include "popupmnu.h"
#include "screen.h" #include "screen.h"
static void comp_botline __ARGS((win_T *wp)); static void comp_botline(win_T *wp);
static int scrolljump_value __ARGS((void)); static int scrolljump_value(void);
static int check_top_offset __ARGS((void)); static int check_top_offset(void);
static void curs_rows __ARGS((win_T *wp, int do_botline)); static void curs_rows(win_T *wp, int do_botline);
static void validate_botline_win __ARGS((win_T *wp)); static void validate_botline_win(win_T *wp);
static void validate_cheight __ARGS((void)); static void validate_cheight(void);
typedef struct { typedef struct {
linenr_T lnum; /* line number */ linenr_T lnum; /* line number */
@ -43,11 +43,11 @@ typedef struct {
int height; /* height of added line */ int height; /* height of added line */
} lineoff_T; } lineoff_T;
static void topline_back __ARGS((lineoff_T *lp)); static void topline_back(lineoff_T *lp);
static void botline_forw __ARGS((lineoff_T *lp)); static void botline_forw(lineoff_T *lp);
static void botline_topline __ARGS((lineoff_T *lp)); static void botline_topline(lineoff_T *lp);
static void topline_botline __ARGS((lineoff_T *lp)); static void topline_botline(lineoff_T *lp);
static void max_topfill __ARGS((void)); static void max_topfill(void);
/* /*
* Compute wp->w_botline for the current wp->w_topline. Can be called after * Compute wp->w_botline for the current wp->w_topline. Can be called after
@ -1738,7 +1738,7 @@ void cursor_correct(void) {
curwin->w_valid |= VALID_TOPLINE; curwin->w_valid |= VALID_TOPLINE;
} }
static void get_scroll_overlap __ARGS((lineoff_T *lp, int dir)); static void get_scroll_overlap(lineoff_T *lp, int dir);
/* /*
* move screen 'count' pages up or down and update screen * move screen 'count' pages up or down and update screen

78
src/move.h
View File

@ -1,44 +1,44 @@
#ifndef NEOVIM_MOVE_H #ifndef NEOVIM_MOVE_H
#define NEOVIM_MOVE_H #define NEOVIM_MOVE_H
/* move.c */ /* move.c */
void update_topline_redraw __ARGS((void)); void update_topline_redraw(void);
void update_topline __ARGS((void)); void update_topline(void);
void update_curswant __ARGS((void)); void update_curswant(void);
void check_cursor_moved __ARGS((win_T *wp)); void check_cursor_moved(win_T *wp);
void changed_window_setting __ARGS((void)); void changed_window_setting(void);
void changed_window_setting_win __ARGS((win_T *wp)); void changed_window_setting_win(win_T *wp);
void set_topline __ARGS((win_T *wp, linenr_T lnum)); void set_topline(win_T *wp, linenr_T lnum);
void changed_cline_bef_curs __ARGS((void)); void changed_cline_bef_curs(void);
void changed_cline_bef_curs_win __ARGS((win_T *wp)); void changed_cline_bef_curs_win(win_T *wp);
void changed_line_abv_curs __ARGS((void)); void changed_line_abv_curs(void);
void changed_line_abv_curs_win __ARGS((win_T *wp)); void changed_line_abv_curs_win(win_T *wp);
void validate_botline __ARGS((void)); void validate_botline(void);
void invalidate_botline __ARGS((void)); void invalidate_botline(void);
void invalidate_botline_win __ARGS((win_T *wp)); void invalidate_botline_win(win_T *wp);
void approximate_botline_win __ARGS((win_T *wp)); void approximate_botline_win(win_T *wp);
int cursor_valid __ARGS((void)); int cursor_valid(void);
void validate_cursor __ARGS((void)); void validate_cursor(void);
void validate_cline_row __ARGS((void)); void validate_cline_row(void);
void validate_virtcol __ARGS((void)); void validate_virtcol(void);
void validate_virtcol_win __ARGS((win_T *wp)); void validate_virtcol_win(win_T *wp);
void validate_cursor_col __ARGS((void)); void validate_cursor_col(void);
int win_col_off __ARGS((win_T *wp)); int win_col_off(win_T *wp);
int curwin_col_off __ARGS((void)); int curwin_col_off(void);
int win_col_off2 __ARGS((win_T *wp)); int win_col_off2(win_T *wp);
int curwin_col_off2 __ARGS((void)); int curwin_col_off2(void);
void curs_columns __ARGS((int may_scroll)); void curs_columns(int may_scroll);
void scrolldown __ARGS((long line_count, int byfold)); void scrolldown(long line_count, int byfold);
void scrollup __ARGS((long line_count, int byfold)); void scrollup(long line_count, int byfold);
void check_topfill __ARGS((win_T *wp, int down)); void check_topfill(win_T *wp, int down);
void scrolldown_clamp __ARGS((void)); void scrolldown_clamp(void);
void scrollup_clamp __ARGS((void)); void scrollup_clamp(void);
void scroll_cursor_top __ARGS((int min_scroll, int always)); void scroll_cursor_top(int min_scroll, int always);
void set_empty_rows __ARGS((win_T *wp, int used)); void set_empty_rows(win_T *wp, int used);
void scroll_cursor_bot __ARGS((int min_scroll, int set_topbot)); void scroll_cursor_bot(int min_scroll, int set_topbot);
void scroll_cursor_halfway __ARGS((int atend)); void scroll_cursor_halfway(int atend);
void cursor_correct __ARGS((void)); void cursor_correct(void);
int onepage __ARGS((int dir, long count)); int onepage(int dir, long count);
void halfpage __ARGS((int flag, linenr_T Prenum)); void halfpage(int flag, linenr_T Prenum);
void do_check_cursorbind __ARGS((void)); void do_check_cursorbind(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_MOVE_H */ #endif /* NEOVIM_MOVE_H */

214
src/normal.c
View File

@ -57,118 +57,118 @@ static int VIsual_mode_orig = NUL; /* type of Visual mode, that use
static int restart_VIsual_select = 0; static int restart_VIsual_select = 0;
static void set_vcount_ca __ARGS((cmdarg_T *cap, int *set_prevcount)); static void set_vcount_ca(cmdarg_T *cap, int *set_prevcount);
static int static int
nv_compare __ARGS((const void *s1, const void *s2)); nv_compare(const void *s1, const void *s2);
static int find_command __ARGS((int cmdchar)); static int find_command(int cmdchar);
static void op_colon __ARGS((oparg_T *oap)); static void op_colon(oparg_T *oap);
static void op_function __ARGS((oparg_T *oap)); static void op_function(oparg_T *oap);
static void find_start_of_word __ARGS((pos_T *)); static void find_start_of_word(pos_T *);
static void find_end_of_word __ARGS((pos_T *)); static void find_end_of_word(pos_T *);
static int get_mouse_class __ARGS((char_u *p)); static int get_mouse_class(char_u *p);
static void prep_redo_cmd __ARGS((cmdarg_T *cap)); static void prep_redo_cmd(cmdarg_T *cap);
static void prep_redo __ARGS((int regname, long, int, int, int, int, int)); static void prep_redo(int regname, long, int, int, int, int, int);
static int checkclearop __ARGS((oparg_T *oap)); static int checkclearop(oparg_T *oap);
static int checkclearopq __ARGS((oparg_T *oap)); static int checkclearopq(oparg_T *oap);
static void clearop __ARGS((oparg_T *oap)); static void clearop(oparg_T *oap);
static void clearopbeep __ARGS((oparg_T *oap)); static void clearopbeep(oparg_T *oap);
static void unshift_special __ARGS((cmdarg_T *cap)); static void unshift_special(cmdarg_T *cap);
static void del_from_showcmd __ARGS((int)); static void del_from_showcmd(int);
/* /*
* nv_*(): functions called to handle Normal and Visual mode commands. * nv_*(): functions called to handle Normal and Visual mode commands.
* n_*(): functions called to handle Normal mode commands. * n_*(): functions called to handle Normal mode commands.
* v_*(): functions called to handle Visual mode commands. * v_*(): functions called to handle Visual mode commands.
*/ */
static void nv_ignore __ARGS((cmdarg_T *cap)); static void nv_ignore(cmdarg_T *cap);
static void nv_nop __ARGS((cmdarg_T *cap)); static void nv_nop(cmdarg_T *cap);
static void nv_error __ARGS((cmdarg_T *cap)); static void nv_error(cmdarg_T *cap);
static void nv_help __ARGS((cmdarg_T *cap)); static void nv_help(cmdarg_T *cap);
static void nv_addsub __ARGS((cmdarg_T *cap)); static void nv_addsub(cmdarg_T *cap);
static void nv_page __ARGS((cmdarg_T *cap)); static void nv_page(cmdarg_T *cap);
static void nv_gd __ARGS((oparg_T *oap, int nchar, int thisblock)); static void nv_gd(oparg_T *oap, int nchar, int thisblock);
static int nv_screengo __ARGS((oparg_T *oap, int dir, long dist)); static int nv_screengo(oparg_T *oap, int dir, long dist);
static void nv_mousescroll __ARGS((cmdarg_T *cap)); static void nv_mousescroll(cmdarg_T *cap);
static void nv_mouse __ARGS((cmdarg_T *cap)); static void nv_mouse(cmdarg_T *cap);
static void nv_scroll_line __ARGS((cmdarg_T *cap)); static void nv_scroll_line(cmdarg_T *cap);
static void nv_zet __ARGS((cmdarg_T *cap)); static void nv_zet(cmdarg_T *cap);
static void nv_exmode __ARGS((cmdarg_T *cap)); static void nv_exmode(cmdarg_T *cap);
static void nv_colon __ARGS((cmdarg_T *cap)); static void nv_colon(cmdarg_T *cap);
static void nv_ctrlg __ARGS((cmdarg_T *cap)); static void nv_ctrlg(cmdarg_T *cap);
static void nv_ctrlh __ARGS((cmdarg_T *cap)); static void nv_ctrlh(cmdarg_T *cap);
static void nv_clear __ARGS((cmdarg_T *cap)); static void nv_clear(cmdarg_T *cap);
static void nv_ctrlo __ARGS((cmdarg_T *cap)); static void nv_ctrlo(cmdarg_T *cap);
static void nv_hat __ARGS((cmdarg_T *cap)); static void nv_hat(cmdarg_T *cap);
static void nv_Zet __ARGS((cmdarg_T *cap)); static void nv_Zet(cmdarg_T *cap);
static void nv_ident __ARGS((cmdarg_T *cap)); static void nv_ident(cmdarg_T *cap);
static void nv_tagpop __ARGS((cmdarg_T *cap)); static void nv_tagpop(cmdarg_T *cap);
static void nv_scroll __ARGS((cmdarg_T *cap)); static void nv_scroll(cmdarg_T *cap);
static void nv_right __ARGS((cmdarg_T *cap)); static void nv_right(cmdarg_T *cap);
static void nv_left __ARGS((cmdarg_T *cap)); static void nv_left(cmdarg_T *cap);
static void nv_up __ARGS((cmdarg_T *cap)); static void nv_up(cmdarg_T *cap);
static void nv_down __ARGS((cmdarg_T *cap)); static void nv_down(cmdarg_T *cap);
static void nv_gotofile __ARGS((cmdarg_T *cap)); static void nv_gotofile(cmdarg_T *cap);
static void nv_end __ARGS((cmdarg_T *cap)); static void nv_end(cmdarg_T *cap);
static void nv_dollar __ARGS((cmdarg_T *cap)); static void nv_dollar(cmdarg_T *cap);
static void nv_search __ARGS((cmdarg_T *cap)); static void nv_search(cmdarg_T *cap);
static void nv_next __ARGS((cmdarg_T *cap)); static void nv_next(cmdarg_T *cap);
static void normal_search __ARGS((cmdarg_T *cap, int dir, char_u *pat, int opt)); static void normal_search(cmdarg_T *cap, int dir, char_u *pat, int opt);
static void nv_csearch __ARGS((cmdarg_T *cap)); static void nv_csearch(cmdarg_T *cap);
static void nv_brackets __ARGS((cmdarg_T *cap)); static void nv_brackets(cmdarg_T *cap);
static void nv_percent __ARGS((cmdarg_T *cap)); static void nv_percent(cmdarg_T *cap);
static void nv_brace __ARGS((cmdarg_T *cap)); static void nv_brace(cmdarg_T *cap);
static void nv_mark __ARGS((cmdarg_T *cap)); static void nv_mark(cmdarg_T *cap);
static void nv_findpar __ARGS((cmdarg_T *cap)); static void nv_findpar(cmdarg_T *cap);
static void nv_undo __ARGS((cmdarg_T *cap)); static void nv_undo(cmdarg_T *cap);
static void nv_kundo __ARGS((cmdarg_T *cap)); static void nv_kundo(cmdarg_T *cap);
static void nv_Replace __ARGS((cmdarg_T *cap)); static void nv_Replace(cmdarg_T *cap);
static void nv_vreplace __ARGS((cmdarg_T *cap)); static void nv_vreplace(cmdarg_T *cap);
static void v_swap_corners __ARGS((int cmdchar)); static void v_swap_corners(int cmdchar);
static void nv_replace __ARGS((cmdarg_T *cap)); static void nv_replace(cmdarg_T *cap);
static void n_swapchar __ARGS((cmdarg_T *cap)); static void n_swapchar(cmdarg_T *cap);
static void nv_cursormark __ARGS((cmdarg_T *cap, int flag, pos_T *pos)); static void nv_cursormark(cmdarg_T *cap, int flag, pos_T *pos);
static void v_visop __ARGS((cmdarg_T *cap)); static void v_visop(cmdarg_T *cap);
static void nv_subst __ARGS((cmdarg_T *cap)); static void nv_subst(cmdarg_T *cap);
static void nv_abbrev __ARGS((cmdarg_T *cap)); static void nv_abbrev(cmdarg_T *cap);
static void nv_optrans __ARGS((cmdarg_T *cap)); static void nv_optrans(cmdarg_T *cap);
static void nv_gomark __ARGS((cmdarg_T *cap)); static void nv_gomark(cmdarg_T *cap);
static void nv_pcmark __ARGS((cmdarg_T *cap)); static void nv_pcmark(cmdarg_T *cap);
static void nv_regname __ARGS((cmdarg_T *cap)); static void nv_regname(cmdarg_T *cap);
static void nv_visual __ARGS((cmdarg_T *cap)); static void nv_visual(cmdarg_T *cap);
static void n_start_visual_mode __ARGS((int c)); static void n_start_visual_mode(int c);
static void nv_window __ARGS((cmdarg_T *cap)); static void nv_window(cmdarg_T *cap);
static void nv_suspend __ARGS((cmdarg_T *cap)); static void nv_suspend(cmdarg_T *cap);
static void nv_g_cmd __ARGS((cmdarg_T *cap)); static void nv_g_cmd(cmdarg_T *cap);
static void n_opencmd __ARGS((cmdarg_T *cap)); static void n_opencmd(cmdarg_T *cap);
static void nv_dot __ARGS((cmdarg_T *cap)); static void nv_dot(cmdarg_T *cap);
static void nv_redo __ARGS((cmdarg_T *cap)); static void nv_redo(cmdarg_T *cap);
static void nv_Undo __ARGS((cmdarg_T *cap)); static void nv_Undo(cmdarg_T *cap);
static void nv_tilde __ARGS((cmdarg_T *cap)); static void nv_tilde(cmdarg_T *cap);
static void nv_operator __ARGS((cmdarg_T *cap)); static void nv_operator(cmdarg_T *cap);
static void set_op_var __ARGS((int optype)); static void set_op_var(int optype);
static void nv_lineop __ARGS((cmdarg_T *cap)); static void nv_lineop(cmdarg_T *cap);
static void nv_home __ARGS((cmdarg_T *cap)); static void nv_home(cmdarg_T *cap);
static void nv_pipe __ARGS((cmdarg_T *cap)); static void nv_pipe(cmdarg_T *cap);
static void nv_bck_word __ARGS((cmdarg_T *cap)); static void nv_bck_word(cmdarg_T *cap);
static void nv_wordcmd __ARGS((cmdarg_T *cap)); static void nv_wordcmd(cmdarg_T *cap);
static void nv_beginline __ARGS((cmdarg_T *cap)); static void nv_beginline(cmdarg_T *cap);
static void adjust_cursor __ARGS((oparg_T *oap)); static void adjust_cursor(oparg_T *oap);
static void adjust_for_sel __ARGS((cmdarg_T *cap)); static void adjust_for_sel(cmdarg_T *cap);
static int unadjust_for_sel __ARGS((void)); static int unadjust_for_sel(void);
static void nv_select __ARGS((cmdarg_T *cap)); static void nv_select(cmdarg_T *cap);
static void nv_goto __ARGS((cmdarg_T *cap)); static void nv_goto(cmdarg_T *cap);
static void nv_normal __ARGS((cmdarg_T *cap)); static void nv_normal(cmdarg_T *cap);
static void nv_esc __ARGS((cmdarg_T *oap)); static void nv_esc(cmdarg_T *oap);
static void nv_edit __ARGS((cmdarg_T *cap)); static void nv_edit(cmdarg_T *cap);
static void invoke_edit __ARGS((cmdarg_T *cap, int repl, int cmd, int startln)); static void invoke_edit(cmdarg_T *cap, int repl, int cmd, int startln);
static void nv_object __ARGS((cmdarg_T *cap)); static void nv_object(cmdarg_T *cap);
static void nv_record __ARGS((cmdarg_T *cap)); static void nv_record(cmdarg_T *cap);
static void nv_at __ARGS((cmdarg_T *cap)); static void nv_at(cmdarg_T *cap);
static void nv_halfpage __ARGS((cmdarg_T *cap)); static void nv_halfpage(cmdarg_T *cap);
static void nv_join __ARGS((cmdarg_T *cap)); static void nv_join(cmdarg_T *cap);
static void nv_put __ARGS((cmdarg_T *cap)); static void nv_put(cmdarg_T *cap);
static void nv_open __ARGS((cmdarg_T *cap)); static void nv_open(cmdarg_T *cap);
static void nv_cursorhold __ARGS((cmdarg_T *cap)); static void nv_cursorhold(cmdarg_T *cap);
static char *e_noident = N_("E349: No identifier under cursor"); static char *e_noident = N_("E349: No identifier under cursor");
@ -176,7 +176,7 @@ static char *e_noident = N_("E349: No identifier under cursor");
* Function to be called for a Normal or Visual mode command. * Function to be called for a Normal or Visual mode command.
* The argument is a cmdarg_T. * The argument is a cmdarg_T.
*/ */
typedef void (*nv_func_T) __ARGS ((cmdarg_T *cap)); typedef void (*nv_func_T)(cmdarg_T *cap);
/* Values for cmd_flags. */ /* Values for cmd_flags. */
#define NV_NCH 0x01 /* may need to get a second char */ #define NV_NCH 0x01 /* may need to get a second char */
@ -2987,7 +2987,7 @@ static char_u old_showcmd_buf[SHOWCMD_BUFLEN]; /* For push_showcmd() */
static int showcmd_is_clear = TRUE; static int showcmd_is_clear = TRUE;
static int showcmd_visual = FALSE; static int showcmd_visual = FALSE;
static void display_showcmd __ARGS((void)); static void display_showcmd(void);
void clear_showcmd(void) { void clear_showcmd(void) {
if (!p_sc) if (!p_sc)

52
src/normal.h
View File

@ -1,32 +1,32 @@
#ifndef NEOVIM_NORMAL_H #ifndef NEOVIM_NORMAL_H
#define NEOVIM_NORMAL_H #define NEOVIM_NORMAL_H
/* normal.c */ /* normal.c */
void init_normal_cmds __ARGS((void)); void init_normal_cmds(void);
void normal_cmd __ARGS((oparg_T *oap, int toplevel)); void normal_cmd(oparg_T *oap, int toplevel);
void do_pending_operator __ARGS((cmdarg_T *cap, int old_col, int gui_yank)); void do_pending_operator(cmdarg_T *cap, int old_col, int gui_yank);
int do_mouse __ARGS((oparg_T *oap, int c, int dir, long count, int fixindent)); int do_mouse(oparg_T *oap, int c, int dir, long count, int fixindent);
void check_visual_highlight __ARGS((void)); void check_visual_highlight(void);
void end_visual_mode __ARGS((void)); void end_visual_mode(void);
void reset_VIsual_and_resel __ARGS((void)); void reset_VIsual_and_resel(void);
void reset_VIsual __ARGS((void)); void reset_VIsual(void);
int find_ident_under_cursor __ARGS((char_u **string, int find_type)); int find_ident_under_cursor(char_u **string, int find_type);
int find_ident_at_pos __ARGS((win_T *wp, linenr_T lnum, colnr_T startcol, int find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol,
char_u **string, char_u **string,
int find_type)); int find_type);
void clear_showcmd __ARGS((void)); void clear_showcmd(void);
int add_to_showcmd __ARGS((int c)); int add_to_showcmd(int c);
void add_to_showcmd_c __ARGS((int c)); void add_to_showcmd_c(int c);
void push_showcmd __ARGS((void)); void push_showcmd(void);
void pop_showcmd __ARGS((void)); void pop_showcmd(void);
void do_check_scrollbind __ARGS((int check)); void do_check_scrollbind(int check);
void check_scrollbind __ARGS((linenr_T topline_diff, long leftcol_diff)); void check_scrollbind(linenr_T topline_diff, long leftcol_diff);
int find_decl __ARGS((char_u *ptr, int len, int locally, int thisblock, int find_decl(char_u *ptr, int len, int locally, int thisblock,
int searchflags)); int searchflags);
void scroll_redraw __ARGS((int up, long count)); void scroll_redraw(int up, long count);
void handle_tabmenu __ARGS((void)); void handle_tabmenu(void);
void do_nv_ident __ARGS((int c1, int c2)); void do_nv_ident(int c1, int c2);
int get_visual_text __ARGS((cmdarg_T *cap, char_u **pp, int *lenp)); int get_visual_text(cmdarg_T *cap, char_u **pp, int *lenp);
void start_selection __ARGS((void)); void start_selection(void);
void may_start_select __ARGS((int c)); void may_start_select(int c);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_NORMAL_H */ #endif /* NEOVIM_NORMAL_H */

52
src/ops.c
View File

@ -90,29 +90,29 @@ struct block_def {
colnr_T start_char_vcols; /* number of vcols of pre-block char */ colnr_T start_char_vcols; /* number of vcols of pre-block char */
}; };
static void shift_block __ARGS((oparg_T *oap, int amount)); static void shift_block(oparg_T *oap, int amount);
static void block_insert __ARGS((oparg_T *oap, char_u *s, int b_insert, static void block_insert(oparg_T *oap, char_u *s, int b_insert,
struct block_def*bdp)); struct block_def*bdp);
static int stuff_yank __ARGS((int, char_u *)); static int stuff_yank(int, char_u *);
static void put_reedit_in_typebuf __ARGS((int silent)); static void put_reedit_in_typebuf(int silent);
static int put_in_typebuf __ARGS((char_u *s, int esc, int colon, static int put_in_typebuf(char_u *s, int esc, int colon,
int silent)); int silent);
static void stuffescaped __ARGS((char_u *arg, int literally)); static void stuffescaped(char_u *arg, int literally);
static void mb_adjust_opend __ARGS((oparg_T *oap)); static void mb_adjust_opend(oparg_T *oap);
static void free_yank __ARGS((long)); static void free_yank(long);
static void free_yank_all __ARGS((void)); static void free_yank_all(void);
static int yank_copy_line __ARGS((struct block_def *bd, long y_idx)); static int yank_copy_line(struct block_def *bd, long y_idx);
static void dis_msg __ARGS((char_u *p, int skip_esc)); static void dis_msg(char_u *p, int skip_esc);
static char_u *skip_comment __ARGS((char_u *line, int process, static char_u *skip_comment(char_u *line, int process,
int include_space, int include_space,
int *is_comment)); int *is_comment);
static void block_prep __ARGS((oparg_T *oap, struct block_def *, linenr_T, int)); static void block_prep(oparg_T *oap, struct block_def *, linenr_T, int);
static void str_to_reg __ARGS((struct yankreg *y_ptr, int type, char_u *str, static void str_to_reg(struct yankreg *y_ptr, int type, char_u *str,
long len, long len,
long blocklen)); long blocklen);
static int ends_in_white __ARGS((linenr_T lnum)); static int ends_in_white(linenr_T lnum);
static int same_leader __ARGS((linenr_T lnum, int, char_u *, int, char_u *)); static int same_leader(linenr_T lnum, int, char_u *, int, char_u *);
static int fmt_check_par __ARGS((linenr_T, int *, char_u **, int do_comments)); static int fmt_check_par(linenr_T, int *, char_u **, int do_comments);
/* /*
* The names of operators. * The names of operators.
@ -574,7 +574,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
*/ */
void op_reindent(oap, how) void op_reindent(oap, how)
oparg_T *oap; oparg_T *oap;
int (*how)__ARGS((void)); int (*how)(void);
{ {
long i; long i;
char_u *l; char_u *l;
@ -1890,7 +1890,7 @@ int op_replace(oparg_T *oap, int c)
return OK; return OK;
} }
static int swapchars __ARGS((int op_type, pos_T *pos, int length)); static int swapchars(int op_type, pos_T *pos, int length);
/* /*
* Handle the (non-standard vi) tilde operator. Also for "gu", "gU" and "g?". * Handle the (non-standard vi) tilde operator. Also for "gu", "gU" and "g?".
@ -4257,7 +4257,7 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, int i
bdp->textstart = pstart; bdp->textstart = pstart;
} }
static void reverse_line __ARGS((char_u *s)); static void reverse_line(char_u *s);
static void reverse_line(char_u *s) static void reverse_line(char_u *s)
{ {
@ -4979,9 +4979,9 @@ void clear_oparg(oparg_T *oap)
vim_memset(oap, 0, sizeof(oparg_T)); vim_memset(oap, 0, sizeof(oparg_T));
} }
static long line_count_info __ARGS((char_u *line, long *wc, long *cc, static long line_count_info(char_u *line, long *wc, long *cc,
long limit, long limit,
int eol_size)); int eol_size);
/* /*
* Count the number of bytes, characters and "words" in a line. * Count the number of bytes, characters and "words" in a line.

126
src/ops.h
View File

@ -1,69 +1,69 @@
#ifndef NEOVIM_OPS_H #ifndef NEOVIM_OPS_H
#define NEOVIM_OPS_H #define NEOVIM_OPS_H
/* ops.c */ /* ops.c */
int get_op_type __ARGS((int char1, int char2)); int get_op_type(int char1, int char2);
int op_on_lines __ARGS((int op)); int op_on_lines(int op);
int get_op_char __ARGS((int optype)); int get_op_char(int optype);
int get_extra_op_char __ARGS((int optype)); int get_extra_op_char(int optype);
void op_shift __ARGS((oparg_T *oap, int curs_top, int amount)); void op_shift(oparg_T *oap, int curs_top, int amount);
void shift_line __ARGS((int left, int round, int amount, int call_changed_bytes)); void shift_line(int left, int round, int amount, int call_changed_bytes);
void op_reindent __ARGS((oparg_T *oap, int (*how)(void))); void op_reindent(oparg_T *oap, int (*how)(void));
int get_expr_register __ARGS((void)); int get_expr_register(void);
void set_expr_line __ARGS((char_u *new_line)); void set_expr_line(char_u *new_line);
char_u *get_expr_line __ARGS((void)); char_u *get_expr_line(void);
char_u *get_expr_line_src __ARGS((void)); char_u *get_expr_line_src(void);
int valid_yank_reg __ARGS((int regname, int writing)); int valid_yank_reg(int regname, int writing);
void get_yank_register __ARGS((int regname, int writing)); void get_yank_register(int regname, int writing);
int may_get_selection __ARGS((int regname)); int may_get_selection(int regname);
void *get_register __ARGS((int name, int copy)); void *get_register(int name, int copy);
void put_register __ARGS((int name, void *reg)); void put_register(int name, void *reg);
void free_register __ARGS((void *reg)); void free_register(void *reg);
int yank_register_mline __ARGS((int regname)); int yank_register_mline(int regname);
int do_record __ARGS((int c)); int do_record(int c);
int do_execreg __ARGS((int regname, int colon, int addcr, int silent)); int do_execreg(int regname, int colon, int addcr, int silent);
int insert_reg __ARGS((int regname, int literally)); int insert_reg(int regname, int literally);
int get_spec_reg __ARGS((int regname, char_u **argp, int *allocated, int errmsg)); int get_spec_reg(int regname, char_u **argp, int *allocated, int errmsg);
int cmdline_paste_reg __ARGS((int regname, int literally, int remcr)); int cmdline_paste_reg(int regname, int literally, int remcr);
void adjust_clip_reg __ARGS((int *rp)); void adjust_clip_reg(int *rp);
int op_delete __ARGS((oparg_T *oap)); int op_delete(oparg_T *oap);
int op_replace __ARGS((oparg_T *oap, int c)); int op_replace(oparg_T *oap, int c);
void op_tilde __ARGS((oparg_T *oap)); void op_tilde(oparg_T *oap);
int swapchar __ARGS((int op_type, pos_T *pos)); int swapchar(int op_type, pos_T *pos);
void op_insert __ARGS((oparg_T *oap, long count1)); void op_insert(oparg_T *oap, long count1);
int op_change __ARGS((oparg_T *oap)); int op_change(oparg_T *oap);
void init_yank __ARGS((void)); void init_yank(void);
void clear_registers __ARGS((void)); void clear_registers(void);
int op_yank __ARGS((oparg_T *oap, int deleting, int mess)); int op_yank(oparg_T *oap, int deleting, int mess);
void do_put __ARGS((int regname, int dir, long count, int flags)); void do_put(int regname, int dir, long count, int flags);
void adjust_cursor_eol __ARGS((void)); void adjust_cursor_eol(void);
int preprocs_left __ARGS((void)); int preprocs_left(void);
int get_register_name __ARGS((int num)); int get_register_name(int num);
void ex_display __ARGS((exarg_T *eap)); void ex_display(exarg_T *eap);
int do_join __ARGS((long count, int insert_space, int save_undo, int do_join(long count, int insert_space, int save_undo,
int use_formatoptions)); int use_formatoptions);
void op_format __ARGS((oparg_T *oap, int keep_cursor)); void op_format(oparg_T *oap, int keep_cursor);
void op_formatexpr __ARGS((oparg_T *oap)); void op_formatexpr(oparg_T *oap);
int fex_format __ARGS((linenr_T lnum, long count, int c)); int fex_format(linenr_T lnum, long count, int c);
void format_lines __ARGS((linenr_T line_count, int avoid_fex)); void format_lines(linenr_T line_count, int avoid_fex);
int paragraph_start __ARGS((linenr_T lnum)); int paragraph_start(linenr_T lnum);
int do_addsub __ARGS((int command, linenr_T Prenum1)); int do_addsub(int command, linenr_T Prenum1);
int read_viminfo_register __ARGS((vir_T *virp, int force)); int read_viminfo_register(vir_T *virp, int force);
void write_viminfo_registers __ARGS((FILE *fp)); void write_viminfo_registers(FILE *fp);
void x11_export_final_selection __ARGS((void)); void x11_export_final_selection(void);
void clip_free_selection __ARGS((VimClipboard *cbd)); void clip_free_selection(VimClipboard *cbd);
void clip_get_selection __ARGS((VimClipboard *cbd)); void clip_get_selection(VimClipboard *cbd);
void clip_yank_selection __ARGS((int type, char_u *str, long len, void clip_yank_selection(int type, char_u *str, long len,
VimClipboard *cbd)); VimClipboard *cbd);
int clip_convert_selection __ARGS((char_u **str, long_u *len, VimClipboard *cbd)); int clip_convert_selection(char_u **str, long_u *len, VimClipboard *cbd);
void dnd_yank_drag_data __ARGS((char_u *str, long len)); void dnd_yank_drag_data(char_u *str, long len);
char_u get_reg_type __ARGS((int regname, long *reglen)); char_u get_reg_type(int regname, long *reglen);
char_u *get_reg_contents __ARGS((int regname, int allowexpr, int expr_src)); char_u *get_reg_contents(int regname, int allowexpr, int expr_src);
void write_reg_contents __ARGS((int name, char_u *str, int maxlen, void write_reg_contents(int name, char_u *str, int maxlen,
int must_append)); int must_append);
void write_reg_contents_ex __ARGS((int name, char_u *str, int maxlen, void write_reg_contents_ex(int name, char_u *str, int maxlen,
int must_append, int yank_type, int must_append, int yank_type,
long block_len)); long block_len);
void clear_oparg __ARGS((oparg_T *oap)); void clear_oparg(oparg_T *oap);
void cursor_pos_info __ARGS((void)); void cursor_pos_info(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_OPS_H */ #endif /* NEOVIM_OPS_H */

107
src/option.c
View File

@ -1893,60 +1893,59 @@ static char *(p_fdm_values[]) = {"manual", "expr", "marker", "indent", "syntax",
static char *(p_fcl_values[]) = {"all", NULL}; static char *(p_fcl_values[]) = {"all", NULL};
static char *(p_cot_values[]) = {"menu", "menuone", "longest", "preview", NULL}; static char *(p_cot_values[]) = {"menu", "menuone", "longest", "preview", NULL};
static void set_option_default __ARGS((int, int opt_flags, int compatible)); static void set_option_default(int, int opt_flags, int compatible);
static void set_options_default __ARGS((int opt_flags)); static void set_options_default(int opt_flags);
static char_u *term_bg_default __ARGS((void)); static char_u *term_bg_default(void);
static void did_set_option __ARGS((int opt_idx, int opt_flags, int new_value)); static void did_set_option(int opt_idx, int opt_flags, int new_value);
static char_u *illegal_char __ARGS((char_u *, int)); static char_u *illegal_char(char_u *, int);
static int string_to_key __ARGS((char_u *arg)); static int string_to_key(char_u *arg);
static char_u *check_cedit __ARGS((void)); static char_u *check_cedit(void);
static void did_set_title __ARGS((int icon)); static void did_set_title(int icon);
static char_u *option_expand __ARGS((int opt_idx, char_u *val)); static char_u *option_expand(int opt_idx, char_u *val);
static void didset_options __ARGS((void)); static void didset_options(void);
static void check_string_option __ARGS((char_u **pp)); static void check_string_option(char_u **pp);
static long_u *insecure_flag __ARGS((int opt_idx, int opt_flags)); static long_u *insecure_flag(int opt_idx, int opt_flags);
static void set_string_option_global __ARGS((int opt_idx, char_u **varp)); static void set_string_option_global(int opt_idx, char_u **varp);
static char_u *set_string_option __ARGS((int opt_idx, char_u *value, static char_u *set_string_option(int opt_idx, char_u *value,
int opt_flags)); int opt_flags);
static char_u *did_set_string_option __ARGS((int opt_idx, char_u **varp, static char_u *did_set_string_option(int opt_idx, char_u **varp,
int new_value_alloced, char_u * int new_value_alloced,
oldval, char_u *errbuf, char_u *oldval, char_u *errbuf,
int opt_flags)); int opt_flags);
static char_u *set_chars_option __ARGS((char_u **varp)); static char_u *set_chars_option(char_u **varp);
static int int_cmp __ARGS((const void *a, const void *b)); static int int_cmp(const void *a, const void *b);
static char_u *compile_cap_prog __ARGS((synblock_T *synblock)); static char_u *compile_cap_prog(synblock_T *synblock);
static void set_option_scriptID_idx __ARGS((int opt_idx, int opt_flags, int id)); static void set_option_scriptID_idx(int opt_idx, int opt_flags, int id);
static char_u *set_bool_option __ARGS((int opt_idx, char_u *varp, int value, static char_u *set_bool_option(int opt_idx, char_u *varp, int value,
int opt_flags)); int opt_flags);
static char_u *set_num_option __ARGS((int opt_idx, char_u *varp, long value, static char_u *set_num_option(int opt_idx, char_u *varp, long value,
char_u *errbuf, size_t errbuflen, char_u *errbuf, size_t errbuflen,
int opt_flags)); int opt_flags);
static void check_redraw __ARGS((long_u flags)); static void check_redraw(long_u flags);
static int findoption __ARGS((char_u *)); static int findoption(char_u *);
static int find_key_option __ARGS((char_u *)); static int find_key_option(char_u *);
static void showoptions __ARGS((int all, int opt_flags)); static void showoptions(int all, int opt_flags);
static int optval_default __ARGS((struct vimoption *, char_u *varp)); static int optval_default(struct vimoption *, char_u *varp);
static void showoneopt __ARGS((struct vimoption *, int opt_flags)); static void showoneopt(struct vimoption *, int opt_flags);
static int put_setstring __ARGS((FILE *fd, char *cmd, char *name, char_u * static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep,
*valuep, int expand);
int expand)); static int put_setnum(FILE *fd, char *cmd, char *name, long *valuep);
static int put_setnum __ARGS((FILE *fd, char *cmd, char *name, long *valuep)); static int put_setbool(FILE *fd, char *cmd, char *name, int value);
static int put_setbool __ARGS((FILE *fd, char *cmd, char *name, int value)); static int istermoption(struct vimoption *);
static int istermoption __ARGS((struct vimoption *)); static char_u *get_varp_scope(struct vimoption *p, int opt_flags);
static char_u *get_varp_scope __ARGS((struct vimoption *p, int opt_flags)); static char_u *get_varp(struct vimoption *);
static char_u *get_varp __ARGS((struct vimoption *)); static void option_value2string(struct vimoption *, int opt_flags);
static void option_value2string __ARGS((struct vimoption *, int opt_flags)); static int wc_use_keyname(char_u *varp, long *wcp);
static int wc_use_keyname __ARGS((char_u *varp, long *wcp)); static void langmap_init(void);
static void langmap_init __ARGS((void)); static void langmap_set(void);
static void langmap_set __ARGS((void)); static void paste_option_changed(void);
static void paste_option_changed __ARGS((void)); static void compatible_set(void);
static void compatible_set __ARGS((void)); static void fill_breakat_flags(void);
static void fill_breakat_flags __ARGS((void)); static int opt_strings_flags(char_u *val, char **values,
static int opt_strings_flags __ARGS((char_u *val, char **values,
unsigned *flagp, unsigned *flagp,
int list)); int list);
static int check_opt_strings __ARGS((char_u *val, char **values, int)); static int check_opt_strings(char_u *val, char **values, int);
static int check_opt_wim __ARGS((void)); static int check_opt_wim(void);
/* /*
* Initialize the options, first part. * Initialize the options, first part.
@ -3759,7 +3758,7 @@ static long_u *insecure_flag(int opt_idx, int opt_flags)
return &options[opt_idx].flags; return &options[opt_idx].flags;
} }
static void redraw_titles __ARGS((void)); static void redraw_titles(void);
/* /*
* Redraw the window title and/or tab page text later. * Redraw the window title and/or tab page text later.
@ -7637,7 +7636,7 @@ typedef struct {
} langmap_entry_T; } langmap_entry_T;
static garray_T langmap_mapga; static garray_T langmap_mapga;
static void langmap_set_entry __ARGS((int from, int to)); static void langmap_set_entry(int from, int to);
/* /*
* Search for an entry in "langmap_mapga" for "from". If found set the "to" * Search for an entry in "langmap_mapga" for "from". If found set the "to"

140
src/option.h
View File

@ -1,77 +1,77 @@
#ifndef NEOVIM_OPTION_H #ifndef NEOVIM_OPTION_H
#define NEOVIM_OPTION_H #define NEOVIM_OPTION_H
/* option.c */ /* option.c */
void set_init_1 __ARGS((void)); void set_init_1(void);
void set_string_default __ARGS((char *name, char_u *val)); void set_string_default(char *name, char_u *val);
void set_number_default __ARGS((char *name, long val)); void set_number_default(char *name, long val);
void free_all_options __ARGS((void)); void free_all_options(void);
void set_init_2 __ARGS((void)); void set_init_2(void);
void set_init_3 __ARGS((void)); void set_init_3(void);
void set_helplang_default __ARGS((char_u *lang)); void set_helplang_default(char_u *lang);
void init_gui_options __ARGS((void)); void init_gui_options(void);
void set_title_defaults __ARGS((void)); void set_title_defaults(void);
int do_set __ARGS((char_u *arg, int opt_flags)); int do_set(char_u *arg, int opt_flags);
void set_options_bin __ARGS((int oldval, int newval, int opt_flags)); void set_options_bin(int oldval, int newval, int opt_flags);
int get_viminfo_parameter __ARGS((int type)); int get_viminfo_parameter(int type);
char_u *find_viminfo_parameter __ARGS((int type)); char_u *find_viminfo_parameter(int type);
void check_options __ARGS((void)); void check_options(void);
void check_buf_options __ARGS((buf_T *buf)); void check_buf_options(buf_T *buf);
void free_string_option __ARGS((char_u *p)); void free_string_option(char_u *p);
void clear_string_option __ARGS((char_u **pp)); void clear_string_option(char_u **pp);
void set_term_option_alloced __ARGS((char_u **p)); void set_term_option_alloced(char_u **p);
int was_set_insecurely __ARGS((char_u *opt, int opt_flags)); int was_set_insecurely(char_u *opt, int opt_flags);
void set_string_option_direct __ARGS((char_u *name, int opt_idx, char_u *val, void set_string_option_direct(char_u *name, int opt_idx, char_u *val,
int opt_flags, int opt_flags,
int set_sid)); int set_sid);
char_u *check_colorcolumn __ARGS((win_T *wp)); char_u *check_colorcolumn(win_T *wp);
char_u *check_stl_option __ARGS((char_u *s)); char_u *check_stl_option(char_u *s);
int get_option_value __ARGS((char_u *name, long *numval, char_u **stringval, int get_option_value(char_u *name, long *numval, char_u **stringval,
int opt_flags)); int opt_flags);
int get_option_value_strict __ARGS((char_u *name, long *numval, char_u * int get_option_value_strict(char_u *name, long *numval, char_u *
*stringval, int opt_type, *stringval, int opt_type,
void *from)); void *from);
char_u *option_iter_next __ARGS((void **option, int opt_type)); char_u *option_iter_next(void **option, int opt_type);
char_u *set_option_value __ARGS((char_u *name, long number, char_u *string, char_u *set_option_value(char_u *name, long number, char_u *string,
int opt_flags)); int opt_flags);
char_u *get_term_code __ARGS((char_u *tname)); char_u *get_term_code(char_u *tname);
char_u *get_highlight_default __ARGS((void)); char_u *get_highlight_default(void);
char_u *get_encoding_default __ARGS((void)); char_u *get_encoding_default(void);
int makeset __ARGS((FILE *fd, int opt_flags, int local_only)); int makeset(FILE *fd, int opt_flags, int local_only);
int makefoldset __ARGS((FILE *fd)); int makefoldset(FILE *fd);
void clear_termoptions __ARGS((void)); void clear_termoptions(void);
void free_termoptions __ARGS((void)); void free_termoptions(void);
void free_one_termoption __ARGS((char_u *var)); void free_one_termoption(char_u *var);
void set_term_defaults __ARGS((void)); void set_term_defaults(void);
void comp_col __ARGS((void)); void comp_col(void);
void unset_global_local_option __ARGS((char_u *name, void *from)); void unset_global_local_option(char_u *name, void *from);
char_u *get_equalprg __ARGS((void)); char_u *get_equalprg(void);
void win_copy_options __ARGS((win_T *wp_from, win_T *wp_to)); void win_copy_options(win_T *wp_from, win_T *wp_to);
void copy_winopt __ARGS((winopt_T *from, winopt_T *to)); void copy_winopt(winopt_T *from, winopt_T *to);
void check_win_options __ARGS((win_T *win)); void check_win_options(win_T *win);
void check_winopt __ARGS((winopt_T *wop)); void check_winopt(winopt_T *wop);
void clear_winopt __ARGS((winopt_T *wop)); void clear_winopt(winopt_T *wop);
void buf_copy_options __ARGS((buf_T *buf, int flags)); void buf_copy_options(buf_T *buf, int flags);
void reset_modifiable __ARGS((void)); void reset_modifiable(void);
void set_iminsert_global __ARGS((void)); void set_iminsert_global(void);
void set_imsearch_global __ARGS((void)); void set_imsearch_global(void);
void set_context_in_set_cmd __ARGS((expand_T *xp, char_u *arg, int opt_flags)); void set_context_in_set_cmd(expand_T *xp, char_u *arg, int opt_flags);
int ExpandSettings __ARGS((expand_T *xp, regmatch_T *regmatch, int *num_file, int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file,
char_u ***file)); char_u ***file);
int ExpandOldSetting __ARGS((int *num_file, char_u ***file)); int ExpandOldSetting(int *num_file, char_u ***file);
int langmap_adjust_mb __ARGS((int c)); int langmap_adjust_mb(int c);
int has_format_option __ARGS((int x)); int has_format_option(int x);
int shortmess __ARGS((int x)); int shortmess(int x);
void vimrc_found __ARGS((char_u *fname, char_u *envname)); void vimrc_found(char_u *fname, char_u *envname);
void change_compatible __ARGS((int on)); void change_compatible(int on);
int option_was_set __ARGS((char_u *name)); int option_was_set(char_u *name);
void reset_option_was_set __ARGS((char_u *name)); void reset_option_was_set(char_u *name);
int can_bs __ARGS((int what)); int can_bs(int what);
void save_file_ff __ARGS((buf_T *buf)); void save_file_ff(buf_T *buf);
int file_ff_differs __ARGS((buf_T *buf, int ignore_empty)); int file_ff_differs(buf_T *buf, int ignore_empty);
int check_ff_value __ARGS((char_u *p)); int check_ff_value(char_u *p);
long get_sw_value __ARGS((buf_T *buf)); long get_sw_value(buf_T *buf);
long get_sts_value __ARGS((void)); long get_sts_value(void);
void find_mps_values __ARGS((int *initc, int *findc, int *backwards, void find_mps_values(int *initc, int *findc, int *backwards,
int switchit)); int switchit);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_OPTION_H */ #endif /* NEOVIM_OPTION_H */

58
src/os_unix.c
View File

@ -62,7 +62,7 @@ static int selinux_enabled = -1;
#if defined(HAVE_SELECT) #if defined(HAVE_SELECT)
extern int select __ARGS((int, fd_set *, fd_set *, fd_set *, struct timeval *)); extern int select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
#endif #endif
@ -87,49 +87,49 @@ extern int select __ARGS((int, fd_set *, fd_set *, fd_set *, struct timeval *));
#endif #endif
static int get_x11_title __ARGS((int)); static int get_x11_title(int);
static int get_x11_icon __ARGS((int)); static int get_x11_icon(int);
static char_u *oldtitle = NULL; static char_u *oldtitle = NULL;
static int did_set_title = FALSE; static int did_set_title = FALSE;
static char_u *oldicon = NULL; static char_u *oldicon = NULL;
static int did_set_icon = FALSE; static int did_set_icon = FALSE;
static void may_core_dump __ARGS((void)); static void may_core_dump(void);
#ifdef HAVE_UNION_WAIT #ifdef HAVE_UNION_WAIT
typedef union wait waitstatus; typedef union wait waitstatus;
#else #else
typedef int waitstatus; typedef int waitstatus;
#endif #endif
static pid_t wait4pid __ARGS((pid_t, waitstatus *)); static pid_t wait4pid(pid_t, waitstatus *);
static int WaitForChar __ARGS((long)); static int WaitForChar(long);
static int RealWaitForChar __ARGS((int, long, int *)); static int RealWaitForChar(int, long, int *);
static void handle_resize __ARGS((void)); static void handle_resize(void);
#if defined(SIGWINCH) #if defined(SIGWINCH)
static RETSIGTYPE sig_winch __ARGS(SIGPROTOARG); static RETSIGTYPE sig_winch SIGPROTOARG;
#endif #endif
#if defined(SIGINT) #if defined(SIGINT)
static RETSIGTYPE catch_sigint __ARGS(SIGPROTOARG); static RETSIGTYPE catch_sigint SIGPROTOARG;
#endif #endif
#if defined(SIGPWR) #if defined(SIGPWR)
static RETSIGTYPE catch_sigpwr __ARGS(SIGPROTOARG); static RETSIGTYPE catch_sigpwr SIGPROTOARG;
#endif #endif
static RETSIGTYPE deathtrap __ARGS(SIGPROTOARG); static RETSIGTYPE deathtrap SIGPROTOARG;
static void catch_int_signal __ARGS((void)); static void catch_int_signal(void);
static void set_signals __ARGS((void)); static void set_signals(void);
static void catch_signals __ARGS( static void catch_signals
(RETSIGTYPE (*func_deadly)(), RETSIGTYPE (*func_other)())); (RETSIGTYPE (*func_deadly)(), RETSIGTYPE (*func_other)());
static int have_wildcard __ARGS((int, char_u **)); static int have_wildcard(int, char_u **);
static int have_dollars __ARGS((int, char_u **)); static int have_dollars(int, char_u **);
static int save_patterns __ARGS((int num_pat, char_u **pat, int *num_file, static int save_patterns(int num_pat, char_u **pat, int *num_file,
char_u ***file)); char_u ***file);
#ifndef SIG_ERR #ifndef SIG_ERR
# define SIG_ERR ((RETSIGTYPE (*)())-1) # define SIG_ERR ((RETSIGTYPE (*)())-1)
@ -408,7 +408,7 @@ void mch_delay(long msec, int ignoreinput)
* Return a pointer to an item on the stack. Used to find out if the stack * Return a pointer to an item on the stack. Used to find out if the stack
* grows up or down. * grows up or down.
*/ */
static void check_stack_growth __ARGS((char *p)); static void check_stack_growth(char *p);
static int stack_grows_downwards; static int stack_grows_downwards;
/* /*
@ -515,7 +515,7 @@ static stack_t sigstk; /* for sigaltstack() */
static struct sigstack sigstk; /* for sigstack() */ static struct sigstack sigstk; /* for sigstack() */
# endif # endif
static void init_signal_stack __ARGS((void)); static void init_signal_stack(void);
static char *signal_stack; static char *signal_stack;
static void init_signal_stack() { static void init_signal_stack() {
@ -765,7 +765,7 @@ deathtrap SIGDEFARG(sigarg) {
* volatile because it is used in signal handler sigcont_handler(). * volatile because it is used in signal handler sigcont_handler().
*/ */
static volatile int sigcont_received; static volatile int sigcont_received;
static RETSIGTYPE sigcont_handler __ARGS(SIGPROTOARG); static RETSIGTYPE sigcont_handler SIGPROTOARG;
/* /*
* signal handler for SIGCONT * signal handler for SIGCONT
@ -1445,7 +1445,7 @@ int mch_isdir(char_u *name)
#endif #endif
} }
static int executable_file __ARGS((char_u *name)); static int executable_file(char_u *name);
/* /*
* Return 1 if "name" is an executable file, 0 if not or it doesn't exist. * Return 1 if "name" is an executable file, 0 if not or it doesn't exist.
@ -1566,7 +1566,7 @@ void mch_free_mem() {
#endif #endif
static void exit_scroll __ARGS((void)); static void exit_scroll(void);
/* /*
* Output a newline when exiting. * Output a newline when exiting.
@ -3556,10 +3556,10 @@ const char *src, *dest;
#if defined(FEAT_LIBCALL) || defined(PROTO) #if defined(FEAT_LIBCALL) || defined(PROTO)
typedef char_u * (*STRPROCSTR) __ARGS ((char_u *)); typedef char_u * (*STRPROCSTR)(char_u *);
typedef char_u * (*INTPROCSTR) __ARGS ((int)); typedef char_u * (*INTPROCSTR)(int);
typedef int (*STRPROCINT) __ARGS ((char_u *)); typedef int (*STRPROCINT)(char_u *);
typedef int (*INTPROCINT) __ARGS ((int)); typedef int (*INTPROCINT)(int);
/* /*
* Call a DLL routine which takes either a string or int param * Call a DLL routine which takes either a string or int param

142
src/os_unix.h
View File

@ -1,78 +1,78 @@
#ifndef NEOVIM_OS_UNIX_H #ifndef NEOVIM_OS_UNIX_H
#define NEOVIM_OS_UNIX_H #define NEOVIM_OS_UNIX_H
/* os_unix.c */ /* os_unix.c */
void mch_write __ARGS((char_u *s, int len)); void mch_write(char_u *s, int len);
int mch_inchar __ARGS((char_u *buf, int maxlen, long wtime, int tb_change_cnt)); int mch_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
int mch_char_avail __ARGS((void)); int mch_char_avail(void);
void mch_delay __ARGS((long msec, int ignoreinput)); void mch_delay(long msec, int ignoreinput);
int mch_stackcheck __ARGS((char *p)); int mch_stackcheck(char *p);
void mch_startjmp __ARGS((void)); void mch_startjmp(void);
void mch_endjmp __ARGS((void)); void mch_endjmp(void);
void mch_didjmp __ARGS((void)); void mch_didjmp(void);
void mch_suspend __ARGS((void)); void mch_suspend(void);
void mch_init __ARGS((void)); void mch_init(void);
void reset_signals __ARGS((void)); void reset_signals(void);
int vim_handle_signal __ARGS((int sig)); int vim_handle_signal(int sig);
int mch_check_win __ARGS((int argc, char **argv)); int mch_check_win(int argc, char **argv);
int mch_input_isatty __ARGS((void)); int mch_input_isatty(void);
int mch_can_restore_title __ARGS((void)); int mch_can_restore_title(void);
int mch_can_restore_icon __ARGS((void)); int mch_can_restore_icon(void);
void mch_settitle __ARGS((char_u *title, char_u *icon)); void mch_settitle(char_u *title, char_u *icon);
void mch_restore_title __ARGS((int which)); void mch_restore_title(int which);
int vim_is_xterm __ARGS((char_u *name)); int vim_is_xterm(char_u *name);
int use_xterm_like_mouse __ARGS((char_u *name)); int use_xterm_like_mouse(char_u *name);
int use_xterm_mouse __ARGS((void)); int use_xterm_mouse(void);
int vim_is_iris __ARGS((char_u *name)); int vim_is_iris(char_u *name);
int vim_is_vt300 __ARGS((char_u *name)); int vim_is_vt300(char_u *name);
int vim_is_fastterm __ARGS((char_u *name)); int vim_is_fastterm(char_u *name);
int mch_get_user_name __ARGS((char_u *s, int len)); int mch_get_user_name(char_u *s, int len);
int mch_get_uname __ARGS((uid_t uid, char_u *s, int len)); int mch_get_uname(uid_t uid, char_u *s, int len);
void mch_get_host_name __ARGS((char_u *s, int len)); void mch_get_host_name(char_u *s, int len);
long mch_get_pid __ARGS((void)); long mch_get_pid(void);
void slash_adjust __ARGS((char_u *p)); void slash_adjust(char_u *p);
void fname_case __ARGS((char_u *name, int len)); void fname_case(char_u *name, int len);
long mch_getperm __ARGS((char_u *name)); long mch_getperm(char_u *name);
int mch_setperm __ARGS((char_u *name, long perm)); int mch_setperm(char_u *name, long perm);
void mch_copy_sec __ARGS((char_u *from_file, char_u *to_file)); void mch_copy_sec(char_u *from_file, char_u *to_file);
vim_acl_T mch_get_acl __ARGS((char_u *fname)); vim_acl_T mch_get_acl(char_u *fname);
void mch_set_acl __ARGS((char_u *fname, vim_acl_T aclent)); void mch_set_acl(char_u *fname, vim_acl_T aclent);
void mch_free_acl __ARGS((vim_acl_T aclent)); void mch_free_acl(vim_acl_T aclent);
void mch_hide __ARGS((char_u *name)); void mch_hide(char_u *name);
int mch_isdir __ARGS((char_u *name)); int mch_isdir(char_u *name);
int mch_can_exe __ARGS((char_u *name)); int mch_can_exe(char_u *name);
int mch_nodetype __ARGS((char_u *name)); int mch_nodetype(char_u *name);
void mch_early_init __ARGS((void)); void mch_early_init(void);
void mch_free_mem __ARGS((void)); void mch_free_mem(void);
void mch_exit __ARGS((int r)); void mch_exit(int r);
void mch_settmode __ARGS((int tmode)); void mch_settmode(int tmode);
void get_stty __ARGS((void)); void get_stty(void);
void mch_setmouse __ARGS((int on)); void mch_setmouse(int on);
void check_mouse_termcode __ARGS((void)); void check_mouse_termcode(void);
int mch_screenmode __ARGS((char_u *arg)); int mch_screenmode(char_u *arg);
int mch_get_shellsize __ARGS((void)); int mch_get_shellsize(void);
void mch_set_shellsize __ARGS((void)); void mch_set_shellsize(void);
void mch_new_shellsize __ARGS((void)); void mch_new_shellsize(void);
int mch_call_shell __ARGS((char_u *cmd, int options)); int mch_call_shell(char_u *cmd, int options);
void mch_breakcheck __ARGS((void)); void mch_breakcheck(void);
int mch_expandpath __ARGS((garray_T *gap, char_u *path, int flags)); int mch_expandpath(garray_T *gap, char_u *path, int flags);
int mch_expand_wildcards __ARGS((int num_pat, char_u **pat, int *num_file, int mch_expand_wildcards(int num_pat, char_u **pat, int *num_file,
char_u ***file, char_u ***file,
int flags)); int flags);
int mch_has_exp_wildcard __ARGS((char_u *p)); int mch_has_exp_wildcard(char_u *p);
int mch_has_wildcard __ARGS((char_u *p)); int mch_has_wildcard(char_u *p);
int mch_libcall __ARGS((char_u *libname, char_u *funcname, char_u *argstring, int mch_libcall(char_u *libname, char_u *funcname, char_u *argstring,
int argint, char_u **string_result, int argint, char_u **string_result,
int *number_result)); int *number_result);
void setup_term_clip __ARGS((void)); void setup_term_clip(void);
void start_xterm_trace __ARGS((int button)); void start_xterm_trace(int button);
void stop_xterm_trace __ARGS((void)); void stop_xterm_trace(void);
void clear_xterm_clip __ARGS((void)); void clear_xterm_clip(void);
int clip_xterm_own_selection __ARGS((VimClipboard *cbd)); int clip_xterm_own_selection(VimClipboard *cbd);
void clip_xterm_lose_selection __ARGS((VimClipboard *cbd)); void clip_xterm_lose_selection(VimClipboard *cbd);
void clip_xterm_request_selection __ARGS((VimClipboard *cbd)); void clip_xterm_request_selection(VimClipboard *cbd);
void clip_xterm_set_selection __ARGS((VimClipboard *cbd)); void clip_xterm_set_selection(VimClipboard *cbd);
int xsmp_handle_requests __ARGS((void)); int xsmp_handle_requests(void);
void xsmp_init __ARGS((void)); void xsmp_init(void);
void xsmp_close __ARGS((void)); void xsmp_close(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_OS_UNIX_H */ #endif /* NEOVIM_OS_UNIX_H */

16
src/os_unix_defs.h
View File

@ -42,16 +42,6 @@
* Sun defines FILE on SunOS 4.x.x, Solaris has a typedef for FILE * Sun defines FILE on SunOS 4.x.x, Solaris has a typedef for FILE
*/ */
#ifndef __ARGS
/* The AIX VisualAge cc compiler defines __EXTENDED__ instead of __STDC__
* because it includes pre-ansi features. */
# if defined(__STDC__) || defined(__GNUC__) || defined(__EXTENDED__)
# define __ARGS(x) x
# else
# define __ARGS(x) ()
# endif
#endif
/* always use unlink() to remove files */ /* always use unlink() to remove files */
# define vim_mkdir(x, y) mkdir((char *)(x), y) # define vim_mkdir(x, y) mkdir((char *)(x), y)
# define mch_rmdir(x) rmdir((char *)(x)) # define mch_rmdir(x) rmdir((char *)(x))
@ -135,10 +125,6 @@
# include <pwd.h> # include <pwd.h>
#endif #endif
#ifdef __COHERENT__
# undef __ARGS
#endif
/* /*
* Unix system-dependent file names * Unix system-dependent file names
*/ */
@ -292,7 +278,7 @@
# ifdef HAVE_RENAME # ifdef HAVE_RENAME
# define mch_rename(src, dst) rename(src, dst) # define mch_rename(src, dst) rename(src, dst)
# else # else
int mch_rename __ARGS((const char *src, const char *dest)); int mch_rename(const char *src, const char *dest);
# endif # endif
# ifdef __MVS__ # ifdef __MVS__
/* on OS390 Unix getenv() doesn't return a pointer to persistent /* on OS390 Unix getenv() doesn't return a pointer to persistent

2
src/popupmnu.c
View File

@ -38,7 +38,7 @@ static int pum_col; /* left column of pum */
static int pum_do_redraw = FALSE; /* do redraw anyway */ static int pum_do_redraw = FALSE; /* do redraw anyway */
static int pum_set_selected __ARGS((int n, int repeat)); static int pum_set_selected(int n, int repeat);
#define PUM_DEF_HEIGHT 10 #define PUM_DEF_HEIGHT 10
#define PUM_DEF_WIDTH 15 #define PUM_DEF_WIDTH 15

12
src/popupmnu.h
View File

@ -1,11 +1,11 @@
#ifndef NEOVIM_POPUPMNU_H #ifndef NEOVIM_POPUPMNU_H
#define NEOVIM_POPUPMNU_H #define NEOVIM_POPUPMNU_H
/* popupmnu.c */ /* popupmnu.c */
void pum_display __ARGS((pumitem_T *array, int size, int selected)); void pum_display(pumitem_T *array, int size, int selected);
void pum_redraw __ARGS((void)); void pum_redraw(void);
void pum_undisplay __ARGS((void)); void pum_undisplay(void);
void pum_clear __ARGS((void)); void pum_clear(void);
int pum_visible __ARGS((void)); int pum_visible(void);
int pum_get_height __ARGS((void)); int pum_get_height(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_POPUPMNU_H */ #endif /* NEOVIM_POPUPMNU_H */

14
src/proto.h
View File

@ -30,16 +30,16 @@
/* These prototypes cannot be produced automatically and conflict with /* These prototypes cannot be produced automatically and conflict with
* the old-style prototypes in message.c. */ * the old-style prototypes in message.c. */
int int
smsg __ARGS((char_u *, ...)); smsg(char_u *, ...);
int int
smsg_attr __ARGS((int, char_u *, ...)); smsg_attr(int, char_u *, ...);
int int
vim_snprintf_add __ARGS((char *, size_t, char *, ...)); vim_snprintf_add(char *, size_t, char *, ...);
int int
vim_snprintf __ARGS((char *, size_t, char *, ...)); vim_snprintf(char *, size_t, char *, ...);
# if defined(HAVE_STDARG_H) # if defined(HAVE_STDARG_H)
int vim_vsnprintf(char *str, size_t str_m, char *fmt, va_list ap, typval_T *tvs); int vim_vsnprintf(char *str, size_t str_m, char *fmt, va_list ap, typval_T *tvs);
@ -47,12 +47,12 @@ int vim_vsnprintf(char *str, size_t str_m, char *fmt, va_list ap, typval_T *tvs)
# endif # endif
#ifndef HAVE_STRPBRK /* not generated automatically from misc2.c */ #ifndef HAVE_STRPBRK /* not generated automatically from misc2.c */
char_u *vim_strpbrk __ARGS((char_u *s, char_u *charset)); char_u *vim_strpbrk(char_u *s, char_u *charset);
#endif #endif
#ifndef HAVE_QSORT #ifndef HAVE_QSORT
/* Use our own qsort(), don't define the prototype when not used. */ /* Use our own qsort(), don't define the prototype when not used. */
void qsort __ARGS((void *base, size_t elm_count, size_t elm_size, int (*cmp)( void qsort(void *base, size_t elm_count, size_t elm_size,
const void *, const void *))); int (*cmp)(const void *, const void *));
#endif #endif
/* Ugly solution for "BalloonEval" not being defined while it's used in some /* Ugly solution for "BalloonEval" not being defined while it's used in some

60
src/quickfix.c
View File

@ -129,42 +129,42 @@ struct efm_S {
int conthere; /* %> used */ int conthere; /* %> used */
}; };
static int qf_init_ext __ARGS((qf_info_T *qi, char_u *efile, buf_T *buf, static int qf_init_ext(qf_info_T *qi, char_u *efile, buf_T *buf,
typval_T *tv, char_u *errorformat, int newlist, typval_T *tv, char_u *errorformat, int newlist,
linenr_T lnumfirst, linenr_T lnumfirst,
linenr_T lnumlast, linenr_T lnumlast,
char_u *qf_title)); char_u *qf_title);
static void qf_new_list __ARGS((qf_info_T *qi, char_u *qf_title)); static void qf_new_list(qf_info_T *qi, char_u *qf_title);
static void ll_free_all __ARGS((qf_info_T **pqi)); static void ll_free_all(qf_info_T **pqi);
static int qf_add_entry __ARGS((qf_info_T *qi, qfline_T **prevp, char_u *dir, static int qf_add_entry(qf_info_T *qi, qfline_T **prevp, char_u *dir,
char_u *fname, int bufnum, char_u *mesg, char_u *fname, int bufnum, char_u *mesg,
long lnum, int col, int vis_col, long lnum, int col, int vis_col,
char_u *pattern, int nr, int type, char_u *pattern, int nr, int type,
int valid)); int valid);
static qf_info_T *ll_new_list __ARGS((void)); static qf_info_T *ll_new_list(void);
static void qf_msg __ARGS((qf_info_T *qi)); static void qf_msg(qf_info_T *qi);
static void qf_free __ARGS((qf_info_T *qi, int idx)); static void qf_free(qf_info_T *qi, int idx);
static char_u *qf_types __ARGS((int, int)); static char_u *qf_types(int, int);
static int qf_get_fnum __ARGS((char_u *, char_u *)); static int qf_get_fnum(char_u *, char_u *);
static char_u *qf_push_dir __ARGS((char_u *, struct dir_stack_T **)); static char_u *qf_push_dir(char_u *, struct dir_stack_T **);
static char_u *qf_pop_dir __ARGS((struct dir_stack_T **)); static char_u *qf_pop_dir(struct dir_stack_T **);
static char_u *qf_guess_filepath __ARGS((char_u *)); static char_u *qf_guess_filepath(char_u *);
static void qf_fmt_text __ARGS((char_u *text, char_u *buf, int bufsize)); static void qf_fmt_text(char_u *text, char_u *buf, int bufsize);
static void qf_clean_dir_stack __ARGS((struct dir_stack_T **)); static void qf_clean_dir_stack(struct dir_stack_T **);
static int qf_win_pos_update __ARGS((qf_info_T *qi, int old_qf_index)); static int qf_win_pos_update(qf_info_T *qi, int old_qf_index);
static int is_qf_win __ARGS((win_T *win, qf_info_T *qi)); static int is_qf_win(win_T *win, qf_info_T *qi);
static win_T *qf_find_win __ARGS((qf_info_T *qi)); static win_T *qf_find_win(qf_info_T *qi);
static buf_T *qf_find_buf __ARGS((qf_info_T *qi)); static buf_T *qf_find_buf(qf_info_T *qi);
static void qf_update_buffer __ARGS((qf_info_T *qi)); static void qf_update_buffer(qf_info_T *qi);
static void qf_set_title __ARGS((qf_info_T *qi)); static void qf_set_title(qf_info_T *qi);
static void qf_fill_buffer __ARGS((qf_info_T *qi)); static void qf_fill_buffer(qf_info_T *qi);
static char_u *get_mef_name __ARGS((void)); static char_u *get_mef_name(void);
static void restore_start_dir __ARGS((char_u *dirname_start)); static void restore_start_dir(char_u *dirname_start);
static buf_T *load_dummy_buffer __ARGS((char_u *fname, char_u *dirname_start, static buf_T *load_dummy_buffer(char_u *fname, char_u *dirname_start,
char_u *resulting_dir)); char_u *resulting_dir);
static void wipe_dummy_buffer __ARGS((buf_T *buf, char_u *dirname_start)); static void wipe_dummy_buffer(buf_T *buf, char_u *dirname_start);
static void unload_dummy_buffer __ARGS((buf_T *buf, char_u *dirname_start)); static void unload_dummy_buffer(buf_T *buf, char_u *dirname_start);
static qf_info_T *ll_get_or_alloc_list __ARGS((win_T *)); static qf_info_T *ll_get_or_alloc_list(win_T *);
/* Quickfix window check helper macro */ /* Quickfix window check helper macro */
#define IS_QF_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref == NULL) #define IS_QF_WINDOW(wp) (bt_quickfix(wp->w_buffer) && wp->w_llist_ref == NULL)

60
src/quickfix.h
View File

@ -1,36 +1,36 @@
#ifndef NEOVIM_QUICKFIX_H #ifndef NEOVIM_QUICKFIX_H
#define NEOVIM_QUICKFIX_H #define NEOVIM_QUICKFIX_H
/* quickfix.c */ /* quickfix.c */
int qf_init __ARGS((win_T *wp, char_u *efile, char_u *errorformat, int newlist, int qf_init(win_T *wp, char_u *efile, char_u *errorformat, int newlist,
char_u *qf_title)); char_u *qf_title);
void qf_free_all __ARGS((win_T *wp)); void qf_free_all(win_T *wp);
void copy_loclist __ARGS((win_T *from, win_T *to)); void copy_loclist(win_T *from, win_T *to);
void qf_jump __ARGS((qf_info_T *qi, int dir, int errornr, int forceit)); void qf_jump(qf_info_T *qi, int dir, int errornr, int forceit);
void qf_list __ARGS((exarg_T *eap)); void qf_list(exarg_T *eap);
void qf_age __ARGS((exarg_T *eap)); void qf_age(exarg_T *eap);
void qf_mark_adjust __ARGS((win_T *wp, linenr_T line1, linenr_T line2, void qf_mark_adjust(win_T *wp, linenr_T line1, linenr_T line2,
long amount, long amount,
long amount_after)); long amount_after);
void ex_cwindow __ARGS((exarg_T *eap)); void ex_cwindow(exarg_T *eap);
void ex_cclose __ARGS((exarg_T *eap)); void ex_cclose(exarg_T *eap);
void ex_copen __ARGS((exarg_T *eap)); void ex_copen(exarg_T *eap);
linenr_T qf_current_entry __ARGS((win_T *wp)); linenr_T qf_current_entry(win_T *wp);
int bt_quickfix __ARGS((buf_T *buf)); int bt_quickfix(buf_T *buf);
int bt_nofile __ARGS((buf_T *buf)); int bt_nofile(buf_T *buf);
int bt_dontwrite __ARGS((buf_T *buf)); int bt_dontwrite(buf_T *buf);
int bt_dontwrite_msg __ARGS((buf_T *buf)); int bt_dontwrite_msg(buf_T *buf);
int buf_hide __ARGS((buf_T *buf)); int buf_hide(buf_T *buf);
int grep_internal __ARGS((cmdidx_T cmdidx)); int grep_internal(cmdidx_T cmdidx);
void ex_make __ARGS((exarg_T *eap)); void ex_make(exarg_T *eap);
void ex_cc __ARGS((exarg_T *eap)); void ex_cc(exarg_T *eap);
void ex_cnext __ARGS((exarg_T *eap)); void ex_cnext(exarg_T *eap);
void ex_cfile __ARGS((exarg_T *eap)); void ex_cfile(exarg_T *eap);
void ex_vimgrep __ARGS((exarg_T *eap)); void ex_vimgrep(exarg_T *eap);
char_u *skip_vimgrep_pat __ARGS((char_u *p, char_u **s, int *flags)); char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags);
int get_errorlist __ARGS((win_T *wp, list_T *list)); int get_errorlist(win_T *wp, list_T *list);
int set_errorlist __ARGS((win_T *wp, list_T *list, int action, char_u *title)); int set_errorlist(win_T *wp, list_T *list, int action, char_u *title);
void ex_cbuffer __ARGS((exarg_T *eap)); void ex_cbuffer(exarg_T *eap);
void ex_cexpr __ARGS((exarg_T *eap)); void ex_cexpr(exarg_T *eap);
void ex_helpgrep __ARGS((exarg_T *eap)); void ex_helpgrep(exarg_T *eap);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_QUICKFIX_H */ #endif /* NEOVIM_QUICKFIX_H */

168
src/regexp.c
View File

@ -262,8 +262,8 @@
#define un_Magic(x) ((x) + 256) #define un_Magic(x) ((x) + 256)
#define is_Magic(x) ((x) < 0) #define is_Magic(x) ((x) < 0)
static int no_Magic __ARGS((int x)); static int no_Magic(int x);
static int toggle_Magic __ARGS((int x)); static int toggle_Magic(int x);
static int no_Magic(int x) static int no_Magic(int x)
{ {
@ -357,15 +357,15 @@ static int toggle_Magic(int x)
#define MAX_LIMIT (32767L << 16L) #define MAX_LIMIT (32767L << 16L)
static int re_multi_type __ARGS((int)); static int re_multi_type(int);
static int cstrncmp __ARGS((char_u *s1, char_u *s2, int *n)); static int cstrncmp(char_u *s1, char_u *s2, int *n);
static char_u *cstrchr __ARGS((char_u *, int)); static char_u *cstrchr(char_u *, int);
#ifdef BT_REGEXP_DUMP #ifdef BT_REGEXP_DUMP
static void regdump __ARGS((char_u *, bt_regprog_T *)); static void regdump(char_u *, bt_regprog_T *);
#endif #endif
#ifdef REGEXP_DEBUG #ifdef REGEXP_DEBUG
static char_u *regprop __ARGS((char_u *)); static char_u *regprop(char_u *);
#endif #endif
static char_u e_missingbracket[] = N_("E769: Missing ] after %s["); static char_u e_missingbracket[] = N_("E769: Missing ] after %s[");
@ -430,13 +430,13 @@ static char_u *reg_prev_sub = NULL;
static char_u REGEXP_INRANGE[] = "]^-n\\"; static char_u REGEXP_INRANGE[] = "]^-n\\";
static char_u REGEXP_ABBR[] = "nrtebdoxuU"; static char_u REGEXP_ABBR[] = "nrtebdoxuU";
static int backslash_trans __ARGS((int c)); static int backslash_trans(int c);
static int get_char_class __ARGS((char_u **pp)); static int get_char_class(char_u **pp);
static int get_equi_class __ARGS((char_u **pp)); static int get_equi_class(char_u **pp);
static void reg_equi_class __ARGS((int c)); static void reg_equi_class(int c);
static int get_coll_element __ARGS((char_u **pp)); static int get_coll_element(char_u **pp);
static char_u *skip_anyof __ARGS((char_u *p)); static char_u *skip_anyof(char_u *p);
static void init_class_tab __ARGS((void)); static void init_class_tab(void);
/* /*
* Translate '\x' to its control character, except "\n", which is Magic. * Translate '\x' to its control character, except "\n", which is Magic.
@ -652,39 +652,39 @@ typedef struct {
/* /*
* Forward declarations for vim_regcomp()'s friends. * Forward declarations for vim_regcomp()'s friends.
*/ */
static void initchr __ARGS((char_u *)); static void initchr(char_u *);
static void save_parse_state __ARGS((parse_state_T *ps)); static void save_parse_state(parse_state_T *ps);
static void restore_parse_state __ARGS((parse_state_T *ps)); static void restore_parse_state(parse_state_T *ps);
static int getchr __ARGS((void)); static int getchr(void);
static void skipchr_keepstart __ARGS((void)); static void skipchr_keepstart(void);
static int peekchr __ARGS((void)); static int peekchr(void);
static void skipchr __ARGS((void)); static void skipchr(void);
static void ungetchr __ARGS((void)); static void ungetchr(void);
static int gethexchrs __ARGS((int maxinputlen)); static int gethexchrs(int maxinputlen);
static int getoctchrs __ARGS((void)); static int getoctchrs(void);
static int getdecchrs __ARGS((void)); static int getdecchrs(void);
static int coll_get_char __ARGS((void)); static int coll_get_char(void);
static void regcomp_start __ARGS((char_u *expr, int flags)); static void regcomp_start(char_u *expr, int flags);
static char_u *reg __ARGS((int, int *)); static char_u *reg(int, int *);
static char_u *regbranch __ARGS((int *flagp)); static char_u *regbranch(int *flagp);
static char_u *regconcat __ARGS((int *flagp)); static char_u *regconcat(int *flagp);
static char_u *regpiece __ARGS((int *)); static char_u *regpiece(int *);
static char_u *regatom __ARGS((int *)); static char_u *regatom(int *);
static char_u *regnode __ARGS((int)); static char_u *regnode(int);
static int use_multibytecode __ARGS((int c)); static int use_multibytecode(int c);
static int prog_magic_wrong __ARGS((void)); static int prog_magic_wrong(void);
static char_u *regnext __ARGS((char_u *)); static char_u *regnext(char_u *);
static void regc __ARGS((int b)); static void regc(int b);
static void regmbc __ARGS((int c)); static void regmbc(int c);
# define REGMBC(x) regmbc(x); # define REGMBC(x) regmbc(x);
# define CASEMBC(x) case x: # define CASEMBC(x) case x:
static void reginsert __ARGS((int, char_u *)); static void reginsert(int, char_u *);
static void reginsert_nr __ARGS((int op, long val, char_u *opnd)); static void reginsert_nr(int op, long val, char_u *opnd);
static void reginsert_limits __ARGS((int, long, long, char_u *)); static void reginsert_limits(int, long, long, char_u *);
static char_u *re_put_long __ARGS((char_u *pr, long_u val)); static char_u *re_put_long(char_u *pr, long_u val);
static int read_limits __ARGS((long *, long *)); static int read_limits(long *, long *);
static void regtail __ARGS((char_u *, char_u *)); static void regtail(char_u *, char_u *);
static void regoptail __ARGS((char_u *, char_u *)); static void regoptail(char_u *, char_u *);
static regengine_T bt_regengine; static regengine_T bt_regengine;
static regengine_T nfa_regengine; static regengine_T nfa_regengine;
@ -1066,7 +1066,7 @@ static int get_coll_element(char_u **pp)
return 0; return 0;
} }
static void get_cpo_flags __ARGS((void)); static void get_cpo_flags(void);
static int reg_cpo_lit; /* 'cpoptions' contains 'l' flag */ static int reg_cpo_lit; /* 'cpoptions' contains 'l' flag */
static int reg_cpo_bsl; /* 'cpoptions' contains '\' flag */ static int reg_cpo_bsl; /* 'cpoptions' contains '\' flag */
@ -1163,8 +1163,8 @@ char_u *skip_regexp(char_u *startp, int dirc, int magic, char_u **newp)
return p; return p;
} }
static regprog_T *bt_regcomp __ARGS((char_u *expr, int re_flags)); static regprog_T *bt_regcomp(char_u *expr, int re_flags);
static void bt_regfree __ARGS((regprog_T *prog)); static void bt_regfree(regprog_T *prog);
/* /*
* bt_regcomp() - compile a regular expression into internal code for the * bt_regcomp() - compile a regular expression into internal code for the
@ -3079,19 +3079,19 @@ typedef struct regbehind_S {
save_se_T save_end[NSUBEXP]; save_se_T save_end[NSUBEXP];
} regbehind_T; } regbehind_T;
static char_u *reg_getline __ARGS((linenr_T lnum)); static char_u *reg_getline(linenr_T lnum);
static long bt_regexec_both __ARGS((char_u *line, colnr_T col, proftime_T *tm)); static long bt_regexec_both(char_u *line, colnr_T col, proftime_T *tm);
static long regtry __ARGS((bt_regprog_T *prog, colnr_T col)); static long regtry(bt_regprog_T *prog, colnr_T col);
static void cleanup_subexpr __ARGS((void)); static void cleanup_subexpr(void);
static void cleanup_zsubexpr __ARGS((void)); static void cleanup_zsubexpr(void);
static void save_subexpr __ARGS((regbehind_T *bp)); static void save_subexpr(regbehind_T *bp);
static void restore_subexpr __ARGS((regbehind_T *bp)); static void restore_subexpr(regbehind_T *bp);
static void reg_nextline __ARGS((void)); static void reg_nextline(void);
static void reg_save __ARGS((regsave_T *save, garray_T *gap)); static void reg_save(regsave_T *save, garray_T *gap);
static void reg_restore __ARGS((regsave_T *save, garray_T *gap)); static void reg_restore(regsave_T *save, garray_T *gap);
static int reg_save_equal __ARGS((regsave_T *save)); static int reg_save_equal(regsave_T *save);
static void save_se_multi __ARGS((save_se_T *savep, lpos_T *posp)); static void save_se_multi(save_se_T *savep, lpos_T *posp);
static void save_se_one __ARGS((save_se_T *savep, char_u **pp)); static void save_se_one(save_se_T *savep, char_u **pp);
/* Save the sub-expressions before attempting a match. */ /* Save the sub-expressions before attempting a match. */
#define save_se(savep, posp, pp) \ #define save_se(savep, posp, pp) \
@ -3104,12 +3104,12 @@ static void save_se_one __ARGS((save_se_T *savep, char_u **pp));
else \ else \
*(pp) = (savep)->se_u.ptr; } *(pp) = (savep)->se_u.ptr; }
static int re_num_cmp __ARGS((long_u val, char_u *scan)); static int re_num_cmp(long_u val, char_u *scan);
static int match_with_backref __ARGS((linenr_T start_lnum, colnr_T start_col, static int match_with_backref(linenr_T start_lnum, colnr_T start_col,
linenr_T end_lnum, colnr_T end_col, linenr_T end_lnum, colnr_T end_col,
int *bytelen)); int *bytelen);
static int regmatch __ARGS((char_u *prog)); static int regmatch(char_u *prog);
static int regrepeat __ARGS((char_u *p, long maxcount)); static int regrepeat(char_u *p, long maxcount);
#ifdef REGEXP_DEBUG #ifdef REGEXP_DEBUG
int regnarrate = 0; int regnarrate = 0;
@ -3205,8 +3205,8 @@ typedef struct regitem_S {
short rs_no; /* submatch nr or BEHIND/NOBEHIND */ short rs_no; /* submatch nr or BEHIND/NOBEHIND */
} regitem_T; } regitem_T;
static regitem_T *regstack_push __ARGS((regstate_T state, char_u *scan)); static regitem_T *regstack_push(regstate_T state, char_u *scan);
static void regstack_pop __ARGS((char_u **scan)); static void regstack_pop(char_u **scan);
/* used for STAR, PLUS and BRACE_SIMPLE matching */ /* used for STAR, PLUS and BRACE_SIMPLE matching */
typedef struct regstar_S { typedef struct regstar_S {
@ -3283,7 +3283,7 @@ static lpos_T reg_endzpos[NSUBEXP]; /* idem, end pos */
/* TRUE if using multi-line regexp. */ /* TRUE if using multi-line regexp. */
#define REG_MULTI (reg_match == NULL) #define REG_MULTI (reg_match == NULL)
static int bt_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); static int bt_regexec(regmatch_T *rmp, char_u *line, colnr_T col);
/* /*
* Match a regexp against a string. * Match a regexp against a string.
@ -3314,7 +3314,7 @@ bt_regexec (
#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \ #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
|| defined(FIND_REPLACE_DIALOG) || defined(PROTO) || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
static int bt_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); static int bt_regexec_nl(regmatch_T *rmp, char_u *line, colnr_T col);
/* /*
* Like vim_regexec(), but consider a "\n" in "line" to be a line break. * Like vim_regexec(), but consider a "\n" in "line" to be a line break.
@ -3339,9 +3339,9 @@ bt_regexec_nl (
} }
#endif #endif
static long bt_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, static long bt_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf,
linenr_T lnum, colnr_T col, linenr_T lnum, colnr_T col,
proftime_T *tm)); proftime_T *tm);
/* /*
* Match a regexp against multiple lines. * Match a regexp against multiple lines.
@ -3567,7 +3567,7 @@ theend:
return retval; return retval;
} }
static reg_extmatch_T *make_extmatch __ARGS((void)); static reg_extmatch_T *make_extmatch(void);
/* /*
* Create a new extmatch and mark it as referenced once. * Create a new extmatch and mark it as referenced once.
@ -3668,7 +3668,7 @@ static long regtry(bt_regprog_T *prog, colnr_T col)
return 1 + reglnum; return 1 + reglnum;
} }
static int reg_prev_class __ARGS((void)); static int reg_prev_class(void);
/* /*
* Get class of previous character. * Get class of previous character.
@ -3680,7 +3680,7 @@ static int reg_prev_class(void) {
return -1; return -1;
} }
static int reg_match_visual __ARGS((void)); static int reg_match_visual(void);
/* /*
* Return TRUE if the current reginput position matches the Visual area. * Return TRUE if the current reginput position matches the Visual area.
@ -6177,7 +6177,7 @@ static char_u *regprop(char_u *op)
} }
#endif /* REGEXP_DEBUG */ #endif /* REGEXP_DEBUG */
static void mb_decompose __ARGS((int c, int *c1, int *c2, int *c3)); static void mb_decompose(int c, int *c1, int *c2, int *c3);
typedef struct { typedef struct {
int a, b, c; int a, b, c;
@ -6356,16 +6356,16 @@ static char_u *cstrchr(char_u *s, int c)
* This is impossible, so we declare a pointer to a function returning a * This is impossible, so we declare a pointer to a function returning a
* pointer to a function returning void. This should work for all compilers. * pointer to a function returning void. This should work for all compilers.
*/ */
typedef void (*(*fptr_T)__ARGS((int *, int)))(); typedef void (*(*fptr_T)(int *, int))();
static fptr_T do_upper __ARGS((int *, int)); static fptr_T do_upper(int *, int);
static fptr_T do_Upper __ARGS((int *, int)); static fptr_T do_Upper(int *, int);
static fptr_T do_lower __ARGS((int *, int)); static fptr_T do_lower(int *, int);
static fptr_T do_Lower __ARGS((int *, int)); static fptr_T do_Lower(int *, int);
static int vim_regsub_both __ARGS((char_u *source, char_u *dest, int copy, static int vim_regsub_both(char_u *source, char_u *dest, int copy,
int magic, int magic,
int backslash)); int backslash);
static fptr_T do_upper(d, c) static fptr_T do_upper(d, c)
int *d; int *d;
@ -6815,7 +6815,7 @@ exit:
return (int)((dst - dest) + 1); return (int)((dst - dest) + 1);
} }
static char_u *reg_getline_submatch __ARGS((linenr_T lnum)); static char_u *reg_getline_submatch(linenr_T lnum);
/* /*
* Call reg_getline() with the line numbers from the submatch. If a * Call reg_getline() with the line numbers from the submatch. If a

38
src/regexp.h
View File

@ -1,27 +1,27 @@
#ifndef NEOVIM_REGEXP_H #ifndef NEOVIM_REGEXP_H
#define NEOVIM_REGEXP_H #define NEOVIM_REGEXP_H
/* regexp.c */ /* regexp.c */
int re_multiline __ARGS((regprog_T *prog)); int re_multiline(regprog_T *prog);
int re_lookbehind __ARGS((regprog_T *prog)); int re_lookbehind(regprog_T *prog);
char_u *skip_regexp __ARGS((char_u *startp, int dirc, int magic, char_u **newp)); char_u *skip_regexp(char_u *startp, int dirc, int magic, char_u **newp);
int vim_regcomp_had_eol __ARGS((void)); int vim_regcomp_had_eol(void);
void free_regexp_stuff __ARGS((void)); void free_regexp_stuff(void);
reg_extmatch_T *ref_extmatch __ARGS((reg_extmatch_T *em)); reg_extmatch_T *ref_extmatch(reg_extmatch_T *em);
void unref_extmatch __ARGS((reg_extmatch_T *em)); void unref_extmatch(reg_extmatch_T *em);
char_u *regtilde __ARGS((char_u *source, int magic)); char_u *regtilde(char_u *source, int magic);
int vim_regsub __ARGS((regmatch_T *rmp, char_u *source, char_u *dest, int copy, int vim_regsub(regmatch_T *rmp, char_u *source, char_u *dest, int copy,
int magic, int magic,
int backslash)); int backslash);
int vim_regsub_multi __ARGS((regmmatch_T *rmp, linenr_T lnum, char_u *source, int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source,
char_u *dest, int copy, int magic, char_u *dest, int copy, int magic,
int backslash)); int backslash);
char_u *reg_submatch __ARGS((int no)); char_u *reg_submatch(int no);
regprog_T *vim_regcomp __ARGS((char_u *expr_arg, int re_flags)); regprog_T *vim_regcomp(char_u *expr_arg, int re_flags);
void vim_regfree __ARGS((regprog_T *prog)); void vim_regfree(regprog_T *prog);
int vim_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); int vim_regexec(regmatch_T *rmp, char_u *line, colnr_T col);
int vim_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); int vim_regexec_nl(regmatch_T *rmp, char_u *line, colnr_T col);
long vim_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, long vim_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf,
linenr_T lnum, colnr_T col, linenr_T lnum, colnr_T col,
proftime_T *tm)); proftime_T *tm);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_REGEXP_H */ #endif /* NEOVIM_REGEXP_H */

146
src/regexp_nfa.c
View File

@ -276,48 +276,48 @@ static int nfa_alt_listid;
/* 0 for first call to nfa_regmatch(), 1 for recursive call. */ /* 0 for first call to nfa_regmatch(), 1 for recursive call. */
static int nfa_ll_index = 0; static int nfa_ll_index = 0;
static int nfa_regcomp_start __ARGS((char_u *expr, int re_flags)); static int nfa_regcomp_start(char_u *expr, int re_flags);
static int nfa_get_reganch __ARGS((nfa_state_T *start, int depth)); static int nfa_get_reganch(nfa_state_T *start, int depth);
static int nfa_get_regstart __ARGS((nfa_state_T *start, int depth)); static int nfa_get_regstart(nfa_state_T *start, int depth);
static char_u *nfa_get_match_text __ARGS((nfa_state_T *start)); static char_u *nfa_get_match_text(nfa_state_T *start);
static int realloc_post_list __ARGS((void)); static int realloc_post_list(void);
static int nfa_recognize_char_class __ARGS((char_u *start, char_u *end, static int nfa_recognize_char_class(char_u *start, char_u *end,
int extra_newl)); int extra_newl);
static int nfa_emit_equi_class __ARGS((int c)); static int nfa_emit_equi_class(int c);
static int nfa_regatom __ARGS((void)); static int nfa_regatom(void);
static int nfa_regpiece __ARGS((void)); static int nfa_regpiece(void);
static int nfa_regconcat __ARGS((void)); static int nfa_regconcat(void);
static int nfa_regbranch __ARGS((void)); static int nfa_regbranch(void);
static int nfa_reg __ARGS((int paren)); static int nfa_reg(int paren);
#ifdef REGEXP_DEBUG #ifdef REGEXP_DEBUG
static void nfa_set_code __ARGS((int c)); static void nfa_set_code(int c);
static void nfa_postfix_dump __ARGS((char_u *expr, int retval)); static void nfa_postfix_dump(char_u *expr, int retval);
static void nfa_print_state __ARGS((FILE *debugf, nfa_state_T *state)); static void nfa_print_state(FILE *debugf, nfa_state_T *state);
static void nfa_print_state2 __ARGS((FILE *debugf, nfa_state_T *state, static void nfa_print_state2(FILE *debugf, nfa_state_T *state,
garray_T *indent)); garray_T *indent);
static void nfa_dump __ARGS((nfa_regprog_T *prog)); static void nfa_dump(nfa_regprog_T *prog);
#endif #endif
static int *re2post __ARGS((void)); static int *re2post(void);
static nfa_state_T *alloc_state __ARGS((int c, nfa_state_T *out, static nfa_state_T *alloc_state(int c, nfa_state_T *out,
nfa_state_T *out1)); nfa_state_T *out1);
static void st_error __ARGS((int *postfix, int *end, int *p)); static void st_error(int *postfix, int *end, int *p);
static int nfa_max_width __ARGS((nfa_state_T *startstate, int depth)); static int nfa_max_width(nfa_state_T *startstate, int depth);
static nfa_state_T *post2nfa __ARGS((int *postfix, int *end, int nfa_calc_size)); static nfa_state_T *post2nfa(int *postfix, int *end, int nfa_calc_size);
static void nfa_postprocess __ARGS((nfa_regprog_T *prog)); static void nfa_postprocess(nfa_regprog_T *prog);
static int check_char_class __ARGS((int class, int c)); static int check_char_class(int class, int c);
static void nfa_save_listids __ARGS((nfa_regprog_T *prog, int *list)); static void nfa_save_listids(nfa_regprog_T *prog, int *list);
static void nfa_restore_listids __ARGS((nfa_regprog_T *prog, int *list)); static void nfa_restore_listids(nfa_regprog_T *prog, int *list);
static int nfa_re_num_cmp __ARGS((long_u val, int op, long_u pos)); static int nfa_re_num_cmp(long_u val, int op, long_u pos);
static long nfa_regtry __ARGS((nfa_regprog_T *prog, colnr_T col)); static long nfa_regtry(nfa_regprog_T *prog, colnr_T col);
static long nfa_regexec_both __ARGS((char_u *line, colnr_T col)); static long nfa_regexec_both(char_u *line, colnr_T col);
static regprog_T *nfa_regcomp __ARGS((char_u *expr, int re_flags)); static regprog_T *nfa_regcomp(char_u *expr, int re_flags);
static void nfa_regfree __ARGS((regprog_T *prog)); static void nfa_regfree(regprog_T *prog);
static int nfa_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); static int nfa_regexec(regmatch_T *rmp, char_u *line, colnr_T col);
static long nfa_regexec_multi __ARGS((regmmatch_T *rmp, win_T *win, buf_T *buf, static long nfa_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf,
linenr_T lnum, colnr_T col, linenr_T lnum, colnr_T col,
proftime_T *tm)); proftime_T *tm);
static int match_follows __ARGS((nfa_state_T *startstate, int depth)); static int match_follows(nfa_state_T *startstate, int depth);
static int failure_chance __ARGS((nfa_state_T *state, int depth)); static int failure_chance(nfa_state_T *state, int depth);
/* helper functions used when doing re2post() ... regatom() parsing */ /* helper functions used when doing re2post() ... regatom() parsing */
#define EMIT(c) do { \ #define EMIT(c) do { \
@ -2511,12 +2511,12 @@ struct Frag {
}; };
typedef struct Frag Frag_T; typedef struct Frag Frag_T;
static Frag_T frag __ARGS((nfa_state_T *start, Ptrlist *out)); static Frag_T frag(nfa_state_T *start, Ptrlist *out);
static Ptrlist *list1 __ARGS((nfa_state_T **outp)); static Ptrlist *list1(nfa_state_T **outp);
static void patch __ARGS((Ptrlist *l, nfa_state_T *s)); static void patch(Ptrlist *l, nfa_state_T *s);
static Ptrlist *append __ARGS((Ptrlist *l1, Ptrlist *l2)); static Ptrlist *append(Ptrlist *l1, Ptrlist *l2);
static void st_push __ARGS((Frag_T s, Frag_T **p, Frag_T *stack_end)); static void st_push(Frag_T s, Frag_T **p, Frag_T *stack_end);
static Frag_T st_pop __ARGS((Frag_T **p, Frag_T *stack)); static Frag_T st_pop(Frag_T **p, Frag_T *stack);
/* /*
* Initialize a Frag_T struct and return it. * Initialize a Frag_T struct and return it.
@ -3449,9 +3449,9 @@ typedef struct {
} nfa_list_T; } nfa_list_T;
#ifdef ENABLE_LOG #ifdef ENABLE_LOG
static void log_subsexpr __ARGS((regsubs_T *subs)); static void log_subsexpr(regsubs_T *subs);
static void log_subexpr __ARGS((regsub_T *sub)); static void log_subexpr(regsub_T *sub);
static char *pim_info __ARGS((nfa_pim_T *pim)); static char *pim_info(nfa_pim_T *pim);
static void log_subsexpr(regsubs_T *subs) static void log_subsexpr(regsubs_T *subs)
{ {
@ -3501,25 +3501,25 @@ static char *pim_info(nfa_pim_T *pim)
/* Used during execution: whether a match has been found. */ /* Used during execution: whether a match has been found. */
static int nfa_match; static int nfa_match;
static void copy_pim __ARGS((nfa_pim_T *to, nfa_pim_T *from)); static void copy_pim(nfa_pim_T *to, nfa_pim_T *from);
static void clear_sub __ARGS((regsub_T *sub)); static void clear_sub(regsub_T *sub);
static void copy_sub __ARGS((regsub_T *to, regsub_T *from)); static void copy_sub(regsub_T *to, regsub_T *from);
static void copy_sub_off __ARGS((regsub_T *to, regsub_T *from)); static void copy_sub_off(regsub_T *to, regsub_T *from);
static void copy_ze_off __ARGS((regsub_T *to, regsub_T *from)); static void copy_ze_off(regsub_T *to, regsub_T *from);
static int sub_equal __ARGS((regsub_T *sub1, regsub_T *sub2)); static int sub_equal(regsub_T *sub1, regsub_T *sub2);
static int match_backref __ARGS((regsub_T *sub, int subidx, int *bytelen)); static int match_backref(regsub_T *sub, int subidx, int *bytelen);
static int has_state_with_pos __ARGS((nfa_list_T *l, nfa_state_T *state, static int has_state_with_pos(nfa_list_T *l, nfa_state_T *state,
regsubs_T *subs, regsubs_T *subs,
nfa_pim_T *pim)); nfa_pim_T *pim);
static int pim_equal __ARGS((nfa_pim_T *one, nfa_pim_T *two)); static int pim_equal(nfa_pim_T *one, nfa_pim_T *two);
static int state_in_list __ARGS((nfa_list_T *l, nfa_state_T *state, static int state_in_list(nfa_list_T *l, nfa_state_T *state,
regsubs_T *subs)); regsubs_T *subs);
static regsubs_T *addstate __ARGS((nfa_list_T *l, nfa_state_T *state, static regsubs_T *addstate(nfa_list_T *l, nfa_state_T *state,
regsubs_T *subs_arg, nfa_pim_T *pim, regsubs_T *subs_arg, nfa_pim_T *pim,
int off)); int off);
static void addstate_here __ARGS((nfa_list_T *l, nfa_state_T *state, static void addstate_here(nfa_list_T *l, nfa_state_T *state,
regsubs_T *subs, nfa_pim_T *pim, regsubs_T *subs, nfa_pim_T *pim,
int *ip)); int *ip);
/* /*
* Copy postponed invisible match info from "from" to "to". * Copy postponed invisible match info from "from" to "to".
@ -4376,7 +4376,7 @@ retempty:
} }
static int match_zref __ARGS((int subidx, int *bytelen)); static int match_zref(int subidx, int *bytelen);
/* /*
* Check for a match with \z subexpression "subidx". * Check for a match with \z subexpression "subidx".
@ -4446,13 +4446,13 @@ static int nfa_re_num_cmp(long_u val, int op, long_u pos)
return val == pos; return val == pos;
} }
static int recursive_regmatch __ARGS((nfa_state_T *state, nfa_pim_T *pim, static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim,
nfa_regprog_T *prog, regsubs_T *submatch, nfa_regprog_T *prog, regsubs_T *submatch,
regsubs_T *m, regsubs_T *m,
int **listids)); int **listids);
static int nfa_regmatch __ARGS((nfa_regprog_T *prog, nfa_state_T *start, static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start,
regsubs_T *submatch, regsubs_T *submatch,
regsubs_T *m)); regsubs_T *m);
/* /*
* Recursively call nfa_regmatch() * Recursively call nfa_regmatch()
@ -4599,9 +4599,9 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
return result; return result;
} }
static int skip_to_start __ARGS((int c, colnr_T *colp)); static int skip_to_start(int c, colnr_T *colp);
static long find_match_text __ARGS((colnr_T startcol, int regstart, static long find_match_text(colnr_T startcol, int regstart,
char_u *match_text)); char_u *match_text);
/* /*
* Estimate the chance of a match with "state" failing. * Estimate the chance of a match with "state" failing.
@ -6405,7 +6405,7 @@ nfa_regexec (
#if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \ #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) \
|| defined(FIND_REPLACE_DIALOG) || defined(PROTO) || defined(FIND_REPLACE_DIALOG) || defined(PROTO)
static int nfa_regexec_nl __ARGS((regmatch_T *rmp, char_u *line, colnr_T col)); static int nfa_regexec_nl(regmatch_T *rmp, char_u *line, colnr_T col);
/* /*
* Like nfa_regexec(), but consider a "\n" in "line" to be a line break. * Like nfa_regexec(), but consider a "\n" in "line" to be a line break.

84
src/screen.c
View File

@ -144,48 +144,48 @@ static foldinfo_T win_foldinfo; /* info for 'foldcolumn' */
*/ */
static schar_T *current_ScreenLine; static schar_T *current_ScreenLine;
static void win_update __ARGS((win_T *wp)); static void win_update(win_T *wp);
static void win_draw_end __ARGS((win_T *wp, int c1, int c2, int row, int endrow, static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow,
hlf_T hl)); hlf_T hl);
static void fold_line __ARGS((win_T *wp, long fold_count, foldinfo_T *foldinfo, static void fold_line(win_T *wp, long fold_count, foldinfo_T *foldinfo,
linenr_T lnum, linenr_T lnum,
int row)); int row);
static void fill_foldcolumn __ARGS((char_u *p, win_T *wp, int closed, static void fill_foldcolumn(char_u *p, win_T *wp, int closed,
linenr_T lnum)); linenr_T lnum);
static void copy_text_attr __ARGS((int off, char_u *buf, int len, int attr)); static void copy_text_attr(int off, char_u *buf, int len, int attr);
static int win_line __ARGS((win_T *, linenr_T, int, int, int nochange)); static int win_line(win_T *, linenr_T, int, int, int nochange);
static int char_needs_redraw __ARGS((int off_from, int off_to, int cols)); static int char_needs_redraw(int off_from, int off_to, int cols);
static void screen_line __ARGS((int row, int coloff, int endcol, static void screen_line(int row, int coloff, int endcol,
int clear_width, int clear_width,
int rlflag)); int rlflag);
# define SCREEN_LINE(r, o, e, c, rl) screen_line((r), (o), (e), (c), (rl)) # define SCREEN_LINE(r, o, e, c, rl) screen_line((r), (o), (e), (c), (rl))
static void draw_vsep_win __ARGS((win_T *wp, int row)); static void draw_vsep_win(win_T *wp, int row);
static void redraw_custom_statusline __ARGS((win_T *wp)); static void redraw_custom_statusline(win_T *wp);
#define SEARCH_HL_PRIORITY 0 #define SEARCH_HL_PRIORITY 0
static void start_search_hl __ARGS((void)); static void start_search_hl(void);
static void end_search_hl __ARGS((void)); static void end_search_hl(void);
static void init_search_hl __ARGS((win_T *wp)); static void init_search_hl(win_T *wp);
static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum)); static void prepare_search_hl(win_T *wp, linenr_T lnum);
static void next_search_hl __ARGS((win_T *win, match_T *shl, linenr_T lnum, static void next_search_hl(win_T *win, match_T *shl, linenr_T lnum,
colnr_T mincol)); colnr_T mincol);
static void screen_start_highlight __ARGS((int attr)); static void screen_start_highlight(int attr);
static void screen_char __ARGS((unsigned off, int row, int col)); static void screen_char(unsigned off, int row, int col);
static void screen_char_2 __ARGS((unsigned off, int row, int col)); static void screen_char_2(unsigned off, int row, int col);
static void screenclear2 __ARGS((void)); static void screenclear2(void);
static void lineclear __ARGS((unsigned off, int width)); static void lineclear(unsigned off, int width);
static void lineinvalid __ARGS((unsigned off, int width)); static void lineinvalid(unsigned off, int width);
static void linecopy __ARGS((int to, int from, win_T *wp)); static void linecopy(int to, int from, win_T *wp);
static void redraw_block __ARGS((int row, int end, win_T *wp)); static void redraw_block(int row, int end, win_T *wp);
static int win_do_lines __ARGS((win_T *wp, int row, int line_count, static int win_do_lines(win_T *wp, int row, int line_count,
int mayclear, int mayclear,
int del)); int del);
static void win_rest_invalid __ARGS((win_T *wp)); static void win_rest_invalid(win_T *wp);
static void msg_pos_mode __ARGS((void)); static void msg_pos_mode(void);
static void draw_tabline __ARGS((void)); static void draw_tabline(void);
static int fillchar_status __ARGS((int *attr, int is_curwin)); static int fillchar_status(int *attr, int is_curwin);
static int fillchar_vsep __ARGS((int *attr)); static int fillchar_vsep(int *attr);
static void win_redr_custom __ARGS((win_T *wp, int draw_ruler)); static void win_redr_custom(win_T *wp, int draw_ruler);
static void win_redr_ruler __ARGS((win_T *wp, int always)); static void win_redr_ruler(win_T *wp, int always);
/* Ugly global: overrule attribute used by screen_char() */ /* Ugly global: overrule attribute used by screen_char() */
static int screen_char_attr = 0; static int screen_char_attr = 0;
@ -1704,7 +1704,7 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
set_empty_rows(wp, row); set_empty_rows(wp, row);
} }
static int advance_color_col __ARGS((int vcol, int **color_cols)); static int advance_color_col(int vcol, int **color_cols);
/* /*
* Advance **color_cols and return TRUE when there are columns to draw. * Advance **color_cols and return TRUE when there are columns to draw.
@ -4057,7 +4057,7 @@ win_line (
return row; return row;
} }
static int comp_char_differs __ARGS((int, int)); static int comp_char_differs(int, int);
/* /*
* Return if the composing characters at "off_from" and "off_to" differ. * Return if the composing characters at "off_from" and "off_to" differ.
@ -4458,8 +4458,8 @@ static void draw_vsep_win(win_T *wp, int row)
} }
} }
static int status_match_len __ARGS((expand_T *xp, char_u *s)); static int status_match_len(expand_T *xp, char_u *s);
static int skip_status_match_char __ARGS((expand_T *xp, char_u *s)); static int skip_status_match_char(expand_T *xp, char_u *s);
/* /*
* Get the length of an item as it will be shown in the status line. * Get the length of an item as it will be shown in the status line.
@ -5111,7 +5111,7 @@ void screen_getbytes(int row, int col, char_u *bytes, int *attrp)
} }
} }
static int screen_comp_differs __ARGS((int, int*)); static int screen_comp_differs(int, int*);
/* /*
* Return TRUE if composing characters for screen posn "off" differs from * Return TRUE if composing characters for screen posn "off" differs from

122
src/screen.h
View File

@ -1,69 +1,69 @@
#ifndef NEOVIM_SCREEN_H #ifndef NEOVIM_SCREEN_H
#define NEOVIM_SCREEN_H #define NEOVIM_SCREEN_H
/* screen.c */ /* screen.c */
void redraw_later __ARGS((int type)); void redraw_later(int type);
void redraw_win_later __ARGS((win_T *wp, int type)); void redraw_win_later(win_T *wp, int type);
void redraw_later_clear __ARGS((void)); void redraw_later_clear(void);
void redraw_all_later __ARGS((int type)); void redraw_all_later(int type);
void redraw_curbuf_later __ARGS((int type)); void redraw_curbuf_later(int type);
void redraw_buf_later __ARGS((buf_T *buf, int type)); void redraw_buf_later(buf_T *buf, int type);
int redraw_asap __ARGS((int type)); int redraw_asap(int type);
void redrawWinline __ARGS((linenr_T lnum, int invalid)); void redrawWinline(linenr_T lnum, int invalid);
void update_curbuf __ARGS((int type)); void update_curbuf(int type);
void update_screen __ARGS((int type)); void update_screen(int type);
int conceal_cursor_line __ARGS((win_T *wp)); int conceal_cursor_line(win_T *wp);
void conceal_check_cursur_line __ARGS((void)); void conceal_check_cursur_line(void);
void update_single_line __ARGS((win_T *wp, linenr_T lnum)); void update_single_line(win_T *wp, linenr_T lnum);
void update_debug_sign __ARGS((buf_T *buf, linenr_T lnum)); void update_debug_sign(buf_T *buf, linenr_T lnum);
void updateWindow __ARGS((win_T *wp)); void updateWindow(win_T *wp);
void rl_mirror __ARGS((char_u *str)); void rl_mirror(char_u *str);
void status_redraw_all __ARGS((void)); void status_redraw_all(void);
void status_redraw_curbuf __ARGS((void)); void status_redraw_curbuf(void);
void redraw_statuslines __ARGS((void)); void redraw_statuslines(void);
void win_redraw_last_status __ARGS((frame_T *frp)); void win_redraw_last_status(frame_T *frp);
void win_redr_status_matches __ARGS((expand_T *xp, int num_matches, char_u * void win_redr_status_matches(expand_T *xp, int num_matches, char_u *
*matches, int match, *matches, int match,
int showtail)); int showtail);
void win_redr_status __ARGS((win_T *wp)); void win_redr_status(win_T *wp);
int stl_connected __ARGS((win_T *wp)); int stl_connected(win_T *wp);
int get_keymap_str __ARGS((win_T *wp, char_u *buf, int len)); int get_keymap_str(win_T *wp, char_u *buf, int len);
void screen_putchar __ARGS((int c, int row, int col, int attr)); void screen_putchar(int c, int row, int col, int attr);
void screen_getbytes __ARGS((int row, int col, char_u *bytes, int *attrp)); void screen_getbytes(int row, int col, char_u *bytes, int *attrp);
void screen_puts __ARGS((char_u *text, int row, int col, int attr)); void screen_puts(char_u *text, int row, int col, int attr);
void screen_puts_len __ARGS((char_u *text, int len, int row, int col, int attr)); void screen_puts_len(char_u *text, int len, int row, int col, int attr);
void screen_stop_highlight __ARGS((void)); void screen_stop_highlight(void);
void reset_cterm_colors __ARGS((void)); void reset_cterm_colors(void);
void screen_draw_rectangle __ARGS((int row, int col, int height, int width, void screen_draw_rectangle(int row, int col, int height, int width,
int invert)); int invert);
void screen_fill __ARGS((int start_row, int end_row, int start_col, int end_col, void screen_fill(int start_row, int end_row, int start_col, int end_col,
int c1, int c2, int c1, int c2,
int attr)); int attr);
void check_for_delay __ARGS((int check_msg_scroll)); void check_for_delay(int check_msg_scroll);
int screen_valid __ARGS((int doclear)); int screen_valid(int doclear);
void screenalloc __ARGS((int doclear)); void screenalloc(int doclear);
void free_screenlines __ARGS((void)); void free_screenlines(void);
void screenclear __ARGS((void)); void screenclear(void);
int can_clear __ARGS((char_u *p)); int can_clear(char_u *p);
void screen_start __ARGS((void)); void screen_start(void);
void windgoto __ARGS((int row, int col)); void windgoto(int row, int col);
void setcursor __ARGS((void)); void setcursor(void);
int win_ins_lines __ARGS((win_T *wp, int row, int line_count, int invalid, int win_ins_lines(win_T *wp, int row, int line_count, int invalid,
int mayclear)); int mayclear);
int win_del_lines __ARGS((win_T *wp, int row, int line_count, int invalid, int win_del_lines(win_T *wp, int row, int line_count, int invalid,
int mayclear)); int mayclear);
int screen_ins_lines __ARGS((int off, int row, int line_count, int end, int screen_ins_lines(int off, int row, int line_count, int end,
win_T *wp)); win_T *wp);
int screen_del_lines __ARGS((int off, int row, int line_count, int end, int screen_del_lines(int off, int row, int line_count, int end,
int force, int force,
win_T *wp)); win_T *wp);
int showmode __ARGS((void)); int showmode(void);
void unshowmode __ARGS((int force)); void unshowmode(int force);
void get_trans_bufname __ARGS((buf_T *buf)); void get_trans_bufname(buf_T *buf);
int redrawing __ARGS((void)); int redrawing(void);
int messaging __ARGS((void)); int messaging(void);
void showruler __ARGS((int always)); void showruler(int always);
int number_width __ARGS((win_T *wp)); int number_width(win_T *wp);
int screen_screencol __ARGS((void)); int screen_screencol(void);
int screen_screenrow __ARGS((void)); int screen_screenrow(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_SCREEN_H */ #endif /* NEOVIM_SCREEN_H */

42
src/search.c
View File

@ -37,20 +37,20 @@
#include "ui.h" #include "ui.h"
#include "window.h" #include "window.h"
static void save_re_pat __ARGS((int idx, char_u *pat, int magic)); static void save_re_pat(int idx, char_u *pat, int magic);
static void set_vv_searchforward __ARGS((void)); static void set_vv_searchforward(void);
static int first_submatch __ARGS((regmmatch_T *rp)); static int first_submatch(regmmatch_T *rp);
static int check_prevcol __ARGS((char_u *linep, int col, int ch, int *prevcol)); static int check_prevcol(char_u *linep, int col, int ch, int *prevcol);
static int inmacro __ARGS((char_u *, char_u *)); static int inmacro(char_u *, char_u *);
static int check_linecomment __ARGS((char_u *line)); static int check_linecomment(char_u *line);
static int cls __ARGS((void)); static int cls(void);
static int skip_chars __ARGS((int, int)); static int skip_chars(int, int);
static void back_in_line __ARGS((void)); static void back_in_line(void);
static void find_first_blank __ARGS((pos_T *)); static void find_first_blank(pos_T *);
static void findsent_forward __ARGS((long count, int at_start_sent)); static void findsent_forward(long count, int at_start_sent);
static void show_pat_in_path __ARGS((char_u *, int, static void show_pat_in_path(char_u *, int,
int, int, FILE *, linenr_T *, long)); int, int, FILE *, linenr_T *, long);
static void wvsp_one __ARGS((FILE *fp, int idx, char *s, int sc)); static void wvsp_one(FILE *fp, int idx, char *s, int sc);
/* /*
* This file contains various searching-related routines. These fall into * This file contains various searching-related routines. These fall into
@ -2088,7 +2088,7 @@ int findsent(int dir, long count)
{ {
pos_T pos, tpos; pos_T pos, tpos;
int c; int c;
int (*func)__ARGS((pos_T *)); int (*func)(pos_T *);
int startlnum; int startlnum;
int noskip = FALSE; /* do not skip blanks */ int noskip = FALSE; /* do not skip blanks */
int cpo_J; int cpo_J;
@ -3091,7 +3091,7 @@ current_block (
return OK; return OK;
} }
static int in_html_tag __ARGS((int)); static int in_html_tag(int);
/* /*
* Return TRUE if the cursor is on a "<aaa>" tag. Ignore "<aaa/>". * Return TRUE if the cursor is on a "<aaa>" tag. Ignore "<aaa/>".
@ -3492,10 +3492,10 @@ extend:
return OK; return OK;
} }
static int find_next_quote __ARGS((char_u *top_ptr, int col, int quotechar, static int find_next_quote(char_u *top_ptr, int col, int quotechar,
char_u *escape)); char_u *escape);
static int find_prev_quote __ARGS((char_u *line, int col_start, int quotechar, static int find_prev_quote(char_u *line, int col_start, int quotechar,
char_u *escape)); char_u *escape);
/* /*
* Search quote char from string line[col]. * Search quote char from string line[col].
@ -3772,7 +3772,7 @@ current_quote (
} }
static int is_one_char __ARGS((char_u *pattern)); static int is_one_char(char_u *pattern);
/* /*
* Find next search match under cursor, cursor at end. * Find next search match under cursor, cursor at end.

86
src/search.h
View File

@ -1,52 +1,52 @@
#ifndef NEOVIM_SEARCH_H #ifndef NEOVIM_SEARCH_H
#define NEOVIM_SEARCH_H #define NEOVIM_SEARCH_H
/* search.c */ /* search.c */
int search_regcomp __ARGS((char_u *pat, int pat_save, int pat_use, int options, int search_regcomp(char_u *pat, int pat_save, int pat_use, int options,
regmmatch_T *regmatch)); regmmatch_T *regmatch);
char_u *get_search_pat __ARGS((void)); char_u *get_search_pat(void);
char_u *reverse_text __ARGS((char_u *s)); char_u *reverse_text(char_u *s);
void save_search_patterns __ARGS((void)); void save_search_patterns(void);
void restore_search_patterns __ARGS((void)); void restore_search_patterns(void);
void free_search_patterns __ARGS((void)); void free_search_patterns(void);
int ignorecase __ARGS((char_u *pat)); int ignorecase(char_u *pat);
int pat_has_uppercase __ARGS((char_u *pat)); int pat_has_uppercase(char_u *pat);
char_u *last_search_pat __ARGS((void)); char_u *last_search_pat(void);
void reset_search_dir __ARGS((void)); void reset_search_dir(void);
void set_last_search_pat __ARGS((char_u *s, int idx, int magic, int setlast)); void set_last_search_pat(char_u *s, int idx, int magic, int setlast);
void last_pat_prog __ARGS((regmmatch_T *regmatch)); void last_pat_prog(regmmatch_T *regmatch);
int searchit __ARGS((win_T *win, buf_T *buf, pos_T *pos, int dir, char_u *pat, int searchit(win_T *win, buf_T *buf, pos_T *pos, int dir, char_u *pat,
long count, int options, int pat_use, linenr_T stop_lnum, long count, int options, int pat_use, linenr_T stop_lnum,
proftime_T *tm)); proftime_T *tm);
void set_search_direction __ARGS((int cdir)); void set_search_direction(int cdir);
int do_search __ARGS((oparg_T *oap, int dirc, char_u *pat, long count, int do_search(oparg_T *oap, int dirc, char_u *pat, long count,
int options, int options,
proftime_T *tm)); proftime_T *tm);
int search_for_exact_line __ARGS((buf_T *buf, pos_T *pos, int dir, char_u *pat)); int search_for_exact_line(buf_T *buf, pos_T *pos, int dir, char_u *pat);
int searchc __ARGS((cmdarg_T *cap, int t_cmd)); int searchc(cmdarg_T *cap, int t_cmd);
pos_T *findmatch __ARGS((oparg_T *oap, int initc)); pos_T *findmatch(oparg_T *oap, int initc);
pos_T *findmatchlimit __ARGS((oparg_T *oap, int initc, int flags, int maxtravel)); pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int maxtravel);
void showmatch __ARGS((int c)); void showmatch(int c);
int findsent __ARGS((int dir, long count)); int findsent(int dir, long count);
int findpar __ARGS((int *pincl, int dir, long count, int what, int both)); int findpar(int *pincl, int dir, long count, int what, int both);
int startPS __ARGS((linenr_T lnum, int para, int both)); int startPS(linenr_T lnum, int para, int both);
int fwd_word __ARGS((long count, int bigword, int eol)); int fwd_word(long count, int bigword, int eol);
int bck_word __ARGS((long count, int bigword, int stop)); int bck_word(long count, int bigword, int stop);
int end_word __ARGS((long count, int bigword, int stop, int empty)); int end_word(long count, int bigword, int stop, int empty);
int bckend_word __ARGS((long count, int bigword, int eol)); int bckend_word(long count, int bigword, int eol);
int current_word __ARGS((oparg_T *oap, long count, int include, int bigword)); int current_word(oparg_T *oap, long count, int include, int bigword);
int current_sent __ARGS((oparg_T *oap, long count, int include)); int current_sent(oparg_T *oap, long count, int include);
int current_block __ARGS((oparg_T *oap, long count, int include, int what, int current_block(oparg_T *oap, long count, int include, int what,
int other)); int other);
int current_tagblock __ARGS((oparg_T *oap, long count_arg, int include)); int current_tagblock(oparg_T *oap, long count_arg, int include);
int current_par __ARGS((oparg_T *oap, long count, int include, int type)); int current_par(oparg_T *oap, long count, int include, int type);
int current_quote __ARGS((oparg_T *oap, long count, int include, int quotechar)); int current_quote(oparg_T *oap, long count, int include, int quotechar);
int current_search __ARGS((long count, int forward)); int current_search(long count, int forward);
int linewhite __ARGS((linenr_T lnum)); int linewhite(linenr_T lnum);
void find_pattern_in_path __ARGS((char_u *ptr, int dir, int len, int whole, void find_pattern_in_path(char_u *ptr, int dir, int len, int whole,
int skip_comments, int type, long count, int skip_comments, int type, long count,
int action, linenr_T start_lnum, int action, linenr_T start_lnum,
linenr_T end_lnum)); linenr_T end_lnum);
int read_viminfo_search_pattern __ARGS((vir_T *virp, int force)); int read_viminfo_search_pattern(vir_T *virp, int force);
void write_viminfo_search_pattern __ARGS((FILE *fp)); void write_viminfo_search_pattern(FILE *fp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_SEARCH_H */ #endif /* NEOVIM_SEARCH_H */

4
src/sha256.c
View File

@ -23,7 +23,7 @@
#include "vim.h" #include "vim.h"
#include "sha256.h" #include "sha256.h"
static void sha256_process __ARGS((context_sha256_T *ctx, char_u data[64])); static void sha256_process(context_sha256_T *ctx, char_u data[64]);
#define GET_UINT32(n, b, i) \ #define GET_UINT32(n, b, i) \
{ \ { \
@ -256,7 +256,7 @@ void sha256_finish(context_sha256_T *ctx, char_u digest[32])
PUT_UINT32(ctx->state[7], digest, 28); PUT_UINT32(ctx->state[7], digest, 28);
} }
static unsigned int get_some_time __ARGS((void)); static unsigned int get_some_time(void);
/* /*
* Returns hex digest of "buf[buf_len]" in a static array. * Returns hex digest of "buf[buf_len]" in a static array.

20
src/sha256.h
View File

@ -1,15 +1,15 @@
#ifndef NEOVIM_SHA256_H #ifndef NEOVIM_SHA256_H
#define NEOVIM_SHA256_H #define NEOVIM_SHA256_H
/* sha256.c */ /* sha256.c */
void sha256_start __ARGS((context_sha256_T *ctx)); void sha256_start(context_sha256_T *ctx);
void sha256_update __ARGS((context_sha256_T *ctx, char_u *input, void sha256_update(context_sha256_T *ctx, char_u *input,
UINT32_T length)); UINT32_T length);
void sha256_finish __ARGS((context_sha256_T *ctx, char_u digest[32])); void sha256_finish(context_sha256_T *ctx, char_u digest[32]);
char_u *sha256_bytes __ARGS((char_u *buf, int buf_len, char_u *salt, char_u *sha256_bytes(char_u *buf, int buf_len, char_u *salt,
int salt_len)); int salt_len);
char_u *sha256_key __ARGS((char_u *buf, char_u *salt, int salt_len)); char_u *sha256_key(char_u *buf, char_u *salt, int salt_len);
int sha256_self_test __ARGS((void)); int sha256_self_test(void);
void sha2_seed __ARGS((char_u *header, int header_len, char_u *salt, void sha2_seed(char_u *header, int header_len, char_u *salt,
int salt_len)); int salt_len);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_SHA256_H */ #endif /* NEOVIM_SHA256_H */

380
src/spell.c
View File

@ -742,13 +742,13 @@ static int did_set_spelltab;
#define CF_WORD 0x01 #define CF_WORD 0x01
#define CF_UPPER 0x02 #define CF_UPPER 0x02
static void clear_spell_chartab __ARGS((spelltab_T *sp)); static void clear_spell_chartab(spelltab_T *sp);
static int set_spell_finish __ARGS((spelltab_T *new_st)); static int set_spell_finish(spelltab_T *new_st);
static int spell_iswordp __ARGS((char_u *p, win_T *wp)); static int spell_iswordp(char_u *p, win_T *wp);
static int spell_iswordp_nmw __ARGS((char_u *p, win_T *wp)); static int spell_iswordp_nmw(char_u *p, win_T *wp);
static int spell_mb_isword_class __ARGS((int cl, win_T *wp)); static int spell_mb_isword_class(int cl, win_T *wp);
static int spell_iswordp_w __ARGS((int *p, win_T *wp)); static int spell_iswordp_w(int *p, win_T *wp);
static int write_spell_prefcond __ARGS((FILE *fd, garray_T *gap)); static int write_spell_prefcond(FILE *fd, garray_T *gap);
/* /*
* For finding suggestions: At each node in the tree these states are tried: * For finding suggestions: At each node in the tree these states are tried:
@ -826,135 +826,133 @@ typedef struct trystate_S {
#define FIND_COMPOUND 3 /* find case-folded compound word */ #define FIND_COMPOUND 3 /* find case-folded compound word */
#define FIND_KEEPCOMPOUND 4 /* find keep-case compound word */ #define FIND_KEEPCOMPOUND 4 /* find keep-case compound word */
static slang_T *slang_alloc __ARGS((char_u *lang)); static slang_T *slang_alloc(char_u *lang);
static void slang_free __ARGS((slang_T *lp)); static void slang_free(slang_T *lp);
static void slang_clear __ARGS((slang_T *lp)); static void slang_clear(slang_T *lp);
static void slang_clear_sug __ARGS((slang_T *lp)); static void slang_clear_sug(slang_T *lp);
static void find_word __ARGS((matchinf_T *mip, int mode)); static void find_word(matchinf_T *mip, int mode);
static int match_checkcompoundpattern __ARGS((char_u *ptr, int wlen, static int match_checkcompoundpattern(char_u *ptr, int wlen,
garray_T *gap)); garray_T *gap);
static int can_compound __ARGS((slang_T *slang, char_u *word, char_u *flags)); static int can_compound(slang_T *slang, char_u *word, char_u *flags);
static int can_be_compound __ARGS((trystate_T *sp, slang_T *slang, char_u * static int can_be_compound(trystate_T *sp, slang_T *slang, char_u *compflags,
compflags, int flag);
int flag)); static int match_compoundrule(slang_T *slang, char_u *compflags);
static int match_compoundrule __ARGS((slang_T *slang, char_u *compflags)); static int valid_word_prefix(int totprefcnt, int arridx, int flags,
static int valid_word_prefix __ARGS((int totprefcnt, int arridx, int flags,
char_u *word, slang_T *slang, char_u *word, slang_T *slang,
int cond_req)); int cond_req);
static void find_prefix __ARGS((matchinf_T *mip, int mode)); static void find_prefix(matchinf_T *mip, int mode);
static int fold_more __ARGS((matchinf_T *mip)); static int fold_more(matchinf_T *mip);
static int spell_valid_case __ARGS((int wordflags, int treeflags)); static int spell_valid_case(int wordflags, int treeflags);
static int no_spell_checking __ARGS((win_T *wp)); static int no_spell_checking(win_T *wp);
static void spell_load_lang __ARGS((char_u *lang)); static void spell_load_lang(char_u *lang);
static char_u *spell_enc __ARGS((void)); static char_u *spell_enc(void);
static void int_wordlist_spl __ARGS((char_u *fname)); static void int_wordlist_spl(char_u *fname);
static void spell_load_cb __ARGS((char_u *fname, void *cookie)); static void spell_load_cb(char_u *fname, void *cookie);
static slang_T *spell_load_file __ARGS((char_u *fname, char_u *lang, slang_T * static slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp,
old_lp, int silent);
int silent)); static char_u *read_cnt_string(FILE *fd, int cnt_bytes, int *lenp);
static char_u *read_cnt_string __ARGS((FILE *fd, int cnt_bytes, int *lenp)); static int read_region_section(FILE *fd, slang_T *slang, int len);
static int read_region_section __ARGS((FILE *fd, slang_T *slang, int len)); static int read_charflags_section(FILE *fd);
static int read_charflags_section __ARGS((FILE *fd)); static int read_prefcond_section(FILE *fd, slang_T *lp);
static int read_prefcond_section __ARGS((FILE *fd, slang_T *lp)); static int read_rep_section(FILE *fd, garray_T *gap, short *first);
static int read_rep_section __ARGS((FILE *fd, garray_T *gap, short *first)); static int read_sal_section(FILE *fd, slang_T *slang);
static int read_sal_section __ARGS((FILE *fd, slang_T *slang)); static int read_words_section(FILE *fd, slang_T *lp, int len);
static int read_words_section __ARGS((FILE *fd, slang_T *lp, int len)); static void count_common_word(slang_T *lp, char_u *word, int len,
static void count_common_word __ARGS((slang_T *lp, char_u *word, int len, int count);
int count)); static int score_wordcount_adj(slang_T *slang, int score, char_u *word,
static int score_wordcount_adj __ARGS((slang_T *slang, int score, char_u *word, int split);
int split)); static int read_sofo_section(FILE *fd, slang_T *slang);
static int read_sofo_section __ARGS((FILE *fd, slang_T *slang)); static int read_compound(FILE *fd, slang_T *slang, int len);
static int read_compound __ARGS((FILE *fd, slang_T *slang, int len)); static int byte_in_str(char_u *str, int byte);
static int byte_in_str __ARGS((char_u *str, int byte)); static int init_syl_tab(slang_T *slang);
static int init_syl_tab __ARGS((slang_T *slang)); static int count_syllables(slang_T *slang, char_u *word);
static int count_syllables __ARGS((slang_T *slang, char_u *word)); static int set_sofo(slang_T *lp, char_u *from, char_u *to);
static int set_sofo __ARGS((slang_T *lp, char_u *from, char_u *to)); static void set_sal_first(slang_T *lp);
static void set_sal_first __ARGS((slang_T *lp)); static int *mb_str2wide(char_u *s);
static int *mb_str2wide __ARGS((char_u *s)); static int spell_read_tree(FILE *fd, char_u **bytsp, idx_T **idxsp,
static int spell_read_tree __ARGS((FILE *fd, char_u **bytsp, idx_T **idxsp,
int prefixtree, int prefixtree,
int prefixcnt)); int prefixcnt);
static idx_T read_tree_node __ARGS((FILE *fd, char_u *byts, idx_T *idxs, static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs,
int maxidx, idx_T startidx, int prefixtree, int maxidx, idx_T startidx, int prefixtree,
int maxprefcondnr)); int maxprefcondnr);
static void clear_midword __ARGS((win_T *buf)); static void clear_midword(win_T *buf);
static void use_midword __ARGS((slang_T *lp, win_T *buf)); static void use_midword(slang_T *lp, win_T *buf);
static int find_region __ARGS((char_u *rp, char_u *region)); static int find_region(char_u *rp, char_u *region);
static int captype __ARGS((char_u *word, char_u *end)); static int captype(char_u *word, char_u *end);
static int badword_captype __ARGS((char_u *word, char_u *end)); static int badword_captype(char_u *word, char_u *end);
static void spell_reload_one __ARGS((char_u *fname, int added_word)); static void spell_reload_one(char_u *fname, int added_word);
static void set_spell_charflags __ARGS((char_u *flags, int cnt, char_u *upp)); static void set_spell_charflags(char_u *flags, int cnt, char_u *upp);
static int set_spell_chartab __ARGS((char_u *fol, char_u *low, char_u *upp)); static int set_spell_chartab(char_u *fol, char_u *low, char_u *upp);
static int spell_casefold __ARGS((char_u *p, int len, char_u *buf, int buflen)); static int spell_casefold(char_u *p, int len, char_u *buf, int buflen);
static int check_need_cap __ARGS((linenr_T lnum, colnr_T col)); static int check_need_cap(linenr_T lnum, colnr_T col);
static void spell_find_suggest __ARGS((char_u *badptr, int badlen, suginfo_T * static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su,
su, int maxcount, int banbadword, int maxcount, int banbadword,
int need_cap, int need_cap,
int interactive)); int interactive);
static void spell_suggest_expr __ARGS((suginfo_T *su, char_u *expr)); static void spell_suggest_expr(suginfo_T *su, char_u *expr);
static void spell_suggest_file __ARGS((suginfo_T *su, char_u *fname)); static void spell_suggest_file(suginfo_T *su, char_u *fname);
static void spell_suggest_intern __ARGS((suginfo_T *su, int interactive)); static void spell_suggest_intern(suginfo_T *su, int interactive);
static void suggest_load_files __ARGS((void)); static void suggest_load_files(void);
static void tree_count_words __ARGS((char_u *byts, idx_T *idxs)); static void tree_count_words(char_u *byts, idx_T *idxs);
static void spell_find_cleanup __ARGS((suginfo_T *su)); static void spell_find_cleanup(suginfo_T *su);
static void onecap_copy __ARGS((char_u *word, char_u *wcopy, int upper)); static void onecap_copy(char_u *word, char_u *wcopy, int upper);
static void allcap_copy __ARGS((char_u *word, char_u *wcopy)); static void allcap_copy(char_u *word, char_u *wcopy);
static void suggest_try_special __ARGS((suginfo_T *su)); static void suggest_try_special(suginfo_T *su);
static void suggest_try_change __ARGS((suginfo_T *su)); static void suggest_try_change(suginfo_T *su);
static void suggest_trie_walk __ARGS((suginfo_T *su, langp_T *lp, char_u *fword, static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword,
int soundfold)); int soundfold);
static void go_deeper __ARGS((trystate_T *stack, int depth, int score_add)); static void go_deeper(trystate_T *stack, int depth, int score_add);
static int nofold_len __ARGS((char_u *fword, int flen, char_u *word)); static int nofold_len(char_u *fword, int flen, char_u *word);
static void find_keepcap_word __ARGS((slang_T *slang, char_u *fword, static void find_keepcap_word(slang_T *slang, char_u *fword,
char_u *kword)); char_u *kword);
static void score_comp_sal __ARGS((suginfo_T *su)); static void score_comp_sal(suginfo_T *su);
static void score_combine __ARGS((suginfo_T *su)); static void score_combine(suginfo_T *su);
static int stp_sal_score __ARGS((suggest_T *stp, suginfo_T *su, slang_T *slang, static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang,
char_u *badsound)); char_u *badsound);
static void suggest_try_soundalike_prep __ARGS((void)); static void suggest_try_soundalike_prep(void);
static void suggest_try_soundalike __ARGS((suginfo_T *su)); static void suggest_try_soundalike(suginfo_T *su);
static void suggest_try_soundalike_finish __ARGS((void)); static void suggest_try_soundalike_finish(void);
static void add_sound_suggest __ARGS((suginfo_T *su, char_u *goodword, static void add_sound_suggest(suginfo_T *su, char_u *goodword,
int score, int score,
langp_T *lp)); langp_T *lp);
static int soundfold_find __ARGS((slang_T *slang, char_u *word)); static int soundfold_find(slang_T *slang, char_u *word);
static void make_case_word __ARGS((char_u *fword, char_u *cword, int flags)); static void make_case_word(char_u *fword, char_u *cword, int flags);
static void set_map_str __ARGS((slang_T *lp, char_u *map)); static void set_map_str(slang_T *lp, char_u *map);
static int similar_chars __ARGS((slang_T *slang, int c1, int c2)); static int similar_chars(slang_T *slang, int c1, int c2);
static void add_suggestion __ARGS((suginfo_T *su, garray_T *gap, char_u * static void add_suggestion(suginfo_T *su, garray_T *gap, char_u *goodword,
goodword, int badlen, int score, int badlen, int score,
int altscore, int had_bonus, slang_T *slang, int altscore, int had_bonus, slang_T *slang,
int maxsf)); int maxsf);
static void check_suggestions __ARGS((suginfo_T *su, garray_T *gap)); static void check_suggestions(suginfo_T *su, garray_T *gap);
static void add_banned __ARGS((suginfo_T *su, char_u *word)); static void add_banned(suginfo_T *su, char_u *word);
static void rescore_suggestions __ARGS((suginfo_T *su)); static void rescore_suggestions(suginfo_T *su);
static void rescore_one __ARGS((suginfo_T *su, suggest_T *stp)); static void rescore_one(suginfo_T *su, suggest_T *stp);
static int cleanup_suggestions __ARGS((garray_T *gap, int maxscore, int keep)); static int cleanup_suggestions(garray_T *gap, int maxscore, int keep);
static void spell_soundfold __ARGS((slang_T *slang, char_u *inword, int folded, static void spell_soundfold(slang_T *slang, char_u *inword, int folded,
char_u *res)); char_u *res);
static void spell_soundfold_sofo __ARGS((slang_T *slang, char_u *inword, static void spell_soundfold_sofo(slang_T *slang, char_u *inword,
char_u *res)); char_u *res);
static void spell_soundfold_sal __ARGS((slang_T *slang, char_u *inword, static void spell_soundfold_sal(slang_T *slang, char_u *inword,
char_u *res)); char_u *res);
static void spell_soundfold_wsal __ARGS((slang_T *slang, char_u *inword, static void spell_soundfold_wsal(slang_T *slang, char_u *inword,
char_u *res)); char_u *res);
static int soundalike_score __ARGS((char_u *goodsound, char_u *badsound)); static int soundalike_score(char_u *goodsound, char_u *badsound);
static int spell_edit_score __ARGS((slang_T *slang, char_u *badword, static int spell_edit_score(slang_T *slang, char_u *badword,
char_u *goodword)); char_u *goodword);
static int spell_edit_score_limit __ARGS((slang_T *slang, char_u *badword, static int spell_edit_score_limit(slang_T *slang, char_u *badword,
char_u *goodword, char_u *goodword,
int limit)); int limit);
static int spell_edit_score_limit_w __ARGS((slang_T *slang, char_u *badword, static int spell_edit_score_limit_w(slang_T *slang, char_u *badword,
char_u *goodword, char_u *goodword,
int limit)); int limit);
static void dump_word __ARGS((slang_T *slang, char_u *word, char_u *pat, static void dump_word(slang_T *slang, char_u *word, char_u *pat,
int *dir, int round, int flags, int *dir, int round, int flags,
linenr_T lnum)); linenr_T lnum);
static linenr_T dump_prefixes __ARGS((slang_T *slang, char_u *word, char_u *pat, static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat,
int *dir, int round, int flags, int *dir, int round, int flags,
linenr_T startlnum)); linenr_T startlnum);
static buf_T *open_spellbuf __ARGS((void)); static buf_T *open_spellbuf(void);
static void close_spellbuf __ARGS((buf_T *buf)); static void close_spellbuf(buf_T *buf);
/* /*
* Use our own character-case definitions, because the current locale may * Use our own character-case definitions, because the current locale may
@ -4560,75 +4558,75 @@ typedef struct spellinfo_S {
int si_newcompID; /* current value for compound ID */ int si_newcompID; /* current value for compound ID */
} spellinfo_T; } spellinfo_T;
static afffile_T *spell_read_aff __ARGS((spellinfo_T *spin, char_u *fname)); static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname);
static int is_aff_rule __ARGS((char_u **items, int itemcnt, char *rulename, static int is_aff_rule(char_u **items, int itemcnt, char *rulename,
int mincount)); int mincount);
static void aff_process_flags __ARGS((afffile_T *affile, affentry_T *entry)); static void aff_process_flags(afffile_T *affile, affentry_T *entry);
static int spell_info_item __ARGS((char_u *s)); static int spell_info_item(char_u *s);
static unsigned affitem2flag __ARGS((int flagtype, char_u *item, char_u *fname, static unsigned affitem2flag(int flagtype, char_u *item, char_u *fname,
int lnum)); int lnum);
static unsigned get_affitem __ARGS((int flagtype, char_u **pp)); static unsigned get_affitem(int flagtype, char_u **pp);
static void process_compflags __ARGS((spellinfo_T *spin, afffile_T *aff, static void process_compflags(spellinfo_T *spin, afffile_T *aff,
char_u *compflags)); char_u *compflags);
static void check_renumber __ARGS((spellinfo_T *spin)); static void check_renumber(spellinfo_T *spin);
static int flag_in_afflist __ARGS((int flagtype, char_u *afflist, unsigned flag)); static int flag_in_afflist(int flagtype, char_u *afflist, unsigned flag);
static void aff_check_number __ARGS((int spinval, int affval, char *name)); static void aff_check_number(int spinval, int affval, char *name);
static void aff_check_string __ARGS((char_u *spinval, char_u *affval, static void aff_check_string(char_u *spinval, char_u *affval,
char *name)); char *name);
static int str_equal __ARGS((char_u *s1, char_u *s2)); static int str_equal(char_u *s1, char_u *s2);
static void add_fromto __ARGS((spellinfo_T *spin, garray_T *gap, char_u *from, static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from,
char_u *to)); char_u *to);
static int sal_to_bool __ARGS((char_u *s)); static int sal_to_bool(char_u *s);
static void spell_free_aff __ARGS((afffile_T *aff)); static void spell_free_aff(afffile_T *aff);
static int spell_read_dic __ARGS((spellinfo_T *spin, char_u *fname, static int spell_read_dic(spellinfo_T *spin, char_u *fname,
afffile_T *affile)); afffile_T *affile);
static int get_affix_flags __ARGS((afffile_T *affile, char_u *afflist)); static int get_affix_flags(afffile_T *affile, char_u *afflist);
static int get_pfxlist __ARGS((afffile_T *affile, char_u *afflist, static int get_pfxlist(afffile_T *affile, char_u *afflist,
char_u *store_afflist)); char_u *store_afflist);
static void get_compflags __ARGS((afffile_T *affile, char_u *afflist, static void get_compflags(afffile_T *affile, char_u *afflist,
char_u *store_afflist)); char_u *store_afflist);
static int store_aff_word __ARGS((spellinfo_T *spin, char_u *word, char_u * static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist,
afflist, afffile_T *affile, hashtab_T *ht, afffile_T *affile, hashtab_T *ht,
hashtab_T *xht, int condit, int flags, hashtab_T *xht, int condit, int flags,
char_u *pfxlist, char_u *pfxlist,
int pfxlen)); int pfxlen);
static int spell_read_wordfile __ARGS((spellinfo_T *spin, char_u *fname)); static int spell_read_wordfile(spellinfo_T *spin, char_u *fname);
static void *getroom __ARGS((spellinfo_T *spin, size_t len, int align)); static void *getroom(spellinfo_T *spin, size_t len, int align);
static char_u *getroom_save __ARGS((spellinfo_T *spin, char_u *s)); static char_u *getroom_save(spellinfo_T *spin, char_u *s);
static void free_blocks __ARGS((sblock_T *bl)); static void free_blocks(sblock_T *bl);
static wordnode_T *wordtree_alloc __ARGS((spellinfo_T *spin)); static wordnode_T *wordtree_alloc(spellinfo_T *spin);
static int store_word __ARGS((spellinfo_T *spin, char_u *word, int flags, static int store_word(spellinfo_T *spin, char_u *word, int flags,
int region, char_u *pfxlist, int region, char_u *pfxlist,
int need_affix)); int need_affix);
static int tree_add_word __ARGS((spellinfo_T *spin, char_u *word, wordnode_T * static int tree_add_word(spellinfo_T *spin, char_u *word,
tree, int flags, int region, wordnode_T *tree, int flags, int region,
int affixID)); int affixID);
static wordnode_T *get_wordnode __ARGS((spellinfo_T *spin)); static wordnode_T *get_wordnode(spellinfo_T *spin);
static int deref_wordnode __ARGS((spellinfo_T *spin, wordnode_T *node)); static int deref_wordnode(spellinfo_T *spin, wordnode_T *node);
static void free_wordnode __ARGS((spellinfo_T *spin, wordnode_T *n)); static void free_wordnode(spellinfo_T *spin, wordnode_T *n);
static void wordtree_compress __ARGS((spellinfo_T *spin, wordnode_T *root)); static void wordtree_compress(spellinfo_T *spin, wordnode_T *root);
static int node_compress __ARGS((spellinfo_T *spin, wordnode_T *node, static int node_compress(spellinfo_T *spin, wordnode_T *node,
hashtab_T *ht, hashtab_T *ht,
int *tot)); int *tot);
static int node_equal __ARGS((wordnode_T *n1, wordnode_T *n2)); static int node_equal(wordnode_T *n1, wordnode_T *n2);
static int write_vim_spell __ARGS((spellinfo_T *spin, char_u *fname)); static int write_vim_spell(spellinfo_T *spin, char_u *fname);
static void clear_node __ARGS((wordnode_T *node)); static void clear_node(wordnode_T *node);
static int put_node __ARGS((FILE *fd, wordnode_T *node, int idx, int regionmask, static int put_node(FILE *fd, wordnode_T *node, int idx, int regionmask,
int prefixtree)); int prefixtree);
static void spell_make_sugfile __ARGS((spellinfo_T *spin, char_u *wfname)); static void spell_make_sugfile(spellinfo_T *spin, char_u *wfname);
static int sug_filltree __ARGS((spellinfo_T *spin, slang_T *slang)); static int sug_filltree(spellinfo_T *spin, slang_T *slang);
static int sug_maketable __ARGS((spellinfo_T *spin)); static int sug_maketable(spellinfo_T *spin);
static int sug_filltable __ARGS((spellinfo_T *spin, wordnode_T *node, static int sug_filltable(spellinfo_T *spin, wordnode_T *node,
int startwordnr, int startwordnr,
garray_T *gap)); garray_T *gap);
static int offset2bytes __ARGS((int nr, char_u *buf)); static int offset2bytes(int nr, char_u *buf);
static int bytes2offset __ARGS((char_u **pp)); static int bytes2offset(char_u **pp);
static void sug_write __ARGS((spellinfo_T *spin, char_u *fname)); static void sug_write(spellinfo_T *spin, char_u *fname);
static void mkspell __ARGS((int fcount, char_u **fnames, int ascii, static void mkspell(int fcount, char_u **fnames, int ascii,
int over_write, int over_write,
int added_word)); int added_word);
static void spell_message __ARGS((spellinfo_T *spin, char_u *str)); static void spell_message(spellinfo_T *spin, char_u *str);
static void init_spellfile __ARGS((void)); static void init_spellfile(void);
/* In the postponed prefixes tree wn_flags is used to store the WFP_ flags, /* In the postponed prefixes tree wn_flags is used to store the WFP_ flags,
* but it must be negative to indicate the prefix tree to tree_add_word(). * but it must be negative to indicate the prefix tree to tree_add_word().
@ -7111,7 +7109,7 @@ static int node_equal(wordnode_T *n1, wordnode_T *n2)
} }
static int static int
rep_compare __ARGS((const void *s1, const void *s2)); rep_compare(const void *s1, const void *s2);
/* /*
* Function given to qsort() to sort the REP items on "from" string. * Function given to qsort() to sort the REP items on "from" string.
@ -12417,7 +12415,7 @@ static void rescore_one(suginfo_T *su, suggest_T *stp)
} }
static int static int
sug_compare __ARGS((const void *s1, const void *s2)); sug_compare(const void *s1, const void *s2);
/* /*
* Function given to qsort() to sort the suggestions on st_score. * Function given to qsort() to sort the suggestions on st_score.

54
src/spell.h
View File

@ -1,33 +1,33 @@
#ifndef NEOVIM_SPELL_H #ifndef NEOVIM_SPELL_H
#define NEOVIM_SPELL_H #define NEOVIM_SPELL_H
/* spell.c */ /* spell.c */
int spell_check __ARGS((win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, int spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol,
int docount)); int docount);
int spell_move_to __ARGS((win_T *wp, int dir, int allwords, int curline, int spell_move_to(win_T *wp, int dir, int allwords, int curline,
hlf_T *attrp)); hlf_T *attrp);
void spell_cat_line __ARGS((char_u *buf, char_u *line, int maxlen)); void spell_cat_line(char_u *buf, char_u *line, int maxlen);
char_u *did_set_spelllang __ARGS((win_T *wp)); char_u *did_set_spelllang(win_T *wp);
void spell_delete_wordlist __ARGS((void)); void spell_delete_wordlist(void);
void spell_free_all __ARGS((void)); void spell_free_all(void);
void spell_reload __ARGS((void)); void spell_reload(void);
int spell_check_msm __ARGS((void)); int spell_check_msm(void);
void ex_mkspell __ARGS((exarg_T *eap)); void ex_mkspell(exarg_T *eap);
void ex_spell __ARGS((exarg_T *eap)); void ex_spell(exarg_T *eap);
void spell_add_word __ARGS((char_u *word, int len, int bad, int idx, int undo)); void spell_add_word(char_u *word, int len, int bad, int idx, int undo);
void init_spell_chartab __ARGS((void)); void init_spell_chartab(void);
int spell_check_sps __ARGS((void)); int spell_check_sps(void);
void spell_suggest __ARGS((int count)); void spell_suggest(int count);
void ex_spellrepall __ARGS((exarg_T *eap)); void ex_spellrepall(exarg_T *eap);
void spell_suggest_list __ARGS((garray_T *gap, char_u *word, int maxcount, void spell_suggest_list(garray_T *gap, char_u *word, int maxcount,
int need_cap, int need_cap,
int interactive)); int interactive);
char_u *eval_soundfold __ARGS((char_u *word)); char_u *eval_soundfold(char_u *word);
void ex_spellinfo __ARGS((exarg_T *eap)); void ex_spellinfo(exarg_T *eap);
void ex_spelldump __ARGS((exarg_T *eap)); void ex_spelldump(exarg_T *eap);
void spell_dump_compl __ARGS((char_u *pat, int ic, int *dir, int dumpflags_arg)); void spell_dump_compl(char_u *pat, int ic, int *dir, int dumpflags_arg);
char_u *spell_to_word_end __ARGS((char_u *start, win_T *win)); char_u *spell_to_word_end(char_u *start, win_T *win);
int spell_word_start __ARGS((int startcol)); int spell_word_start(int startcol);
void spell_expand_check_cap __ARGS((colnr_T col)); void spell_expand_check_cap(colnr_T col);
int expand_spelling __ARGS((linenr_T lnum, char_u *pat, char_u ***matchp)); int expand_spelling(linenr_T lnum, char_u *pat, char_u ***matchp);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_SPELL_H */ #endif /* NEOVIM_SPELL_H */

223
src/syntax.c
View File

@ -90,17 +90,17 @@ static int hl_attr_table[] =
{HL_BOLD, HL_STANDOUT, HL_UNDERLINE, HL_UNDERCURL, HL_ITALIC, HL_INVERSE, {HL_BOLD, HL_STANDOUT, HL_UNDERLINE, HL_UNDERCURL, HL_ITALIC, HL_INVERSE,
HL_INVERSE, 0}; HL_INVERSE, 0};
static int get_attr_entry __ARGS((garray_T *table, attrentry_T *aep)); static int get_attr_entry(garray_T *table, attrentry_T *aep);
static void syn_unadd_group __ARGS((void)); static void syn_unadd_group(void);
static void set_hl_attr __ARGS((int idx)); static void set_hl_attr(int idx);
static void highlight_list_one __ARGS((int id)); static void highlight_list_one(int id);
static int highlight_list_arg __ARGS((int id, int didh, int type, int iarg, static int highlight_list_arg(int id, int didh, int type, int iarg,
char_u *sarg, char_u *sarg,
char *name)); char *name);
static int syn_add_group __ARGS((char_u *name)); static int syn_add_group(char_u *name);
static int syn_list_header __ARGS((int did_header, int outlen, int id)); static int syn_list_header(int did_header, int outlen, int id);
static int hl_has_settings __ARGS((int idx, int check_link)); static int hl_has_settings(int idx, int check_link);
static void highlight_clear __ARGS((int idx)); static void highlight_clear(int idx);
/* /*
@ -353,114 +353,113 @@ static int current_line_id = 0; /* unique number for current line */
#define CUR_STATE(idx) ((stateitem_T *)(current_state.ga_data))[idx] #define CUR_STATE(idx) ((stateitem_T *)(current_state.ga_data))[idx]
static void syn_sync __ARGS((win_T *wp, linenr_T lnum, synstate_T *last_valid)); static void syn_sync(win_T *wp, linenr_T lnum, synstate_T *last_valid);
static int syn_match_linecont __ARGS((linenr_T lnum)); static int syn_match_linecont(linenr_T lnum);
static void syn_start_line __ARGS((void)); static void syn_start_line(void);
static void syn_update_ends __ARGS((int startofline)); static void syn_update_ends(int startofline);
static void syn_stack_alloc __ARGS((void)); static void syn_stack_alloc(void);
static int syn_stack_cleanup __ARGS((void)); static int syn_stack_cleanup(void);
static void syn_stack_free_entry __ARGS((synblock_T *block, synstate_T *p)); static void syn_stack_free_entry(synblock_T *block, synstate_T *p);
static synstate_T *syn_stack_find_entry __ARGS((linenr_T lnum)); static synstate_T *syn_stack_find_entry(linenr_T lnum);
static synstate_T *store_current_state __ARGS((void)); static synstate_T *store_current_state(void);
static void load_current_state __ARGS((synstate_T *from)); static void load_current_state(synstate_T *from);
static void invalidate_current_state __ARGS((void)); static void invalidate_current_state(void);
static int syn_stack_equal __ARGS((synstate_T *sp)); static int syn_stack_equal(synstate_T *sp);
static void validate_current_state __ARGS((void)); static void validate_current_state(void);
static int syn_finish_line __ARGS((int syncing)); static int syn_finish_line(int syncing);
static int syn_current_attr __ARGS((int syncing, int displaying, int *can_spell, static int syn_current_attr(int syncing, int displaying, int *can_spell,
int keep_state)); int keep_state);
static int did_match_already __ARGS((int idx, garray_T *gap)); static int did_match_already(int idx, garray_T *gap);
static stateitem_T *push_next_match __ARGS((stateitem_T *cur_si)); static stateitem_T *push_next_match(stateitem_T *cur_si);
static void check_state_ends __ARGS((void)); static void check_state_ends(void);
static void update_si_attr __ARGS((int idx)); static void update_si_attr(int idx);
static void check_keepend __ARGS((void)); static void check_keepend(void);
static void update_si_end __ARGS((stateitem_T *sip, int startcol, int force)); static void update_si_end(stateitem_T *sip, int startcol, int force);
static short *copy_id_list __ARGS((short *list)); static short *copy_id_list(short *list);
static int in_id_list __ARGS((stateitem_T *item, short *cont_list, static int in_id_list(stateitem_T *item, short *cont_list,
struct sp_syn *ssp, struct sp_syn *ssp,
int contained)); int contained);
static int push_current_state __ARGS((int idx)); static int push_current_state(int idx);
static void pop_current_state __ARGS((void)); static void pop_current_state(void);
static void syn_clear_time __ARGS((syn_time_T *tt)); static void syn_clear_time(syn_time_T *tt);
static void syntime_clear __ARGS((void)); static void syntime_clear(void);
static int syn_compare_syntime __ARGS((const void *v1, const void *v2)); static int syn_compare_syntime(const void *v1, const void *v2);
static void syntime_report __ARGS((void)); static void syntime_report(void);
static int syn_time_on = FALSE; static int syn_time_on = FALSE;
# define IF_SYN_TIME(p) (p) # define IF_SYN_TIME(p) (p)
static void syn_stack_apply_changes_block __ARGS((synblock_T *block, buf_T *buf)); static void syn_stack_apply_changes_block(synblock_T *block, buf_T *buf);
static void find_endpos __ARGS((int idx, lpos_T *startpos, lpos_T *m_endpos, static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos,
lpos_T *hl_endpos, long *flagsp, lpos_T * lpos_T *hl_endpos, long *flagsp, lpos_T *end_endpos,
end_endpos, int *end_idx, int *end_idx, reg_extmatch_T *start_ext);
reg_extmatch_T *start_ext)); static void clear_syn_state(synstate_T *p);
static void clear_syn_state __ARGS((synstate_T *p)); static void clear_current_state(void);
static void clear_current_state __ARGS((void));
static void limit_pos __ARGS((lpos_T *pos, lpos_T *limit)); static void limit_pos(lpos_T *pos, lpos_T *limit);
static void limit_pos_zero __ARGS((lpos_T *pos, lpos_T *limit)); static void limit_pos_zero(lpos_T *pos, lpos_T *limit);
static void syn_add_end_off __ARGS((lpos_T *result, regmmatch_T *regmatch, static void syn_add_end_off(lpos_T *result, regmmatch_T *regmatch,
synpat_T *spp, int idx, synpat_T *spp, int idx,
int extra)); int extra);
static void syn_add_start_off __ARGS((lpos_T *result, regmmatch_T *regmatch, static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch,
synpat_T *spp, int idx, synpat_T *spp, int idx,
int extra)); int extra);
static char_u *syn_getcurline __ARGS((void)); static char_u *syn_getcurline(void);
static int syn_regexec __ARGS((regmmatch_T *rmp, linenr_T lnum, colnr_T col, static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col,
syn_time_T *st)); syn_time_T *st);
static int check_keyword_id __ARGS((char_u *line, int startcol, int *endcol, static int check_keyword_id(char_u *line, int startcol, int *endcol,
long *flags, short **next_list, long *flags, short **next_list,
stateitem_T *cur_si, stateitem_T *cur_si,
int *ccharp)); int *ccharp);
static void syn_cmd_case __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_case(exarg_T *eap, int syncing);
static void syn_cmd_spell __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_spell(exarg_T *eap, int syncing);
static void syntax_sync_clear __ARGS((void)); static void syntax_sync_clear(void);
static void syn_remove_pattern __ARGS((synblock_T *block, int idx)); static void syn_remove_pattern(synblock_T *block, int idx);
static void syn_clear_pattern __ARGS((synblock_T *block, int i)); static void syn_clear_pattern(synblock_T *block, int i);
static void syn_clear_cluster __ARGS((synblock_T *block, int i)); static void syn_clear_cluster(synblock_T *block, int i);
static void syn_cmd_clear __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_clear(exarg_T *eap, int syncing);
static void syn_cmd_conceal __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_conceal(exarg_T *eap, int syncing);
static void syn_clear_one __ARGS((int id, int syncing)); static void syn_clear_one(int id, int syncing);
static void syn_cmd_on __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_on(exarg_T *eap, int syncing);
static void syn_cmd_enable __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_enable(exarg_T *eap, int syncing);
static void syn_cmd_reset __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_reset(exarg_T *eap, int syncing);
static void syn_cmd_manual __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_manual(exarg_T *eap, int syncing);
static void syn_cmd_off __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_off(exarg_T *eap, int syncing);
static void syn_cmd_onoff __ARGS((exarg_T *eap, char *name)); static void syn_cmd_onoff(exarg_T *eap, char *name);
static void syn_cmd_list __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_list(exarg_T *eap, int syncing);
static void syn_lines_msg __ARGS((void)); static void syn_lines_msg(void);
static void syn_match_msg __ARGS((void)); static void syn_match_msg(void);
static void syn_stack_free_block __ARGS((synblock_T *block)); static void syn_stack_free_block(synblock_T *block);
static void syn_list_one __ARGS((int id, int syncing, int link_only)); static void syn_list_one(int id, int syncing, int link_only);
static void syn_list_cluster __ARGS((int id)); static void syn_list_cluster(int id);
static void put_id_list __ARGS((char_u *name, short *list, int attr)); static void put_id_list(char_u *name, short *list, int attr);
static void put_pattern __ARGS((char *s, int c, synpat_T *spp, int attr)); static void put_pattern(char *s, int c, synpat_T *spp, int attr);
static int syn_list_keywords __ARGS((int id, hashtab_T *ht, int did_header, static int syn_list_keywords(int id, hashtab_T *ht, int did_header,
int attr)); int attr);
static void syn_clear_keyword __ARGS((int id, hashtab_T *ht)); static void syn_clear_keyword(int id, hashtab_T *ht);
static void clear_keywtab __ARGS((hashtab_T *ht)); static void clear_keywtab(hashtab_T *ht);
static void add_keyword __ARGS((char_u *name, int id, int flags, static void add_keyword(char_u *name, int id, int flags,
short *cont_in_list, short *next_list, short *cont_in_list, short *next_list,
int conceal_char)); int conceal_char);
static char_u *get_group_name __ARGS((char_u *arg, char_u **name_end)); static char_u *get_group_name(char_u *arg, char_u **name_end);
static char_u *get_syn_options __ARGS((char_u *arg, syn_opt_arg_T *opt, static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt,
int *conceal_char)); int *conceal_char);
static void syn_cmd_include __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_include(exarg_T *eap, int syncing);
static void syn_cmd_keyword __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_keyword(exarg_T *eap, int syncing);
static void syn_cmd_match __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_match(exarg_T *eap, int syncing);
static void syn_cmd_region __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_region(exarg_T *eap, int syncing);
static int syn_compare_stub __ARGS((const void *v1, const void *v2)); static int syn_compare_stub(const void *v1, const void *v2);
static void syn_cmd_cluster __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_cluster(exarg_T *eap, int syncing);
static int syn_scl_name2id __ARGS((char_u *name)); static int syn_scl_name2id(char_u *name);
static int syn_scl_namen2id __ARGS((char_u *linep, int len)); static int syn_scl_namen2id(char_u *linep, int len);
static int syn_check_cluster __ARGS((char_u *pp, int len)); static int syn_check_cluster(char_u *pp, int len);
static int syn_add_cluster __ARGS((char_u *name)); static int syn_add_cluster(char_u *name);
static void init_syn_patterns __ARGS((void)); static void init_syn_patterns(void);
static char_u *get_syn_pattern __ARGS((char_u *arg, synpat_T *ci)); static char_u *get_syn_pattern(char_u *arg, synpat_T *ci);
static void syn_cmd_sync __ARGS((exarg_T *eap, int syncing)); static void syn_cmd_sync(exarg_T *eap, int syncing);
static int get_id_list __ARGS((char_u **arg, int keylen, short **list)); static int get_id_list(char_u **arg, int keylen, short **list);
static void syn_combine_list __ARGS((short **clstr1, short **clstr2, static void syn_combine_list(short **clstr1, short **clstr2,
int list_op)); int list_op);
static void syn_incl_toplevel __ARGS((int id, int *flagsp)); static void syn_incl_toplevel(int id, int *flagsp);
/* /*
* Start the syntax recognition for a line. This function is normally called * Start the syntax recognition for a line. This function is normally called
@ -3503,7 +3502,7 @@ struct name_list {
char *name; char *name;
}; };
static void syn_list_flags __ARGS((struct name_list *nl, int flags, int attr)); static void syn_list_flags(struct name_list *nl, int flags, int attr);
/* /*
* List one syntax item, for ":syntax" or "syntax list syntax_name". * List one syntax item, for ":syntax" or "syntax list syntax_name".
@ -5478,7 +5477,7 @@ in_id_list (
struct subcommand { struct subcommand {
char *name; /* subcommand name */ char *name; /* subcommand name */
void (*func)__ARGS((exarg_T *, int)); /* function to call */ void (*func)(exarg_T *, int); /* function to call */
}; };
static struct subcommand subcommands[] = static struct subcommand subcommands[] =
@ -7744,8 +7743,8 @@ int highlight_changed(void) {
return OK; return OK;
} }
static void highlight_list __ARGS((void)); static void highlight_list(void);
static void highlight_list_two __ARGS((int cnt, int attr)); static void highlight_list_two(int cnt, int attr);
/* /*
* Handle command line completion for :highlight command. * Handle command line completion for :highlight command.

110
src/syntax.h
View File

@ -1,61 +1,61 @@
#ifndef NEOVIM_SYNTAX_H #ifndef NEOVIM_SYNTAX_H
#define NEOVIM_SYNTAX_H #define NEOVIM_SYNTAX_H
/* syntax.c */ /* syntax.c */
void syntax_start __ARGS((win_T *wp, linenr_T lnum)); void syntax_start(win_T *wp, linenr_T lnum);
void syn_stack_free_all __ARGS((synblock_T *block)); void syn_stack_free_all(synblock_T *block);
void syn_stack_apply_changes __ARGS((buf_T *buf)); void syn_stack_apply_changes(buf_T *buf);
void syntax_end_parsing __ARGS((linenr_T lnum)); void syntax_end_parsing(linenr_T lnum);
int syntax_check_changed __ARGS((linenr_T lnum)); int syntax_check_changed(linenr_T lnum);
int get_syntax_attr __ARGS((colnr_T col, int *can_spell, int keep_state)); int get_syntax_attr(colnr_T col, int *can_spell, int keep_state);
void syntax_clear __ARGS((synblock_T *block)); void syntax_clear(synblock_T *block);
void reset_synblock __ARGS((win_T *wp)); void reset_synblock(win_T *wp);
void ex_syntax __ARGS((exarg_T *eap)); void ex_syntax(exarg_T *eap);
void ex_ownsyntax __ARGS((exarg_T *eap)); void ex_ownsyntax(exarg_T *eap);
int syntax_present __ARGS((win_T *win)); int syntax_present(win_T *win);
void reset_expand_highlight __ARGS((void)); void reset_expand_highlight(void);
void set_context_in_echohl_cmd __ARGS((expand_T *xp, char_u *arg)); void set_context_in_echohl_cmd(expand_T *xp, char_u *arg);
void set_context_in_syntax_cmd __ARGS((expand_T *xp, char_u *arg)); void set_context_in_syntax_cmd(expand_T *xp, char_u *arg);
char_u *get_syntax_name __ARGS((expand_T *xp, int idx)); char_u *get_syntax_name(expand_T *xp, int idx);
int syn_get_id __ARGS((win_T *wp, long lnum, colnr_T col, int trans, int syn_get_id(win_T *wp, long lnum, colnr_T col, int trans,
int *spellp, int *spellp,
int keep_state)); int keep_state);
int get_syntax_info __ARGS((int *seqnrp)); int get_syntax_info(int *seqnrp);
int syn_get_sub_char __ARGS((void)); int syn_get_sub_char(void);
int syn_get_stack_item __ARGS((int i)); int syn_get_stack_item(int i);
int syn_get_foldlevel __ARGS((win_T *wp, long lnum)); int syn_get_foldlevel(win_T *wp, long lnum);
void ex_syntime __ARGS((exarg_T *eap)); void ex_syntime(exarg_T *eap);
char_u *get_syntime_arg __ARGS((expand_T *xp, int idx)); char_u *get_syntime_arg(expand_T *xp, int idx);
void init_highlight __ARGS((int both, int reset)); void init_highlight(int both, int reset);
int load_colors __ARGS((char_u *name)); int load_colors(char_u *name);
void do_highlight __ARGS((char_u *line, int forceit, int init)); void do_highlight(char_u *line, int forceit, int init);
void free_highlight __ARGS((void)); void free_highlight(void);
void restore_cterm_colors __ARGS((void)); void restore_cterm_colors(void);
void set_normal_colors __ARGS((void)); void set_normal_colors(void);
char_u *hl_get_font_name __ARGS((void)); char_u *hl_get_font_name(void);
void hl_set_font_name __ARGS((char_u *font_name)); void hl_set_font_name(char_u *font_name);
void hl_set_bg_color_name __ARGS((char_u *name)); void hl_set_bg_color_name(char_u *name);
void hl_set_fg_color_name __ARGS((char_u *name)); void hl_set_fg_color_name(char_u *name);
void clear_hl_tables __ARGS((void)); void clear_hl_tables(void);
int hl_combine_attr __ARGS((int char_attr, int prim_attr)); int hl_combine_attr(int char_attr, int prim_attr);
attrentry_T *syn_gui_attr2entry __ARGS((int attr)); attrentry_T *syn_gui_attr2entry(int attr);
int syn_attr2attr __ARGS((int attr)); int syn_attr2attr(int attr);
attrentry_T *syn_term_attr2entry __ARGS((int attr)); attrentry_T *syn_term_attr2entry(int attr);
attrentry_T *syn_cterm_attr2entry __ARGS((int attr)); attrentry_T *syn_cterm_attr2entry(int attr);
char_u *highlight_has_attr __ARGS((int id, int flag, int modec)); char_u *highlight_has_attr(int id, int flag, int modec);
char_u *highlight_color __ARGS((int id, char_u *what, int modec)); char_u *highlight_color(int id, char_u *what, int modec);
long_u highlight_gui_color_rgb __ARGS((int id, int fg)); long_u highlight_gui_color_rgb(int id, int fg);
int syn_name2id __ARGS((char_u *name)); int syn_name2id(char_u *name);
int highlight_exists __ARGS((char_u *name)); int highlight_exists(char_u *name);
char_u *syn_id2name __ARGS((int id)); char_u *syn_id2name(int id);
int syn_namen2id __ARGS((char_u *linep, int len)); int syn_namen2id(char_u *linep, int len);
int syn_check_group __ARGS((char_u *pp, int len)); int syn_check_group(char_u *pp, int len);
int syn_id2attr __ARGS((int hl_id)); int syn_id2attr(int hl_id);
int syn_id2colors __ARGS((int hl_id, guicolor_T *fgp, guicolor_T *bgp)); int syn_id2colors(int hl_id, guicolor_T *fgp, guicolor_T *bgp);
int syn_get_final_id __ARGS((int hl_id)); int syn_get_final_id(int hl_id);
void highlight_gui_started __ARGS((void)); void highlight_gui_started(void);
int highlight_changed __ARGS((void)); int highlight_changed(void);
void set_context_in_highlight_cmd __ARGS((expand_T *xp, char_u *arg)); void set_context_in_highlight_cmd(expand_T *xp, char_u *arg);
char_u *get_highlight_name __ARGS((expand_T *xp, int idx)); char_u *get_highlight_name(expand_T *xp, int idx);
void free_highlight_fonts __ARGS((void)); void free_highlight_fonts(void);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_SYNTAX_H */ #endif /* NEOVIM_SYNTAX_H */

30
src/tag.c
View File

@ -84,17 +84,17 @@ static char *mt_names[MT_COUNT/2] =
#define NOTAGFILE 99 /* return value for jumpto_tag */ #define NOTAGFILE 99 /* return value for jumpto_tag */
static char_u *nofile_fname = NULL; /* fname for NOTAGFILE error */ static char_u *nofile_fname = NULL; /* fname for NOTAGFILE error */
static void taglen_advance __ARGS((int l)); static void taglen_advance(int l);
static int jumpto_tag __ARGS((char_u *lbuf, int forceit, int keep_help)); static int jumpto_tag(char_u *lbuf, int forceit, int keep_help);
static int parse_tag_line __ARGS((char_u *lbuf, tagptrs_T *tagp)); static int parse_tag_line(char_u *lbuf, tagptrs_T *tagp);
static int test_for_static __ARGS((tagptrs_T *)); static int test_for_static(tagptrs_T *);
static int parse_match __ARGS((char_u *lbuf, tagptrs_T *tagp)); static int parse_match(char_u *lbuf, tagptrs_T *tagp);
static char_u *tag_full_fname __ARGS((tagptrs_T *tagp)); static char_u *tag_full_fname(tagptrs_T *tagp);
static char_u *expand_tag_fname __ARGS((char_u *fname, char_u *tag_fname, static char_u *expand_tag_fname(char_u *fname, char_u *tag_fname,
int expand)); int expand);
static int test_for_current __ARGS((char_u *, char_u *, char_u *, char_u *)); static int test_for_current(char_u *, char_u *, char_u *, char_u *);
static int find_extra __ARGS((char_u **pp)); static int find_extra(char_u **pp);
static char_u *bottommsg = (char_u *)N_("E555: at bottom of tag stack"); static char_u *bottommsg = (char_u *)N_("E555: at bottom of tag stack");
static char_u *topmsg = (char_u *)N_("E556: at top of tag stack"); static char_u *topmsg = (char_u *)N_("E556: at top of tag stack");
@ -1000,7 +1000,7 @@ void do_tags(exarg_T *eap)
# define tag_fgets vim_fgets # define tag_fgets vim_fgets
#endif #endif
static int tag_strnicmp __ARGS((char_u *s1, char_u *s2, size_t len)); static int tag_strnicmp(char_u *s1, char_u *s2, size_t len);
/* /*
* Compare two strings, for length "len", ignoring case the ASCII way. * Compare two strings, for length "len", ignoring case the ASCII way.
@ -1035,7 +1035,7 @@ typedef struct {
regmatch_T regmatch; /* regexp program, may be NULL */ regmatch_T regmatch; /* regexp program, may be NULL */
} pat_T; } pat_T;
static void prepare_pats __ARGS((pat_T *pats, int has_re)); static void prepare_pats(pat_T *pats, int has_re);
/* /*
* Extract info from the tag search pattern "pats->pat". * Extract info from the tag search pattern "pats->pat".
@ -2040,7 +2040,7 @@ findtag_end:
} }
static garray_T tag_fnames = GA_EMPTY; static garray_T tag_fnames = GA_EMPTY;
static void found_tagfile_cb __ARGS((char_u *fname, void *cookie)); static void found_tagfile_cb(char_u *fname, void *cookie);
/* /*
* Callback function for finding all "tags" and "tags-??" files in * Callback function for finding all "tags" and "tags-??" files in
@ -2992,8 +2992,8 @@ expand_tags (
return ret; return ret;
} }
static int add_tag_field __ARGS((dict_T *dict, char *field_name, char_u *start, static int add_tag_field(dict_T *dict, char *field_name, char_u *start,
char_u *end)); char_u *end);
/* /*
* Add a tag field to the dictionary "dict". * Add a tag field to the dictionary "dict".

24
src/tag.h
View File

@ -1,18 +1,18 @@
#ifndef NEOVIM_TAG_H #ifndef NEOVIM_TAG_H
#define NEOVIM_TAG_H #define NEOVIM_TAG_H
/* tag.c */ /* tag.c */
int do_tag __ARGS((char_u *tag, int type, int count, int forceit, int verbose)); int do_tag(char_u *tag, int type, int count, int forceit, int verbose);
void tag_freematch __ARGS((void)); void tag_freematch(void);
void do_tags __ARGS((exarg_T *eap)); void do_tags(exarg_T *eap);
int find_tags __ARGS((char_u *pat, int *num_matches, char_u ***matchesp, int find_tags(char_u *pat, int *num_matches, char_u ***matchesp,
int flags, int mincount, int flags, int mincount,
char_u *buf_ffname)); char_u *buf_ffname);
void free_tag_stuff __ARGS((void)); void free_tag_stuff(void);
int get_tagfname __ARGS((tagname_T *tnp, int first, char_u *buf)); int get_tagfname(tagname_T *tnp, int first, char_u *buf);
void tagname_free __ARGS((tagname_T *tnp)); void tagname_free(tagname_T *tnp);
void simplify_filename __ARGS((char_u *filename)); void simplify_filename(char_u *filename);
int expand_tags __ARGS((int tagnames, char_u *pat, int *num_file, int expand_tags(int tagnames, char_u *pat, int *num_file,
char_u ***file)); char_u ***file);
int get_tags __ARGS((list_T *list, char_u *pat)); int get_tags(list_T *list, char_u *pat);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_TAG_H */ #endif /* NEOVIM_TAG_H */

42
src/term.c
View File

@ -85,32 +85,32 @@ struct builtin_term {
/* start of keys that are not directly used by Vim but can be mapped */ /* start of keys that are not directly used by Vim but can be mapped */
#define BT_EXTRA_KEYS 0x101 #define BT_EXTRA_KEYS 0x101
static struct builtin_term *find_builtin_term __ARGS((char_u *name)); static struct builtin_term *find_builtin_term(char_u *name);
static void parse_builtin_tcap __ARGS((char_u *s)); static void parse_builtin_tcap(char_u *s);
static void term_color __ARGS((char_u *s, int n)); static void term_color(char_u *s, int n);
static void gather_termleader __ARGS((void)); static void gather_termleader(void);
static void req_codes_from_term __ARGS((void)); static void req_codes_from_term(void);
static void req_more_codes_from_term __ARGS((void)); static void req_more_codes_from_term(void);
static void got_code_from_term __ARGS((char_u *code, int len)); static void got_code_from_term(char_u *code, int len);
static void check_for_codes_from_term __ARGS((void)); static void check_for_codes_from_term(void);
#if defined(FEAT_GUI) \ #if defined(FEAT_GUI) \
|| (defined(FEAT_MOUSE) && (!defined(UNIX) || defined(FEAT_MOUSE_XTERM) \ || (defined(FEAT_MOUSE) && (!defined(UNIX) || defined(FEAT_MOUSE_XTERM) \
|| defined(FEAT_MOUSE_GPM) || defined(FEAT_SYSMOUSE))) || defined(FEAT_MOUSE_GPM) || defined(FEAT_SYSMOUSE)))
static int get_bytes_from_buf __ARGS((char_u *, char_u *, int)); static int get_bytes_from_buf(char_u *, char_u *, int);
#endif #endif
static void del_termcode_idx __ARGS((int idx)); static void del_termcode_idx(int idx);
static int term_is_builtin __ARGS((char_u *name)); static int term_is_builtin(char_u *name);
static int term_7to8bit __ARGS((char_u *p)); static int term_7to8bit(char_u *p);
static void switch_to_8bit __ARGS((void)); static void switch_to_8bit(void);
#ifdef HAVE_TGETENT #ifdef HAVE_TGETENT
static char_u *tgetent_error __ARGS((char_u *, char_u *)); static char_u *tgetent_error(char_u *, char_u *);
/* /*
* Here is our own prototype for tgetstr(), any prototypes from the include * Here is our own prototype for tgetstr(), any prototypes from the include
* files have been disabled by the define at the start of this file. * files have been disabled by the define at the start of this file.
*/ */
char *tgetstr __ARGS((char *, char **)); char *tgetstr(char *, char **);
/* Change this to "if 1" to debug what happens with termresponse. */ /* Change this to "if 1" to debug what happens with termresponse. */
# define LOG_TR(msg) # define LOG_TR(msg)
@ -149,7 +149,7 @@ char *UP, *BC, PC;
# define TGETSTR(s, p) vim_tgetstr((s), (p)) # define TGETSTR(s, p) vim_tgetstr((s), (p))
# define TGETENT(b, t) tgetent((char *)(b), (char *)(t)) # define TGETENT(b, t) tgetent((char *)(b), (char *)(t))
static char_u *vim_tgetstr __ARGS((char *s, char_u **pp)); static char_u *vim_tgetstr(char *s, char_u **pp);
#endif /* HAVE_TGETENT */ #endif /* HAVE_TGETENT */
static int detected_8bit = FALSE; /* detected 8-bit terminal */ static int detected_8bit = FALSE; /* detected 8-bit terminal */
@ -1233,7 +1233,7 @@ static void parse_builtin_tcap(char_u *term)
} }
} }
} }
static void set_color_count __ARGS((int nr)); static void set_color_count(int nr);
/* /*
* Set number of colors. * Set number of colors.
@ -1963,7 +1963,7 @@ char_u *tltoa(unsigned long i)
* minimal tgoto() implementation. * minimal tgoto() implementation.
* no padding and we only parse for %i %d and %+char * no padding and we only parse for %i %d and %+char
*/ */
static char *tgoto __ARGS((char *, int, int)); static char *tgoto(char *, int, int);
static char *tgoto(char *cm, int x, int y) static char *tgoto(char *cm, int x, int y)
{ {
@ -2086,7 +2086,7 @@ void out_char(unsigned c)
out_flush(); out_flush();
} }
static void out_char_nf __ARGS((unsigned)); static void out_char_nf(unsigned);
/* /*
* out_char_nf(c): like out_char(), but don't flush when p_wd is set * out_char_nf(c): like out_char(), but don't flush when p_wd is set
@ -2363,7 +2363,7 @@ void add_long_to_buf(long_u val, char_u *dst)
} }
} }
static int get_long_from_buf __ARGS((char_u *buf, long_u *val)); static int get_long_from_buf(char_u *buf, long_u *val);
/* /*
* Interpret the next string of bytes in buf as a long integer, with the most * Interpret the next string of bytes in buf as a long integer, with the most
@ -2951,7 +2951,7 @@ static struct termcode {
static int tc_max_len = 0; /* number of entries that termcodes[] can hold */ static int tc_max_len = 0; /* number of entries that termcodes[] can hold */
static int tc_len = 0; /* current number of entries in termcodes[] */ static int tc_len = 0; /* current number of entries in termcodes[] */
static int termcode_star __ARGS((char_u *code, int len)); static int termcode_star(char_u *code, int len);
void clear_termcodes(void) { void clear_termcodes(void) {
while (tc_len > 0) while (tc_len > 0)

124
src/term.h
View File

@ -1,68 +1,68 @@
#ifndef NEOVIM_TERM_H #ifndef NEOVIM_TERM_H
#define NEOVIM_TERM_H #define NEOVIM_TERM_H
/* term.c */ /* term.c */
int set_termname __ARGS((char_u *term)); int set_termname(char_u *term);
void set_mouse_termcode __ARGS((int n, char_u *s)); void set_mouse_termcode(int n, char_u *s);
void del_mouse_termcode __ARGS((int n)); void del_mouse_termcode(int n);
void getlinecol __ARGS((long *cp, long *rp)); void getlinecol(long *cp, long *rp);
int add_termcap_entry __ARGS((char_u *name, int force)); int add_termcap_entry(char_u *name, int force);
int term_is_8bit __ARGS((char_u *name)); int term_is_8bit(char_u *name);
int term_is_gui __ARGS((char_u *name)); int term_is_gui(char_u *name);
char_u *tltoa __ARGS((unsigned long i)); char_u *tltoa(unsigned long i);
void termcapinit __ARGS((char_u *name)); void termcapinit(char_u *name);
void out_flush __ARGS((void)); void out_flush(void);
void out_flush_check __ARGS((void)); void out_flush_check(void);
void out_trash __ARGS((void)); void out_trash(void);
void out_char __ARGS((unsigned c)); void out_char(unsigned c);
void out_str_nf __ARGS((char_u *s)); void out_str_nf(char_u *s);
void out_str __ARGS((char_u *s)); void out_str(char_u *s);
void term_windgoto __ARGS((int row, int col)); void term_windgoto(int row, int col);
void term_cursor_right __ARGS((int i)); void term_cursor_right(int i);
void term_append_lines __ARGS((int line_count)); void term_append_lines(int line_count);
void term_delete_lines __ARGS((int line_count)); void term_delete_lines(int line_count);
void term_set_winpos __ARGS((int x, int y)); void term_set_winpos(int x, int y);
void term_set_winsize __ARGS((int width, int height)); void term_set_winsize(int width, int height);
void term_fg_color __ARGS((int n)); void term_fg_color(int n);
void term_bg_color __ARGS((int n)); void term_bg_color(int n);
void term_settitle __ARGS((char_u *title)); void term_settitle(char_u *title);
void ttest __ARGS((int pairs)); void ttest(int pairs);
void add_long_to_buf __ARGS((long_u val, char_u *dst)); void add_long_to_buf(long_u val, char_u *dst);
void check_shellsize __ARGS((void)); void check_shellsize(void);
void limit_screen_size __ARGS((void)); void limit_screen_size(void);
void win_new_shellsize __ARGS((void)); void win_new_shellsize(void);
void shell_resized __ARGS((void)); void shell_resized(void);
void shell_resized_check __ARGS((void)); void shell_resized_check(void);
void set_shellsize __ARGS((int width, int height, int mustset)); void set_shellsize(int width, int height, int mustset);
void settmode __ARGS((int tmode)); void settmode(int tmode);
void starttermcap __ARGS((void)); void starttermcap(void);
void stoptermcap __ARGS((void)); void stoptermcap(void);
void may_req_termresponse __ARGS((void)); void may_req_termresponse(void);
void may_req_ambiguous_char_width __ARGS((void)); void may_req_ambiguous_char_width(void);
int swapping_screen __ARGS((void)); int swapping_screen(void);
void setmouse __ARGS((void)); void setmouse(void);
int mouse_has __ARGS((int c)); int mouse_has(int c);
int mouse_model_popup __ARGS((void)); int mouse_model_popup(void);
void scroll_start __ARGS((void)); void scroll_start(void);
void cursor_on __ARGS((void)); void cursor_on(void);
void cursor_off __ARGS((void)); void cursor_off(void);
void term_cursor_shape __ARGS((void)); void term_cursor_shape(void);
void scroll_region_set __ARGS((win_T *wp, int off)); void scroll_region_set(win_T *wp, int off);
void scroll_region_reset __ARGS((void)); void scroll_region_reset(void);
void clear_termcodes __ARGS((void)); void clear_termcodes(void);
void add_termcode __ARGS((char_u *name, char_u *string, int flags)); void add_termcode(char_u *name, char_u *string, int flags);
char_u *find_termcode __ARGS((char_u *name)); char_u *find_termcode(char_u *name);
char_u *get_termcode __ARGS((int i)); char_u *get_termcode(int i);
void del_termcode __ARGS((char_u *name)); void del_termcode(char_u *name);
void set_mouse_topline __ARGS((win_T *wp)); void set_mouse_topline(win_T *wp);
int check_termcode __ARGS((int max_offset, char_u *buf, int bufsize, int check_termcode(int max_offset, char_u *buf, int bufsize,
int *buflen)); int *buflen);
char_u *replace_termcodes __ARGS((char_u *from, char_u **bufp, int from_part, char_u *replace_termcodes(char_u *from, char_u **bufp, int from_part,
int do_lt, int do_lt,
int special)); int special);
int find_term_bykeys __ARGS((char_u *src)); int find_term_bykeys(char_u *src);
void show_termcodes __ARGS((void)); void show_termcodes(void);
int show_one_termcode __ARGS((char_u *name, char_u *code, int printit)); int show_one_termcode(char_u *name, char_u *code, int printit);
char_u *translate_mapping __ARGS((char_u *str, int expmap)); char_u *translate_mapping(char_u *str, int expmap);
void update_tcap __ARGS((int attr)); void update_tcap(int attr);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_TERM_H */ #endif /* NEOVIM_TERM_H */

130
src/ui.h
View File

@ -1,70 +1,70 @@
#ifndef NEOVIM_UI_H #ifndef NEOVIM_UI_H
#define NEOVIM_UI_H #define NEOVIM_UI_H
/* ui.c */ /* ui.c */
void ui_write __ARGS((char_u *s, int len)); void ui_write(char_u *s, int len);
void ui_inchar_undo __ARGS((char_u *s, int len)); void ui_inchar_undo(char_u *s, int len);
int ui_inchar __ARGS((char_u *buf, int maxlen, long wtime, int tb_change_cnt)); int ui_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
int ui_char_avail __ARGS((void)); int ui_char_avail(void);
void ui_delay __ARGS((long msec, int ignoreinput)); void ui_delay(long msec, int ignoreinput);
void ui_suspend __ARGS((void)); void ui_suspend(void);
void suspend_shell __ARGS((void)); void suspend_shell(void);
int ui_get_shellsize __ARGS((void)); int ui_get_shellsize(void);
void ui_set_shellsize __ARGS((int mustset)); void ui_set_shellsize(int mustset);
void ui_new_shellsize __ARGS((void)); void ui_new_shellsize(void);
void ui_breakcheck __ARGS((void)); void ui_breakcheck(void);
void clip_init __ARGS((int can_use)); void clip_init(int can_use);
void clip_update_selection __ARGS((VimClipboard *clip)); void clip_update_selection(VimClipboard *clip);
void clip_own_selection __ARGS((VimClipboard *cbd)); void clip_own_selection(VimClipboard *cbd);
void clip_lose_selection __ARGS((VimClipboard *cbd)); void clip_lose_selection(VimClipboard *cbd);
void clip_auto_select __ARGS((void)); void clip_auto_select(void);
int clip_isautosel_star __ARGS((void)); int clip_isautosel_star(void);
int clip_isautosel_plus __ARGS((void)); int clip_isautosel_plus(void);
void clip_modeless __ARGS((int button, int is_click, int is_drag)); void clip_modeless(int button, int is_click, int is_drag);
void clip_start_selection __ARGS((int col, int row, int repeated_click)); void clip_start_selection(int col, int row, int repeated_click);
void clip_process_selection __ARGS((int button, int col, int row, void clip_process_selection(int button, int col, int row,
int_u repeated_click)); int_u repeated_click);
void clip_may_redraw_selection __ARGS((int row, int col, int len)); void clip_may_redraw_selection(int row, int col, int len);
void clip_clear_selection __ARGS((VimClipboard *cbd)); void clip_clear_selection(VimClipboard *cbd);
void clip_may_clear_selection __ARGS((int row1, int row2)); void clip_may_clear_selection(int row1, int row2);
void clip_scroll_selection __ARGS((int rows)); void clip_scroll_selection(int rows);
void clip_copy_modeless_selection __ARGS((int both)); void clip_copy_modeless_selection(int both);
int clip_gen_own_selection __ARGS((VimClipboard *cbd)); int clip_gen_own_selection(VimClipboard *cbd);
void clip_gen_lose_selection __ARGS((VimClipboard *cbd)); void clip_gen_lose_selection(VimClipboard *cbd);
void clip_gen_set_selection __ARGS((VimClipboard *cbd)); void clip_gen_set_selection(VimClipboard *cbd);
void clip_gen_request_selection __ARGS((VimClipboard *cbd)); void clip_gen_request_selection(VimClipboard *cbd);
int clip_gen_owner_exists __ARGS((VimClipboard *cbd)); int clip_gen_owner_exists(VimClipboard *cbd);
int vim_is_input_buf_full __ARGS((void)); int vim_is_input_buf_full(void);
int vim_is_input_buf_empty __ARGS((void)); int vim_is_input_buf_empty(void);
int vim_free_in_input_buf __ARGS((void)); int vim_free_in_input_buf(void);
int vim_used_in_input_buf __ARGS((void)); int vim_used_in_input_buf(void);
char_u *get_input_buf __ARGS((void)); char_u *get_input_buf(void);
void set_input_buf __ARGS((char_u *p)); void set_input_buf(char_u *p);
void add_to_input_buf __ARGS((char_u *s, int len)); void add_to_input_buf(char_u *s, int len);
void add_to_input_buf_csi __ARGS((char_u *str, int len)); void add_to_input_buf_csi(char_u *str, int len);
void push_raw_key __ARGS((char_u *s, int len)); void push_raw_key(char_u *s, int len);
void trash_input_buf __ARGS((void)); void trash_input_buf(void);
int read_from_input_buf __ARGS((char_u *buf, long maxlen)); int read_from_input_buf(char_u *buf, long maxlen);
void fill_input_buf __ARGS((int exit_on_error)); void fill_input_buf(int exit_on_error);
void read_error_exit __ARGS((void)); void read_error_exit(void);
void ui_cursor_shape __ARGS((void)); void ui_cursor_shape(void);
int check_col __ARGS((int col)); int check_col(int col);
int check_row __ARGS((int row)); int check_row(int row);
void open_app_context __ARGS((void)); void open_app_context(void);
void x11_setup_atoms __ARGS((Display *dpy)); void x11_setup_atoms(Display *dpy);
void x11_setup_selection __ARGS((Widget w)); void x11_setup_selection(Widget w);
void clip_x11_request_selection __ARGS((Widget myShell, Display *dpy, void clip_x11_request_selection(Widget myShell, Display *dpy,
VimClipboard *cbd)); VimClipboard *cbd);
void clip_x11_lose_selection __ARGS((Widget myShell, VimClipboard *cbd)); void clip_x11_lose_selection(Widget myShell, VimClipboard *cbd);
int clip_x11_own_selection __ARGS((Widget myShell, VimClipboard *cbd)); int clip_x11_own_selection(Widget myShell, VimClipboard *cbd);
void clip_x11_set_selection __ARGS((VimClipboard *cbd)); void clip_x11_set_selection(VimClipboard *cbd);
int clip_x11_owner_exists __ARGS((VimClipboard *cbd)); int clip_x11_owner_exists(VimClipboard *cbd);
void yank_cut_buffer0 __ARGS((Display *dpy, VimClipboard *cbd)); void yank_cut_buffer0(Display *dpy, VimClipboard *cbd);
int jump_to_mouse __ARGS((int flags, int *inclusive, int which_button)); int jump_to_mouse(int flags, int *inclusive, int which_button);
int mouse_comp_pos __ARGS((win_T *win, int *rowp, int *colp, linenr_T *lnump)); int mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump);
win_T *mouse_find_win __ARGS((int *rowp, int *colp)); win_T *mouse_find_win(int *rowp, int *colp);
int get_fpos_of_mouse __ARGS((pos_T *mpos)); int get_fpos_of_mouse(pos_T *mpos);
int vcol2col __ARGS((win_T *wp, linenr_T lnum, int vcol)); int vcol2col(win_T *wp, linenr_T lnum, int vcol);
void ui_focus_change __ARGS((int in_focus)); void ui_focus_change(int in_focus);
void im_save_status __ARGS((long *psave)); void im_save_status(long *psave);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_UI_H */ #endif /* NEOVIM_UI_H */

60
src/undo.c
View File

@ -99,38 +99,38 @@
#include "screen.h" #include "screen.h"
#include "sha256.h" #include "sha256.h"
static long get_undolevel __ARGS((void)); static long get_undolevel(void);
static void u_unch_branch __ARGS((u_header_T *uhp)); static void u_unch_branch(u_header_T *uhp);
static u_entry_T *u_get_headentry __ARGS((void)); static u_entry_T *u_get_headentry(void);
static void u_getbot __ARGS((void)); static void u_getbot(void);
static void u_doit __ARGS((int count)); static void u_doit(int count);
static void u_undoredo __ARGS((int undo)); static void u_undoredo(int undo);
static void u_undo_end __ARGS((int did_undo, int absolute)); static void u_undo_end(int did_undo, int absolute);
static void u_add_time __ARGS((char_u *buf, size_t buflen, time_t tt)); static void u_add_time(char_u *buf, size_t buflen, time_t tt);
static void u_freeheader __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp)); static void u_freeheader(buf_T *buf, u_header_T *uhp, u_header_T **uhpp);
static void u_freebranch __ARGS((buf_T *buf, u_header_T *uhp, u_header_T **uhpp)); static void u_freebranch(buf_T *buf, u_header_T *uhp, u_header_T **uhpp);
static void u_freeentries __ARGS((buf_T *buf, u_header_T *uhp, static void u_freeentries(buf_T *buf, u_header_T *uhp,
u_header_T **uhpp)); u_header_T **uhpp);
static void u_freeentry __ARGS((u_entry_T *, long)); static void u_freeentry(u_entry_T *, long);
static void corruption_error __ARGS((char *mesg, char_u *file_name)); static void corruption_error(char *mesg, char_u *file_name);
static void u_free_uhp __ARGS((u_header_T *uhp)); static void u_free_uhp(u_header_T *uhp);
static size_t fwrite_crypt __ARGS((buf_T *buf, char_u *ptr, size_t len, static size_t fwrite_crypt(buf_T *buf, char_u *ptr, size_t len,
FILE *fp)); FILE *fp);
static char_u *read_string_decrypt __ARGS((buf_T *buf, FILE *fd, int len)); static char_u *read_string_decrypt(buf_T *buf, FILE *fd, int len);
static int serialize_header __ARGS((FILE *fp, buf_T *buf, char_u *hash)); static int serialize_header(FILE *fp, buf_T *buf, char_u *hash);
static int serialize_uhp __ARGS((FILE *fp, buf_T *buf, u_header_T *uhp)); static int serialize_uhp(FILE *fp, buf_T *buf, u_header_T *uhp);
static u_header_T *unserialize_uhp __ARGS((FILE *fp, char_u *file_name)); static u_header_T *unserialize_uhp(FILE *fp, char_u *file_name);
static int serialize_uep __ARGS((FILE *fp, buf_T *buf, u_entry_T *uep)); static int serialize_uep(FILE *fp, buf_T *buf, u_entry_T *uep);
static u_entry_T *unserialize_uep __ARGS((FILE *fp, int *error, static u_entry_T *unserialize_uep(FILE *fp, int *error,
char_u *file_name)); char_u *file_name);
static void serialize_pos __ARGS((pos_T pos, FILE *fp)); static void serialize_pos(pos_T pos, FILE *fp);
static void unserialize_pos __ARGS((pos_T *pos, FILE *fp)); static void unserialize_pos(pos_T *pos, FILE *fp);
static void serialize_visualinfo __ARGS((visualinfo_T *info, FILE *fp)); static void serialize_visualinfo(visualinfo_T *info, FILE *fp);
static void unserialize_visualinfo __ARGS((visualinfo_T *info, FILE *fp)); static void unserialize_visualinfo(visualinfo_T *info, FILE *fp);
static void put_header_ptr __ARGS((FILE *fp, u_header_T *uhp)); static void put_header_ptr(FILE *fp, u_header_T *uhp);
#define U_ALLOC_LINE(size) lalloc((long_u)(size), FALSE) #define U_ALLOC_LINE(size) lalloc((long_u)(size), FALSE)
static char_u *u_save_line __ARGS((linenr_T)); static char_u *u_save_line(linenr_T);
/* used in undo_end() to report number of added and deleted lines */ /* used in undo_end() to report number of added and deleted lines */
static long u_newcount, u_oldcount; static long u_newcount, u_oldcount;

58
src/undo.h
View File

@ -1,34 +1,34 @@
#ifndef NEOVIM_UNDO_H #ifndef NEOVIM_UNDO_H
#define NEOVIM_UNDO_H #define NEOVIM_UNDO_H
/* undo.c */ /* undo.c */
int u_save_cursor __ARGS((void)); int u_save_cursor(void);
int u_save __ARGS((linenr_T top, linenr_T bot)); int u_save(linenr_T top, linenr_T bot);
int u_savesub __ARGS((linenr_T lnum)); int u_savesub(linenr_T lnum);
int u_inssub __ARGS((linenr_T lnum)); int u_inssub(linenr_T lnum);
int u_savedel __ARGS((linenr_T lnum, long nlines)); int u_savedel(linenr_T lnum, long nlines);
int undo_allowed __ARGS((void)); int undo_allowed(void);
int u_savecommon __ARGS((linenr_T top, linenr_T bot, linenr_T newbot, int u_savecommon(linenr_T top, linenr_T bot, linenr_T newbot,
int reload)); int reload);
void u_compute_hash __ARGS((char_u *hash)); void u_compute_hash(char_u *hash);
char_u *u_get_undo_file_name __ARGS((char_u *buf_ffname, int reading)); char_u *u_get_undo_file_name(char_u *buf_ffname, int reading);
void u_write_undo __ARGS((char_u *name, int forceit, buf_T *buf, char_u *hash)); void u_write_undo(char_u *name, int forceit, buf_T *buf, char_u *hash);
void u_read_undo __ARGS((char_u *name, char_u *hash, char_u *orig_name)); void u_read_undo(char_u *name, char_u *hash, char_u *orig_name);
void u_undo __ARGS((int count)); void u_undo(int count);
void u_redo __ARGS((int count)); void u_redo(int count);
void undo_time __ARGS((long step, int sec, int file, int absolute)); void undo_time(long step, int sec, int file, int absolute);
void u_sync __ARGS((int force)); void u_sync(int force);
void ex_undolist __ARGS((exarg_T *eap)); void ex_undolist(exarg_T *eap);
void ex_undojoin __ARGS((exarg_T *eap)); void ex_undojoin(exarg_T *eap);
void u_unchanged __ARGS((buf_T *buf)); void u_unchanged(buf_T *buf);
void u_find_first_changed __ARGS((void)); void u_find_first_changed(void);
void u_update_save_nr __ARGS((buf_T *buf)); void u_update_save_nr(buf_T *buf);
void u_clearall __ARGS((buf_T *buf)); void u_clearall(buf_T *buf);
void u_saveline __ARGS((linenr_T lnum)); void u_saveline(linenr_T lnum);
void u_clearline __ARGS((void)); void u_clearline(void);
void u_undoline __ARGS((void)); void u_undoline(void);
void u_blockfree __ARGS((buf_T *buf)); void u_blockfree(buf_T *buf);
int bufIsChanged __ARGS((buf_T *buf)); int bufIsChanged(buf_T *buf);
int curbufIsChanged __ARGS((void)); int curbufIsChanged(void);
void u_eval_tree __ARGS((u_header_T *first_uhp, list_T *list)); void u_eval_tree(u_header_T *first_uhp, list_T *list);
/* vim: set ft=c : */ /* vim: set ft=c : */
#endif /* NEOVIM_UNDO_H */ #endif /* NEOVIM_UNDO_H */

Some files were not shown because too many files have changed in this diff Show More