Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

147 files changed, 5401 insertions, 0 deletions

diff --git a/src/proto/alloc.pro b/src/proto/alloc.pro
new file mode 100644
index 0000000..fe20810
--- /dev/null
+++ b/src/proto/alloc.pro
@@ -0,0 +1,31 @@
+/* alloc.c */
+void vim_mem_profile_dump(void);
+int alloc_does_fail(size_t size);
+void *alloc(size_t size);
+void *alloc_id(size_t size, alloc_id_T id);
+void *alloc_clear(size_t size);
+void *alloc_clear_id(size_t size, alloc_id_T id);
+void *lalloc_clear(size_t size, int message);
+void *lalloc(size_t size, int message);
+void *lalloc_id(size_t size, int message, alloc_id_T id);
+void *mem_realloc(void *ptr, size_t size);
+void do_outofmem_msg(size_t size);
+void free_all_mem(void);
+char_u *vim_memsave(char_u *p, size_t len);
+void vim_free(void *x);
+void ga_clear(garray_T *gap);
+void ga_clear_strings(garray_T *gap);
+int ga_copy_strings(garray_T *from, garray_T *to);
+void ga_init(garray_T *gap);
+void ga_init2(garray_T *gap, size_t itemsize, int growsize);
+int ga_grow(garray_T *gap, int n);
+int ga_grow_id(garray_T *gap, int n, alloc_id_T id);
+int ga_grow_inner(garray_T *gap, int n);
+char_u *ga_concat_strings(garray_T *gap, char *sep);
+int ga_copy_string(garray_T *gap, char_u *p);
+int ga_add_string(garray_T *gap, char_u *p);
+void ga_concat(garray_T *gap, char_u *s);
+void ga_concat_len(garray_T *gap, char_u *s, size_t len);
+int ga_append(garray_T *gap, int c);
+void append_ga_line(garray_T *gap);
+/* vim: set ft=c : */
diff --git a/src/proto/arabic.pro b/src/proto/arabic.pro
new file mode 100644
index 0000000..c93e246
--- /dev/null
+++ b/src/proto/arabic.pro
@@ -0,0 +1,5 @@
+/* arabic.c */
+int arabic_maycombine(int two);
+int arabic_combine(int one, int two);
+int arabic_shape(int c, int *ccp, int *c1p, int prev_c, int prev_c1, int next_c);
+/* vim: set ft=c : */
diff --git a/src/proto/arglist.pro b/src/proto/arglist.pro
new file mode 100644
index 0000000..aeb8399
--- /dev/null
+++ b/src/proto/arglist.pro
@@ -0,0 +1,33 @@
+/* arglist.c */
+void alist_clear(alist_T *al);
+void alist_init(alist_T *al);
+void alist_unlink(alist_T *al);
+void alist_new(void);
+void alist_expand(int *fnum_list, int fnum_len);
+void alist_set(alist_T *al, int count, char_u **files, int use_curbuf, int *fnum_list, int fnum_len);
+void alist_add(alist_T *al, char_u *fname, int set_fnum);
+void alist_slash_adjust(void);
+int get_arglist_exp(char_u *str, int *fcountp, char_u ***fnamesp, int wig);
+void set_arglist(char_u *str);
+int editing_arg_idx(win_T *win);
+void check_arg_idx(win_T *win);
+void ex_args(exarg_T *eap);
+void ex_previous(exarg_T *eap);
+void ex_rewind(exarg_T *eap);
+void ex_last(exarg_T *eap);
+void ex_argument(exarg_T *eap);
+void do_argfile(exarg_T *eap, int argn);
+void ex_next(exarg_T *eap);
+void ex_argdedupe(exarg_T *eap);
+void ex_argedit(exarg_T *eap);
+void ex_argadd(exarg_T *eap);
+void ex_argdelete(exarg_T *eap);
+char_u *get_arglist_name(expand_T *xp, int idx);
+char_u *alist_name(aentry_T *aep);
+void ex_all(exarg_T *eap);
+char_u *arg_all(void);
+void f_argc(typval_T *argvars, typval_T *rettv);
+void f_argidx(typval_T *argvars, typval_T *rettv);
+void f_arglistid(typval_T *argvars, typval_T *rettv);
+void f_argv(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/autocmd.pro b/src/proto/autocmd.pro
new file mode 100644
index 0000000..0b61989
--- /dev/null
+++ b/src/proto/autocmd.pro
@@ -0,0 +1,47 @@
+/* autocmd.c */
+void aubuflocal_remove(buf_T *buf);
+int au_has_group(char_u *name);
+void do_augroup(char_u *arg, int del_group);
+void autocmd_init(void);
+void free_all_autocmds(void);
+int is_aucmd_win(win_T *win);
+int check_ei(void);
+char_u *au_event_disable(char *what);
+void au_event_restore(char_u *old_ei);
+void do_autocmd(exarg_T *eap, char_u *arg_in, int forceit);
+int do_doautocmd(char_u *arg_start, int do_msg, int *did_something);
+void ex_doautoall(exarg_T *eap);
+int check_nomodeline(char_u **argp);
+void aucmd_prepbuf(aco_save_T *aco, buf_T *buf);
+void aucmd_restbuf(aco_save_T *aco);
+int apply_autocmds(event_T event, char_u *fname, char_u *fname_io, int force, buf_T *buf);
+int apply_autocmds_exarg(event_T event, char_u *fname, char_u *fname_io, int force, buf_T *buf, exarg_T *eap);
+int apply_autocmds_retval(event_T event, char_u *fname, char_u *fname_io, int force, buf_T *buf, int *retval);
+int trigger_cursorhold(void);
+int has_winresized(void);
+int has_winscrolled(void);
+int has_cursormoved(void);
+int has_cursormovedI(void);
+int has_textchanged(void);
+int has_textchangedI(void);
+int has_textchangedP(void);
+int has_insertcharpre(void);
+int has_cmdundefined(void);
+int has_textyankpost(void);
+int has_completechanged(void);
+int has_modechanged(void);
+void block_autocmds(void);
+void unblock_autocmds(void);
+int is_autocmd_blocked(void);
+sctx_T *acp_script_ctx(AutoPatCmd_T *acp);
+char_u *getnextac(int c, void *cookie, int indent, getline_opt_T options);
+int has_autocmd(event_T event, char_u *sfname, buf_T *buf);
+char_u *get_augroup_name(expand_T *xp, int idx);
+char_u *set_context_in_autocmd(expand_T *xp, char_u *arg, int doautocmd);
+char_u *get_event_name(expand_T *xp, int idx);
+int autocmd_supported(char_u *name);
+int au_exists(char_u *arg);
+void f_autocmd_add(typval_T *argvars, typval_T *rettv);
+void f_autocmd_delete(typval_T *argvars, typval_T *rettv);
+void f_autocmd_get(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/beval.pro b/src/proto/beval.pro
new file mode 100644
index 0000000..8b67e38
--- /dev/null
+++ b/src/proto/beval.pro
@@ -0,0 +1,7 @@
+/* beval.c */
+int find_word_under_cursor(int mouserow, int mousecol, int getword, int flags, win_T **winp, linenr_T *lnump, char_u **textp, int *colp, int *startcolp);
+int get_beval_info(BalloonEval *beval, int getword, win_T **winp, linenr_T *lnump, char_u **textp, int *colp);
+void post_balloon(BalloonEval *beval, char_u *mesg, list_T *list);
+int can_use_beval(void);
+void general_beval_cb(BalloonEval *beval, int state);
+/* vim: set ft=c : */
diff --git a/src/proto/blob.pro b/src/proto/blob.pro
new file mode 100644
index 0000000..7c8b5ac
--- /dev/null
+++ b/src/proto/blob.pro
@@ -0,0 +1,29 @@
+/* blob.c */
+blob_T *blob_alloc(void);
+int rettv_blob_alloc(typval_T *rettv);
+void rettv_blob_set(typval_T *rettv, blob_T *b);
+int blob_copy(blob_T *from, typval_T *to);
+void blob_free(blob_T *b);
+void blob_unref(blob_T *b);
+long blob_len(blob_T *b);
+int blob_get(blob_T *b, int idx);
+void blob_set(blob_T *blob, int idx, int byte);
+void blob_set_append(blob_T *blob, int idx, int byte);
+int blob_equal(blob_T *b1, blob_T *b2);
+int read_blob(FILE *fd, typval_T *rettv, off_T offset, off_T size_arg);
+int write_blob(FILE *fd, blob_T *blob);
+char_u *blob2string(blob_T *blob, char_u **tofree, char_u *numbuf);
+blob_T *string2blob(char_u *str);
+int blob_slice_or_index(blob_T *blob, int is_range, varnumber_T n1, varnumber_T n2, int exclusive, typval_T *rettv);
+int check_blob_index(long bloblen, varnumber_T n1, int quiet);
+int check_blob_range(long bloblen, varnumber_T n1, varnumber_T n2, int quiet);
+int blob_set_range(blob_T *dest, long n1, long n2, typval_T *src);
+void blob_add(typval_T *argvars, typval_T *rettv);
+void blob_remove(typval_T *argvars, typval_T *rettv, char_u *arg_errmsg);
+void blob_filter_map(blob_T *blob_arg, filtermap_T filtermap, typval_T *expr, typval_T *rettv);
+void blob_insert_func(typval_T *argvars, typval_T *rettv);
+void blob_reduce(typval_T *argvars, typval_T *expr, typval_T *rettv);
+void blob_reverse(blob_T *b, typval_T *rettv);
+void f_blob2list(typval_T *argvars, typval_T *rettv);
+void f_list2blob(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/blowfish.pro b/src/proto/blowfish.pro
new file mode 100644
index 0000000..6b2c454
--- /dev/null
+++ b/src/proto/blowfish.pro
@@ -0,0 +1,6 @@
+/* blowfish.c */
+void crypt_blowfish_encode(cryptstate_T *state, char_u *from, size_t len, char_u *to, int last);
+void crypt_blowfish_decode(cryptstate_T *state, char_u *from, size_t len, char_u *to, int last);
+int crypt_blowfish_init(cryptstate_T *state, char_u *key, char_u *salt, int salt_len, char_u *seed, int seed_len);
+int blowfish_self_test(void);
+/* vim: set ft=c : */
diff --git a/src/proto/buffer.pro b/src/proto/buffer.pro
new file mode 100644
index 0000000..3a61027
--- /dev/null
+++ b/src/proto/buffer.pro
@@ -0,0 +1,73 @@
+/* buffer.c */
+int get_highest_fnum(void);
+void buffer_ensure_loaded(buf_T *buf);
+int open_buffer(int read_stdin, exarg_T *eap, int flags_arg);
+void set_bufref(bufref_T *bufref, buf_T *buf);
+int bufref_valid(bufref_T *bufref);
+int buf_valid(buf_T *buf);
+int close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last, int ignore_abort);
+void buf_clear_file(buf_T *buf);
+void buf_freeall(buf_T *buf, int flags);
+void free_wininfo(wininfo_T *wip);
+void goto_buffer(exarg_T *eap, int start, int dir, int count);
+void handle_swap_exists(bufref_T *old_curbuf);
+int do_buffer(int action, int start, int dir, int count, int forceit);
+char *do_bufdel(int command, char_u *arg, int addr_count, int start_bnr, int end_bnr, int forceit);
+void set_curbuf(buf_T *buf, int action);
+void do_autochdir(void);
+void no_write_message(void);
+void no_write_message_nobang(buf_T *buf);
+int curbuf_reusable(void);
+buf_T *buflist_new(char_u *ffname_arg, char_u *sfname_arg, linenr_T lnum, int flags);
+void free_buf_options(buf_T *buf, int free_p_ff);
+int buflist_getfile(int n, linenr_T lnum, int options, int forceit);
+buf_T *buflist_findname_exp(char_u *fname);
+buf_T *buflist_findname(char_u *ffname);
+int buflist_findpat(char_u *pattern, char_u *pattern_end, int unlisted, int diffmode, int curtab_only);
+int ExpandBufnames(char_u *pat, int *num_file, char_u ***file, int options);
+buf_T *buflist_findnr(int nr);
+char_u *buflist_nr2name(int n, int fullname, int helptail);
+void buflist_setfpos(buf_T *buf, win_T *win, linenr_T lnum, colnr_T col, int copy_options);
+void get_winopts(buf_T *buf);
+pos_T *buflist_findfpos(buf_T *buf);
+linenr_T buflist_findlnum(buf_T *buf);
+void buflist_list(exarg_T *eap);
+int buflist_name_nr(int fnum, char_u **fname, linenr_T *lnum);
+int setfname(buf_T *buf, char_u *ffname_arg, char_u *sfname_arg, int message);
+void buf_set_name(int fnum, char_u *name);
+void buf_name_changed(buf_T *buf);
+buf_T *setaltfname(char_u *ffname, char_u *sfname, linenr_T lnum);
+char_u *getaltfname(int errmsg);
+int buflist_add(char_u *fname, int flags);
+void buflist_slash_adjust(void);
+void buflist_altfpos(win_T *win);
+int otherfile(char_u *ffname);
+void buf_setino(buf_T *buf);
+void fileinfo(int fullname, int shorthelp, int dont_truncate);
+void col_print(char_u *buf, size_t buflen, int col, int vcol);
+void maketitle(void);
+void resettitle(void);
+void free_titles(void);
+int build_stl_str_hl(win_T *wp, char_u *out, size_t outlen, char_u *fmt, char_u *opt_name, int opt_scope, int fillchar, int maxwidth, stl_hlrec_T **hltab, stl_hlrec_T **tabtab);
+void get_rel_pos(win_T *wp, char_u *buf, int buflen);
+char_u *fix_fname(char_u *fname);
+void fname_expand(buf_T *buf, char_u **ffname, char_u **sfname);
+void ex_buffer_all(exarg_T *eap);
+void do_modelines(int flags);
+int bt_normal(buf_T *buf);
+int bt_quickfix(buf_T *buf);
+int bt_terminal(buf_T *buf);
+int bt_help(buf_T *buf);
+int bt_prompt(buf_T *buf);
+int bt_popup(buf_T *buf);
+int bt_nofilename(buf_T *buf);
+int bt_nofile(buf_T *buf);
+int bt_dontwrite(buf_T *buf);
+int bt_dontwrite_msg(buf_T *buf);
+int buf_hide(buf_T *buf);
+char_u *buf_spname(buf_T *buf);
+char_u *buf_get_fname(buf_T *buf);
+void set_buflisted(int on);
+int buf_contents_changed(buf_T *buf);
+void wipe_buffer(buf_T *buf, int aucmd);
+/* vim: set ft=c : */
diff --git a/src/proto/bufwrite.pro b/src/proto/bufwrite.pro
new file mode 100644
index 0000000..72c08da
--- /dev/null
+++ b/src/proto/bufwrite.pro
@@ -0,0 +1,4 @@
+/* bufwrite.c */
+char *new_file_message(void);
+int buf_write(buf_T *buf, char_u *fname, char_u *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, int filtering);
+/* vim: set ft=c : */
diff --git a/src/proto/change.pro b/src/proto/change.pro
new file mode 100644
index 0000000..502b285
--- /dev/null
+++ b/src/proto/change.pro
@@ -0,0 +1,33 @@
+/* change.c */
+void change_warning(int col);
+void changed(void);
+void changed_internal(void);
+void f_listener_add(typval_T *argvars, typval_T *rettv);
+void f_listener_flush(typval_T *argvars, typval_T *rettv);
+void f_listener_remove(typval_T *argvars, typval_T *rettv);
+void may_invoke_listeners(buf_T *buf, linenr_T lnum, linenr_T lnume, int added);
+void invoke_listeners(buf_T *buf);
+void remove_listeners(buf_T *buf);
+void changed_bytes(linenr_T lnum, colnr_T col);
+void inserted_bytes(linenr_T lnum, colnr_T col, int added);
+void appended_lines(linenr_T lnum, long count);
+void appended_lines_mark(linenr_T lnum, long count);
+void deleted_lines(linenr_T lnum, long count);
+void deleted_lines_mark(linenr_T lnum, long count);
+void changed_lines_buf(buf_T *buf, linenr_T lnum, linenr_T lnume, long xtra);
+void changed_lines(linenr_T lnum, colnr_T col, linenr_T lnume, long xtra);
+void unchanged(buf_T *buf, int ff, int always_inc_changedtick);
+void save_file_ff(buf_T *buf);
+int file_ff_differs(buf_T *buf, int ignore_empty);
+void ins_bytes(char_u *p);
+void ins_bytes_len(char_u *p, int len);
+void ins_char(int c);
+void ins_char_bytes(char_u *buf, int charlen);
+void ins_str(char_u *s);
+int del_char(int fixpos);
+int del_chars(long count, int fixpos);
+int del_bytes(long count, int fixpos_arg, int use_delcombine);
+int open_line(int dir, int flags, int second_line_indent, int *did_do_comment);
+int truncate_line(int fixpos);
+void del_lines(long nlines, int undo);
+/* vim: set ft=c : */
diff --git a/src/proto/channel.pro b/src/proto/channel.pro
new file mode 100644
index 0000000..794e60b
--- /dev/null
+++ b/src/proto/channel.pro
@@ -0,0 +1,58 @@
+/* channel.c */
+channel_T *add_channel(void);
+int has_any_channel(void);
+int channel_still_useful(channel_T *channel);
+int channel_can_close(channel_T *channel);
+int channel_unref(channel_T *channel);
+int free_unused_channels_contents(int copyID, int mask);
+void free_unused_channels(int copyID, int mask);
+void channel_gui_register_all(void);
+channel_T *channel_open(const char *hostname, int port, int waittime, void (*nb_close_cb)(void));
+void ch_close_part(channel_T *channel, ch_part_T part);
+void channel_set_pipes(channel_T *channel, sock_T in, sock_T out, sock_T err);
+void channel_set_job(channel_T *channel, job_T *job, jobopt_T *options);
+void channel_write_in(channel_T *channel);
+void channel_buffer_free(buf_T *buf);
+void channel_write_any_lines(void);
+void channel_write_new_lines(buf_T *buf);
+readq_T *channel_peek(channel_T *channel, ch_part_T part);
+char_u *channel_first_nl(readq_T *node);
+char_u *channel_get(channel_T *channel, ch_part_T part, int *outlen);
+void channel_consume(channel_T *channel, ch_part_T part, int len);
+int channel_collapse(channel_T *channel, ch_part_T part, int want_nl);
+int channel_can_write_to(channel_T *channel);
+int channel_is_open(channel_T *channel);
+void channel_close(channel_T *channel, int invoke_close_cb);
+void channel_clear(channel_T *channel);
+void channel_free_all(void);
+int channel_in_blocking_wait(void);
+channel_T *get_channel_arg(typval_T *tv, int check_open, int reading, ch_part_T part);
+void channel_handle_events(int only_keep_open);
+int channel_any_keep_open(void);
+void channel_set_nonblock(channel_T *channel, ch_part_T part);
+int channel_send(channel_T *channel, ch_part_T part, char_u *buf_arg, int len_arg, char *fun);
+int channel_poll_setup(int nfd_in, void *fds_in, int *towait);
+int channel_poll_check(int ret_in, void *fds_in);
+int channel_select_setup(int maxfd_in, void *rfds_in, void *wfds_in, struct timeval *tv, struct timeval **tvp);
+int channel_select_check(int ret_in, void *rfds_in, void *wfds_in);
+int channel_parse_messages(void);
+int channel_any_readahead(void);
+int set_ref_in_channel(int copyID);
+void f_ch_canread(typval_T *argvars, typval_T *rettv);
+void f_ch_close(typval_T *argvars, typval_T *rettv);
+void f_ch_close_in(typval_T *argvars, typval_T *rettv);
+void f_ch_getbufnr(typval_T *argvars, typval_T *rettv);
+void f_ch_getjob(typval_T *argvars, typval_T *rettv);
+void f_ch_info(typval_T *argvars, typval_T *rettv);
+void f_ch_open(typval_T *argvars, typval_T *rettv);
+void f_ch_read(typval_T *argvars, typval_T *rettv);
+void f_ch_readblob(typval_T *argvars, typval_T *rettv);
+void f_ch_readraw(typval_T *argvars, typval_T *rettv);
+void f_ch_evalexpr(typval_T *argvars, typval_T *rettv);
+void f_ch_sendexpr(typval_T *argvars, typval_T *rettv);
+void f_ch_evalraw(typval_T *argvars, typval_T *rettv);
+void f_ch_sendraw(typval_T *argvars, typval_T *rettv);
+void f_ch_setoptions(typval_T *argvars, typval_T *rettv);
+void f_ch_status(typval_T *argvars, typval_T *rettv);
+char_u *channel_to_string_buf(typval_T *varp, char_u *buf);
+/* vim: set ft=c : */
diff --git a/src/proto/charset.pro b/src/proto/charset.pro
new file mode 100644
index 0000000..7e515be
--- /dev/null
+++ b/src/proto/charset.pro
@@ -0,0 +1,73 @@
+/* charset.c */
+int init_chartab(void);
+int buf_init_chartab(buf_T *buf, int global);
+void trans_characters(char_u *buf, int bufsize);
+char_u *transstr(char_u *s);
+char_u *str_foldcase(char_u *str, int orglen, char_u *buf, int buflen);
+char_u *transchar(int c);
+char_u *transchar_buf(buf_T *buf, int c);
+char_u *transchar_byte(int c);
+char_u *transchar_byte_buf(buf_T *buf, int c);
+void transchar_nonprint(buf_T *buf, char_u *charbuf, int c);
+void transchar_hex(char_u *buf, int c);
+int byte2cells(int b);
+int char2cells(int c);
+int ptr2cells(char_u *p);
+int vim_strsize(char_u *s);
+int vim_strnsize(char_u *s, int len);
+int chartabsize(char_u *p, colnr_T col);
+int linetabsize_str(char_u *s);
+int linetabsize_col(int startcol, char_u *s);
+int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len);
+int linetabsize(win_T *wp, linenr_T lnum);
+void win_linetabsize_cts(chartabsize_T *cts, colnr_T len);
+int vim_isIDc(int c);
+int vim_isNormalIDc(int c);
+int vim_iswordc(int c);
+int vim_iswordc_buf(int c, buf_T *buf);
+int vim_iswordp(char_u *p);
+int vim_iswordp_buf(char_u *p, buf_T *buf);
+int vim_isfilec(int c);
+int vim_is_fname_char(int c);
+int vim_isfilec_or_wc(int c);
+int vim_isprintc(int c);
+int vim_isprintc_strict(int c);
+void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char_u *line, char_u *ptr);
+void clear_chartabsize_arg(chartabsize_T *cts);
+int lbr_chartabsize(chartabsize_T *cts);
+int lbr_chartabsize_adv(chartabsize_T *cts);
+int win_lbr_chartabsize(chartabsize_T *cts, int *headp);
+void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end);
+colnr_T getvcol_nolist(pos_T *posp);
+void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end);
+void getvcols(win_T *wp, pos_T *pos1, pos_T *pos2, colnr_T *left, colnr_T *right);
+char_u *skipwhite(char_u *q);
+char_u *skipwhite_and_nl(char_u *q);
+int getwhitecols_curline(void);
+int getwhitecols(char_u *p);
+char_u *skipdigits(char_u *q);
+char_u *skipbin(char_u *q);
+char_u *skiphex(char_u *q);
+char_u *skiptobin(char_u *q);
+char_u *skiptodigit(char_u *q);
+char_u *skiptohex(char_u *q);
+int vim_isdigit(int c);
+int vim_isxdigit(int c);
+int vim_isbdigit(int c);
+int vim_islower(int c);
+int vim_isupper(int c);
+int vim_isalpha(int c);
+int vim_toupper(int c);
+int vim_tolower(int c);
+char_u *skiptowhite(char_u *p);
+char_u *skiptowhite_esc(char_u *p);
+long getdigits(char_u **pp);
+long getdigits_quoted(char_u **pp);
+int vim_isblankline(char_u *lbuf);
+void vim_str2nr(char_u *start, int *prep, int *len, int what, varnumber_T *nptr, uvarnumber_T *unptr, int maxlen, int strict);
+int hex2nr(int c);
+int hexhex2nr(char_u *p);
+int rem_backslash(char_u *str);
+void backslash_halve(char_u *p);
+char_u *backslash_halve_save(char_u *p);
+/* vim: set ft=c : */
diff --git a/src/proto/cindent.pro b/src/proto/cindent.pro
new file mode 100644
index 0000000..80a6add
--- /dev/null
+++ b/src/proto/cindent.pro
@@ -0,0 +1,11 @@
+/* cindent.c */
+int cin_is_cinword(char_u *line);
+int is_pos_in_string(char_u *line, colnr_T col);
+pos_T *find_start_comment(int ind_maxcomment);
+int cindent_on(void);
+void parse_cino(buf_T *buf);
+int get_c_indent(void);
+int in_cinkeys(int keytyped, int when, int line_is_empty);
+void do_c_expr_indent(void);
+void f_cindent(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/clientserver.pro b/src/proto/clientserver.pro
new file mode 100644
index 0000000..3acd5e0
--- /dev/null
+++ b/src/proto/clientserver.pro
@@ -0,0 +1,16 @@
+/* clientserver.c */
+void server_to_input_buf(char_u *str);
+char_u *eval_client_expr_to_string(char_u *expr);
+int sendToLocalVim(char_u *cmd, int asExpr, char_u **result);
+char_u *serverConvert(char_u *client_enc, char_u *data, char_u **tofree);
+void exec_on_server(mparm_T *parmp);
+void prepare_server(mparm_T *parmp);
+void f_remote_expr(typval_T *argvars, typval_T *rettv);
+void f_remote_foreground(typval_T *argvars, typval_T *rettv);
+void f_remote_peek(typval_T *argvars, typval_T *rettv);
+void f_remote_read(typval_T *argvars, typval_T *rettv);
+void f_remote_send(typval_T *argvars, typval_T *rettv);
+void f_remote_startserver(typval_T *argvars, typval_T *rettv);
+void f_server2client(typval_T *argvars, typval_T *rettv);
+void f_serverlist(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/clipboard.pro b/src/proto/clipboard.pro
new file mode 100644
index 0000000..f3e8cab
--- /dev/null
+++ b/src/proto/clipboard.pro
@@ -0,0 +1,38 @@
+/* clipboard.c */
+void clip_init(int can_use);
+void clip_update_selection(Clipboard_T *clip);
+void clip_own_selection(Clipboard_T *cbd);
+void clip_lose_selection(Clipboard_T *cbd);
+void start_global_changes(void);
+void end_global_changes(void);
+void clip_auto_select(void);
+int clip_isautosel_star(void);
+int clip_isautosel_plus(void);
+void clip_modeless(int button, int is_click, int is_drag);
+void clip_start_selection(int col, int row, int repeated_click);
+void clip_process_selection(int button, int col, int row, int_u repeated_click);
+void clip_may_redraw_selection(int row, int col, int len);
+void clip_clear_selection(Clipboard_T *cbd);
+void clip_may_clear_selection(int row1, int row2);
+void clip_scroll_selection(int rows);
+void clip_copy_modeless_selection(int both);
+void clip_gen_set_selection(Clipboard_T *cbd);
+int clip_gen_owner_exists(Clipboard_T *cbd);
+char *did_set_clipboard(optset_T *args);
+void open_app_context(void);
+void x11_setup_atoms(Display *dpy);
+void x11_setup_selection(Widget w);
+void clip_x11_request_selection(Widget myShell, Display *dpy, Clipboard_T *cbd);
+void clip_x11_lose_selection(Widget myShell, Clipboard_T *cbd);
+int clip_x11_own_selection(Widget myShell, Clipboard_T *cbd);
+void clip_x11_set_selection(Clipboard_T *cbd);
+void yank_cut_buffer0(Display *dpy, Clipboard_T *cbd);
+void x11_export_final_selection(void);
+void clip_free_selection(Clipboard_T *cbd);
+void clip_get_selection(Clipboard_T *cbd);
+void clip_yank_selection(int type, char_u *str, long len, Clipboard_T *cbd);
+int clip_convert_selection(char_u **str, long_u *len, Clipboard_T *cbd);
+int may_get_selection(int regname);
+void may_set_selection(void);
+void adjust_clip_reg(int *rp);
+/* vim: set ft=c : */
diff --git a/src/proto/cmdexpand.pro b/src/proto/cmdexpand.pro
new file mode 100644
index 0000000..1e2b148
--- /dev/null
+++ b/src/proto/cmdexpand.pro
@@ -0,0 +1,22 @@
+/* cmdexpand.c */
+int cmdline_fuzzy_complete(char_u *fuzzystr);
+int nextwild(expand_T *xp, int type, int options, int escape);
+void cmdline_pum_display(void);
+int cmdline_pum_active(void);
+void cmdline_pum_remove(void);
+void cmdline_pum_cleanup(cmdline_info_T *cclp);
+int cmdline_compl_startcol(void);
+char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode);
+void ExpandInit(expand_T *xp);
+void ExpandCleanup(expand_T *xp);
+int showmatches(expand_T *xp, int wildmenu);
+char_u *addstar(char_u *fname, int len, int context);
+void set_expand_context(expand_T *xp);
+void set_cmd_context(expand_T *xp, char_u *str, int len, int col, int use_ccline);
+int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char_u ***matches);
+void globpath(char_u *path, char_u *file, garray_T *ga, int expand_options, int dirs);
+int wildmenu_translate_key(cmdline_info_T *cclp, int key, expand_T *xp, int did_wild_list);
+int wildmenu_process_key(cmdline_info_T *cclp, int key, expand_T *xp);
+void wildmenu_cleanup(cmdline_info_T *cclp);
+void f_getcompletion(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/cmdhist.pro b/src/proto/cmdhist.pro
new file mode 100644
index 0000000..9c9e56c
--- /dev/null
+++ b/src/proto/cmdhist.pro
@@ -0,0 +1,19 @@
+/* cmdhist.c */
+int get_hislen(void);
+histentry_T *get_histentry(int hist_type);
+void set_histentry(int hist_type, histentry_T *entry);
+int *get_hisidx(int hist_type);
+int *get_hisnum(int hist_type);
+int hist_char2type(int c);
+char_u *get_history_arg(expand_T *xp, int idx);
+void init_history(void);
+void clear_hist_entry(histentry_T *hisptr);
+int in_history(int type, char_u *str, int move_to_front, int sep, int writing);
+void add_to_history(int histype, char_u *new_entry, int in_map, int sep);
+void f_histadd(typval_T *argvars, typval_T *rettv);
+void f_histdel(typval_T *argvars, typval_T *rettv);
+void f_histget(typval_T *argvars, typval_T *rettv);
+void f_histnr(typval_T *argvars, typval_T *rettv);
+void remove_key_from_history(void);
+void ex_history(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/crypt.pro b/src/proto/crypt.pro
new file mode 100644
index 0000000..560e30b
--- /dev/null
+++ b/src/proto/crypt.pro
@@ -0,0 +1,31 @@
+/* crypt.c */
+int sodium_enabled(int verbose);
+int crypt_method_nr_from_name(char_u *name);
+int crypt_method_nr_from_magic(char *ptr, int len);
+int crypt_works_inplace(cryptstate_T *state);
+int crypt_get_method_nr(buf_T *buf);
+int crypt_whole_undofile(int method_nr);
+int crypt_get_header_len(int method_nr);
+int crypt_get_max_header_len(void);
+void crypt_set_cm_option(buf_T *buf, int method_nr);
+int crypt_self_test(void);
+cryptstate_T *crypt_create(int method_nr, char_u *key, char_u *salt, int salt_len, char_u *seed, int seed_len);
+cryptstate_T *crypt_create_from_header(int method_nr, char_u *key, char_u *header);
+cryptstate_T *crypt_create_from_file(FILE *fp, char_u *key);
+cryptstate_T *crypt_create_for_writing(int method_nr, char_u *key, char_u **header, int *header_len);
+void crypt_free_state(cryptstate_T *state);
+long crypt_encode_alloc(cryptstate_T *state, char_u *from, size_t len, char_u **newptr, int last);
+long crypt_decode_alloc(cryptstate_T *state, char_u *ptr, long len, char_u **newptr, int last);
+void crypt_encode(cryptstate_T *state, char_u *from, size_t len, char_u *to, int last);
+void crypt_encode_inplace(cryptstate_T *state, char_u *buf, size_t len, int last);
+void crypt_decode_inplace(cryptstate_T *state, char_u *buf, size_t len, int last);
+void crypt_free_key(char_u *key);
+void crypt_check_method(int method);
+void crypt_check_current_method(void);
+char_u *crypt_get_key(int store, int twice);
+void crypt_append_msg(buf_T *buf);
+int crypt_sodium_munlock(void *const addr, const size_t len);
+void crypt_sodium_randombytes_buf(void *const buf, const size_t size);
+int crypt_sodium_init(void);
+uint32_t crypt_sodium_randombytes_random(void);
+/* vim: set ft=c : */
diff --git a/src/proto/crypt_zip.pro b/src/proto/crypt_zip.pro
new file mode 100644
index 0000000..626d985
--- /dev/null
+++ b/src/proto/crypt_zip.pro
@@ -0,0 +1,5 @@
+/* crypt_zip.c */
+int crypt_zip_init(cryptstate_T *state, char_u *key, char_u *salt, int salt_len, char_u *seed, int seed_len);
+void crypt_zip_encode(cryptstate_T *state, char_u *from, size_t len, char_u *to, int last);
+void crypt_zip_decode(cryptstate_T *state, char_u *from, size_t len, char_u *to, int last);
+/* vim: set ft=c : */
diff --git a/src/proto/debugger.pro b/src/proto/debugger.pro
new file mode 100644
index 0000000..d80ecf5
--- /dev/null
+++ b/src/proto/debugger.pro
@@ -0,0 +1,15 @@
+/* debugger.c */
+int has_watchexpr(void);
+void do_debug(char_u *cmd);
+void ex_debug(exarg_T *eap);
+void dbg_check_breakpoint(exarg_T *eap);
+int dbg_check_skipped(exarg_T *eap);
+void ex_breakadd(exarg_T *eap);
+void ex_debuggreedy(exarg_T *eap);
+int debug_has_expr_breakpoint(void);
+void ex_breakdel(exarg_T *eap);
+void ex_breaklist(exarg_T *eap);
+linenr_T dbg_find_breakpoint(int file, char_u *fname, linenr_T after);
+int has_profiling(int file, char_u *fname, int *fp);
+void dbg_breakpoint(char_u *name, linenr_T lnum);
+/* vim: set ft=c : */
diff --git a/src/proto/dict.pro b/src/proto/dict.pro
new file mode 100644
index 0000000..fdccca5
--- /dev/null
+++ b/src/proto/dict.pro
@@ -0,0 +1,52 @@
+/* dict.c */
+dict_T *dict_alloc(void);
+dict_T *dict_alloc_id(alloc_id_T id);
+dict_T *dict_alloc_lock(int lock);
+int rettv_dict_alloc(typval_T *rettv);
+void rettv_dict_set(typval_T *rettv, dict_T *d);
+void dict_free_contents(dict_T *d);
+void hashtab_free_contents(hashtab_T *ht);
+void dict_unref(dict_T *d);
+int dict_free_nonref(int copyID);
+void dict_free_items(int copyID);
+dictitem_T *dictitem_alloc(char_u *key);
+void dictitem_remove(dict_T *dict, dictitem_T *item, char *command);
+void dictitem_free(dictitem_T *item);
+dict_T *dict_copy(dict_T *orig, int deep, int top, int copyID);
+int dict_wrong_func_name(dict_T *d, typval_T *tv, char_u *name);
+int dict_add(dict_T *d, dictitem_T *item);
+int dict_add_number(dict_T *d, char *key, varnumber_T nr);
+int dict_add_bool(dict_T *d, char *key, varnumber_T nr);
+int dict_add_string(dict_T *d, char *key, char_u *str);
+int dict_add_string_len(dict_T *d, char *key, char_u *str, int len);
+int dict_add_list(dict_T *d, char *key, list_T *list);
+int dict_add_tv(dict_T *d, char *key, typval_T *tv);
+int dict_add_callback(dict_T *d, char *key, callback_T *cb);
+void dict_iterate_start(typval_T *var, dict_iterator_T *iter);
+char_u *dict_iterate_next(dict_iterator_T *iter, typval_T **tv_result);
+int dict_add_dict(dict_T *d, char *key, dict_T *dict);
+long dict_len(dict_T *d);
+dictitem_T *dict_find(dict_T *d, char_u *key, int len);
+int dict_has_key(dict_T *d, char *key);
+int dict_get_tv(dict_T *d, char *key, typval_T *rettv);
+char_u *dict_get_string(dict_T *d, char *key, int save);
+varnumber_T dict_get_number(dict_T *d, char *key);
+varnumber_T dict_get_number_def(dict_T *d, char *key, int def);
+varnumber_T dict_get_number_check(dict_T *d, char_u *key);
+varnumber_T dict_get_bool(dict_T *d, char *key, int def);
+char_u *dict2string(typval_T *tv, int copyID, int restore_copyID);
+char_u *get_literal_key(char_u **arg);
+int eval_dict(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int literal);
+void dict_extend(dict_T *d1, dict_T *d2, char_u *action, char *func_name);
+dictitem_T *dict_lookup(hashitem_T *hi);
+int dict_equal(dict_T *d1, dict_T *d2, int ic, int recursive);
+long dict_count(dict_T *d, typval_T *needle, int ic);
+void dict_extend_func(typval_T *argvars, type_T *type, char *func_name, char_u *arg_errmsg, int is_new, typval_T *rettv);
+void dict_filter_map(dict_T *d, filtermap_T filtermap, type_T *argtype, char *func_name, char_u *arg_errmsg, typval_T *expr, typval_T *rettv);
+void dict_remove(typval_T *argvars, typval_T *rettv, char_u *arg_errmsg);
+void f_items(typval_T *argvars, typval_T *rettv);
+void f_keys(typval_T *argvars, typval_T *rettv);
+void f_values(typval_T *argvars, typval_T *rettv);
+void dict_set_items_ro(dict_T *di);
+void f_has_key(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/diff.pro b/src/proto/diff.pro
new file mode 100644
index 0000000..d14907e
--- /dev/null
+++ b/src/proto/diff.pro
@@ -0,0 +1,33 @@
+/* diff.c */
+void diff_buf_delete(buf_T *buf);
+void diff_buf_adjust(win_T *win);
+void diff_buf_add(buf_T *buf);
+void diff_invalidate(buf_T *buf);
+void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
+void diff_redraw(int dofold);
+int diff_internal(void);
+void ex_diffupdate(exarg_T *eap);
+void ex_diffpatch(exarg_T *eap);
+void ex_diffsplit(exarg_T *eap);
+void ex_diffthis(exarg_T *eap);
+void diff_win_options(win_T *wp, int addbuf);
+void ex_diffoff(exarg_T *eap);
+void diff_clear(tabpage_T *tp);
+int diff_check(win_T *wp, linenr_T lnum);
+int diff_check_fill(win_T *wp, linenr_T lnum);
+void diff_set_topline(win_T *fromwin, win_T *towin);
+int diffopt_changed(void);
+int diffopt_horizontal(void);
+int diffopt_hiddenoff(void);
+int diffopt_closeoff(void);
+int diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp);
+int diff_infold(win_T *wp, linenr_T lnum);
+void nv_diffgetput(int put, long count);
+void ex_diffgetput(exarg_T *eap);
+int diff_mode_buf(buf_T *buf);
+int diff_move_to(int dir, long count);
+linenr_T diff_get_corresponding_line(buf_T *buf1, linenr_T lnum1);
+linenr_T diff_lnum_win(linenr_T lnum, win_T *wp);
+void f_diff_filler(typval_T *argvars, typval_T *rettv);
+void f_diff_hlID(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/digraph.pro b/src/proto/digraph.pro
new file mode 100644
index 0000000..0908935
--- /dev/null
+++ b/src/proto/digraph.pro
@@ -0,0 +1,15 @@
+/* digraph.c */
+int do_digraph(int c);
+char_u *get_digraph_for_char(int val_arg);
+int get_digraph(int cmdline);
+int digraph_get(int char1, int char2, int meta_char);
+void putdigraph(char_u *str);
+void listdigraphs(int use_headers);
+void f_digraph_get(typval_T *argvars, typval_T *rettv);
+void f_digraph_getlist(typval_T *argvars, typval_T *rettv);
+void f_digraph_set(typval_T *argvars, typval_T *rettv);
+void f_digraph_setlist(typval_T *argvars, typval_T *rettv);
+char *keymap_init(void);
+void ex_loadkeymap(exarg_T *eap);
+void keymap_clear(garray_T *kmap);
+/* vim: set ft=c : */
diff --git a/src/proto/drawline.pro b/src/proto/drawline.pro
new file mode 100644
index 0000000..fc6fb88
--- /dev/null
+++ b/src/proto/drawline.pro
@@ -0,0 +1,4 @@
+/* drawline.c */
+int text_prop_position(win_T *wp, textprop_T *tp, int vcol, int scr_col, int *n_extra, char_u **p_extra, int *n_attr, int *n_attr_skip, int do_skip);
+int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int nochange, int number_only);
+/* vim: set ft=c : */
diff --git a/src/proto/drawscreen.pro b/src/proto/drawscreen.pro
new file mode 100644
index 0000000..6fa5e2c
--- /dev/null
+++ b/src/proto/drawscreen.pro
@@ -0,0 +1,27 @@
+/* drawscreen.c */
+int update_screen(int type_arg);
+int statusline_row(win_T *wp);
+void win_redr_status(win_T *wp, int ignore_pum);
+void showruler(int always);
+void win_redr_ruler(win_T *wp, int always, int ignore_pum);
+void after_updating_screen(int may_resize_shell);
+void update_curbuf(int type);
+void update_debug_sign(buf_T *buf, linenr_T lnum);
+void updateWindow(win_T *wp);
+int redraw_asap(int type);
+void redraw_after_callback(int call_update_screen, int do_message);
+void redraw_later(int type);
+void redraw_win_later(win_T *wp, int type);
+void redraw_later_clear(void);
+void redraw_all_later(int type);
+void set_must_redraw(int type);
+void redraw_curbuf_later(int type);
+void redraw_buf_later(buf_T *buf, int type);
+void redraw_buf_line_later(buf_T *buf, linenr_T lnum);
+void redraw_buf_and_status_later(buf_T *buf, int type);
+void status_redraw_all(void);
+void status_redraw_curbuf(void);
+void redraw_statuslines(void);
+void win_redraw_last_status(frame_T *frp);
+void redrawWinline(win_T *wp, linenr_T lnum);
+/* vim: set ft=c : */
diff --git a/src/proto/edit.pro b/src/proto/edit.pro
new file mode 100644
index 0000000..4513f4f
--- /dev/null
+++ b/src/proto/edit.pro
@@ -0,0 +1,42 @@
+/* edit.c */
+int edit(int cmdchar, int startln, long count);
+int ins_need_undo_get(void);
+void ins_redraw(int ready);
+void edit_putchar(int c, int highlight);
+void set_insstart(linenr_T lnum, int col);
+void edit_unputchar(void);
+void display_dollar(colnr_T col_arg);
+void undisplay_dollar(void);
+void truncate_spaces(char_u *line);
+void backspace_until_column(int col);
+int get_literal(int noReduceKeys);
+void insertchar(int c, int flags, int second_indent);
+void start_arrow(pos_T *end_insert_pos);
+int stop_arrow(void);
+void set_last_insert(int c);
+void free_last_insert(void);
+char_u *add_char2buf(int c, char_u *s);
+void beginline(int flags);
+int oneright(void);
+int oneleft(void);
+linenr_T cursor_up_inner(win_T *wp, long n);
+int cursor_up(long n, int upd_topline);
+linenr_T cursor_down_inner(win_T *wp, long n);
+int cursor_down(long n, int upd_topline);
+int stuff_inserted(int c, long count, int no_esc);
+char_u *get_last_insert(void);
+char_u *get_last_insert_save(void);
+void replace_push(int c);
+int replace_push_mb(char_u *p);
+void replace_join(int off);
+int hkmap(int c);
+int bracketed_paste(paste_mode_T mode, int drop, garray_T *gap);
+void ins_scroll(void);
+void ins_horscroll(void);
+int ins_eol(int c);
+int ins_copychar(linenr_T lnum);
+colnr_T get_nolist_virtcol(void);
+int get_can_cindent(void);
+void set_can_cindent(int val);
+int ins_apply_autocmds(event_T event);
+/* vim: set ft=c : */
diff --git a/src/proto/eval.pro b/src/proto/eval.pro
new file mode 100644
index 0000000..afc4d61
--- /dev/null
+++ b/src/proto/eval.pro
@@ -0,0 +1,86 @@
+/* eval.c */
+varnumber_T num_divide(varnumber_T n1, varnumber_T n2, int *failed);
+varnumber_T num_modulus(varnumber_T n1, varnumber_T n2, int *failed);
+void eval_init(void);
+void eval_clear(void);
+void fill_evalarg_from_eap(evalarg_T *evalarg, exarg_T *eap, int skip);
+int eval_to_bool(char_u *arg, int *error, exarg_T *eap, int skip, int use_simple_function);
+int eval_expr_valid_arg(typval_T *tv);
+funccall_T *eval_expr_get_funccal(typval_T *expr, typval_T *rettv);
+int eval_expr_typval(typval_T *expr, typval_T *argv, int argc, funccall_T *fc_arg, typval_T *rettv);
+int eval_expr_to_bool(typval_T *expr, int *error);
+char_u *eval_to_string_skip(char_u *arg, exarg_T *eap, int skip);
+void init_evalarg(evalarg_T *evalarg);
+void clear_evalarg(evalarg_T *evalarg, exarg_T *eap);
+int skip_expr(char_u **pp, evalarg_T *evalarg);
+int skip_expr_concatenate(char_u **arg, char_u **start, char_u **end, evalarg_T *evalarg);
+char_u *typval2string(typval_T *tv, int convert);
+char_u *eval_to_string_eap(char_u *arg, int convert, exarg_T *eap, int use_simple_function);
+char_u *eval_to_string(char_u *arg, int convert, int use_simple_function);
+char_u *eval_to_string_safe(char_u *arg, int use_sandbox, int keep_script_version, int use_simple_function);
+varnumber_T eval_to_number(char_u *expr, int use_simple_function);
+typval_T *eval_expr(char_u *arg, exarg_T *eap);
+typval_T *eval_expr_ext(char_u *arg, exarg_T *eap, int use_simple_function);
+int call_vim_function(char_u *func, int argc, typval_T *argv, typval_T *rettv);
+void *call_func_retstr(char_u *func, int argc, typval_T *argv);
+void *call_func_retlist(char_u *func, int argc, typval_T *argv);
+int eval_foldexpr(win_T *wp, int *cp);
+char_u *get_lval(char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int flags, int fne_flags);
+void clear_lval(lval_T *lp);
+void set_var_lval(lval_T *lp, char_u *endp, typval_T *rettv, int copy, int flags, char_u *op, int var_idx);
+int tv_op(typval_T *tv1, typval_T *tv2, char_u *op);
+void *eval_for_line(char_u *arg, int *errp, exarg_T *eap, evalarg_T *evalarg);
+void skip_for_lines(void *fi_void, evalarg_T *evalarg);
+int next_for_item(void *fi_void, char_u *arg);
+void free_for_info(void *fi_void);
+void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx);
+int pattern_match(char_u *pat, char_u *text, int ic);
+char_u *eval_next_non_blank(char_u *arg, evalarg_T *evalarg, int *getnext);
+char_u *eval_next_line(char_u *arg, evalarg_T *evalarg);
+char_u *skipwhite_and_linebreak(char_u *arg, evalarg_T *evalarg);
+int eval0(char_u *arg, typval_T *rettv, exarg_T *eap, evalarg_T *evalarg);
+int may_call_simple_func(char_u *arg, typval_T *rettv);
+int eval0_simple_funccal(char_u *arg, typval_T *rettv, exarg_T *eap, evalarg_T *evalarg);
+int eval0_retarg(char_u *arg, typval_T *rettv, exarg_T *eap, evalarg_T *evalarg, char_u **retarg);
+int eval1(char_u **arg, typval_T *rettv, evalarg_T *evalarg);
+void eval_addblob(typval_T *tv1, typval_T *tv2);
+int eval_addlist(typval_T *tv1, typval_T *tv2);
+int eval_leader(char_u **arg, int vim9);
+int handle_predefined(char_u *s, int len, typval_T *rettv);
+int check_can_index(typval_T *rettv, int evaluate, int verbose);
+void f_slice(typval_T *argvars, typval_T *rettv);
+int eval_index_inner(typval_T *rettv, int is_range, typval_T *var1, typval_T *var2, int exclusive, char_u *key, int keylen, int verbose);
+char_u *partial_name(partial_T *pt);
+void partial_unref(partial_T *pt);
+int get_copyID(void);
+int garbage_collect(int testing);
+int set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack);
+int set_ref_in_dict(dict_T *d, int copyID);
+int set_ref_in_list(list_T *ll, int copyID);
+int set_ref_in_list_items(list_T *l, int copyID, ht_stack_T **ht_stack);
+int set_ref_in_callback(callback_T *cb, int copyID);
+int set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack_T **list_stack);
+char_u *echo_string_core(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID, int echo_style, int restore_copyID, int composite_val);
+char_u *echo_string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);
+int buf_byteidx_to_charidx(buf_T *buf, int lnum, int byteidx);
+int buf_charidx_to_byteidx(buf_T *buf, int lnum, int charidx);
+pos_T *var2fpos(typval_T *varp, int dollar_lnum, int *fnum, int charcol);
+int list2fpos(typval_T *arg, pos_T *posp, int *fnump, colnr_T *curswantp, int charcol);
+int get_env_len(char_u **arg);
+int get_id_len(char_u **arg);
+int get_name_len(char_u **arg, char_u **alias, int evaluate, int verbose);
+char_u *find_name_end(char_u *arg, char_u **expr_start, char_u **expr_end, int flags);
+int eval_isnamec(int c);
+int eval_isnamec1(int c);
+int eval_isdictc(int c);
+int handle_subscript(char_u **arg, char_u *name_start, typval_T *rettv, evalarg_T *evalarg, int verbose);
+int item_copy(typval_T *from, typval_T *to, int deep, int top, int copyID);
+void echo_one(typval_T *rettv, int with_space, int *atstart, int *needclr);
+void ex_echo(exarg_T *eap);
+void ex_echohl(exarg_T *eap);
+int get_echo_attr(void);
+void ex_execute(exarg_T *eap);
+char_u *find_option_end(char_u **arg, int *scope);
+void last_set_msg(sctx_T script_ctx);
+char_u *do_string_sub(char_u *str, char_u *pat, char_u *sub, typval_T *expr, char_u *flags);
+/* vim: set ft=c : */
diff --git a/src/proto/evalbuffer.pro b/src/proto/evalbuffer.pro
new file mode 100644
index 0000000..d8ccdec
--- /dev/null
+++ b/src/proto/evalbuffer.pro
@@ -0,0 +1,27 @@
+/* evalbuffer.c */
+int set_ref_in_buffers(int copyID);
+buf_T *buflist_find_by_name(char_u *name, int curtab_only);
+buf_T *find_buffer(typval_T *avar);
+void f_append(typval_T *argvars, typval_T *rettv);
+void f_appendbufline(typval_T *argvars, typval_T *rettv);
+void f_bufadd(typval_T *argvars, typval_T *rettv);
+void f_bufexists(typval_T *argvars, typval_T *rettv);
+void f_buflisted(typval_T *argvars, typval_T *rettv);
+void f_bufload(typval_T *argvars, typval_T *rettv);
+void f_bufloaded(typval_T *argvars, typval_T *rettv);
+void f_bufname(typval_T *argvars, typval_T *rettv);
+void f_bufnr(typval_T *argvars, typval_T *rettv);
+void f_bufwinid(typval_T *argvars, typval_T *rettv);
+void f_bufwinnr(typval_T *argvars, typval_T *rettv);
+void f_deletebufline(typval_T *argvars, typval_T *rettv);
+void f_getbufinfo(typval_T *argvars, typval_T *rettv);
+void f_getbufline(typval_T *argvars, typval_T *rettv);
+void f_getbufoneline(typval_T *argvars, typval_T *rettv);
+void f_getline(typval_T *argvars, typval_T *rettv);
+void f_setbufline(typval_T *argvars, typval_T *rettv);
+void f_setline(typval_T *argvars, typval_T *rettv);
+void switch_buffer(bufref_T *save_curbuf, buf_T *buf);
+void restore_buffer(bufref_T *save_curbuf);
+void switch_to_win_for_buf(buf_T *buf, switchwin_T *switchwin, bufref_T *save_curbuf);
+void restore_win_for_buf(switchwin_T *switchwin, bufref_T *save_curbuf);
+/* vim: set ft=c : */
diff --git a/src/proto/evalfunc.pro b/src/proto/evalfunc.pro
new file mode 100644
index 0000000..a720b64
--- /dev/null
+++ b/src/proto/evalfunc.pro
@@ -0,0 +1,30 @@
+/* evalfunc.c */
+int arg_type_modifiable(type_T *type, int arg_idx);
+char_u *get_function_name(expand_T *xp, int idx);
+char_u *get_expr_name(expand_T *xp, int idx);
+int find_internal_func(char_u *name);
+int has_internal_func(char_u *name);
+char *internal_func_name(int idx);
+int internal_func_check_arg_types(type2_T *types, int idx, int argcount, cctx_T *cctx);
+void internal_func_get_argcount(int idx, int *argcount, int *min_argcount);
+type_T *internal_func_ret_type(int idx, int argcount, type2_T *argtypes, type_T **decl_type, garray_T *type_gap);
+int internal_func_is_map(int idx);
+int check_internal_func(int idx, int argcount);
+funcerror_T call_internal_func(char_u *name, int argcount, typval_T *argvars, typval_T *rettv);
+void call_internal_func_by_idx(int idx, typval_T *argvars, typval_T *rettv);
+funcerror_T call_internal_method(char_u *name, int argcount, typval_T *argvars, typval_T *rettv, typval_T *basetv);
+int non_zero_arg(typval_T *argvars);
+buf_T *get_buf_arg(typval_T *arg);
+win_T *get_optional_window(typval_T *argvars, int idx);
+void execute_redir_str(char_u *value, int value_len);
+void execute_cmds_from_string(char_u *str);
+char_u *get_list_line(int c, void *cookie, int indent, getline_opt_T options);
+void execute_common(typval_T *argvars, typval_T *rettv, int arg_off);
+void f_exists(typval_T *argvars, typval_T *rettv);
+void f_has(typval_T *argvars, typval_T *rettv);
+int dynamic_feature(char_u *feature);
+void f_len(typval_T *argvars, typval_T *rettv);
+void mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv);
+void range_list_materialize(list_T *list);
+long do_searchpair(char_u *spat, char_u *mpat, char_u *epat, int dir, typval_T *skip, int flags, pos_T *match_pos, linenr_T lnum_stop, long time_limit);
+/* vim: set ft=c : */
diff --git a/src/proto/evalvars.pro b/src/proto/evalvars.pro
new file mode 100644
index 0000000..661cb59
--- /dev/null
+++ b/src/proto/evalvars.pro
@@ -0,0 +1,111 @@
+/* evalvars.c */
+void evalvars_init(void);
+void evalvars_clear(void);
+int garbage_collect_globvars(int copyID);
+int garbage_collect_vimvars(int copyID);
+int garbage_collect_scriptvars(int copyID);
+void set_internal_string_var(char_u *name, char_u *value);
+int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to);
+int eval_printexpr(char_u *fname, char_u *args);
+void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile);
+void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile);
+list_T *eval_spell_expr(char_u *badword, char_u *expr);
+int get_spellword(list_T *list, char_u **pp);
+void prepare_vimvar(int idx, typval_T *save_tv);
+void restore_vimvar(int idx, typval_T *save_tv);
+int is_scoped_variable(char_u *name);
+char_u *eval_one_expr_in_str(char_u *p, garray_T *gap, int evaluate);
+list_T *heredoc_get(exarg_T *eap, char_u *cmd, int script_get, int vim9compile);
+void ex_var(exarg_T *eap);
+void ex_let(exarg_T *eap);
+int ex_let_vars(char_u *arg_start, typval_T *tv, int copy, int semicolon, int var_count, int flags, char_u *op);
+char_u *skip_var_list(char_u *arg, int include_type, int *var_count, int *semicolon, int silent);
+char_u *skip_var_one(char_u *arg, int include_type);
+void list_hashtable_vars(hashtab_T *ht, char *prefix, int empty, int *first);
+void ex_unlet(exarg_T *eap);
+void ex_lockvar(exarg_T *eap);
+void ex_unletlock(exarg_T *eap, char_u *argstart, int deep, int glv_flags, int (*callback)(lval_T *, char_u *, exarg_T *, int, void *), void *cookie);
+void list_unlet_range(list_T *l, listitem_T *li_first, long n1_arg, int has_n2, long n2);
+int do_unlet(char_u *name, int forceit);
+void item_lock(typval_T *tv, int deep, int lock, int check_refcount);
+void del_menutrans_vars(void);
+char_u *cat_prefix_varname(int prefix, char_u *name);
+char_u *get_user_var_name(expand_T *xp, int idx);
+char *get_var_special_name(int nr);
+dict_T *get_globvar_dict(void);
+hashtab_T *get_globvar_ht(void);
+dict_T *get_vimvar_dict(void);
+int find_vim_var(char_u *name, int *di_flags);
+void set_vim_var_type(int idx, vartype_T type);
+void set_vim_var_nr(int idx, varnumber_T val);
+char *get_vim_var_name(int idx);
+typval_T *get_vim_var_tv(int idx);
+type_T *get_vim_var_type(int idx, garray_T *type_list);
+int set_vim_var_tv(int idx, typval_T *tv);
+varnumber_T get_vim_var_nr(int idx);
+char_u *get_vim_var_str(int idx);
+list_T *get_vim_var_list(int idx);
+dict_T *get_vim_var_dict(int idx);
+void set_vim_var_char(int c);
+void set_vcount(long count, long count1, int set_prevcount);
+void save_vimvars(vimvars_save_T *vvsave);
+void restore_vimvars(vimvars_save_T *vvsave);
+void set_vim_var_string(int idx, char_u *val, int len);
+void set_vim_var_list(int idx, list_T *val);
+void set_vim_var_dict(int idx, dict_T *val);
+void set_argv_var(char **argv, int argc);
+void reset_reg_var(void);
+void set_reg_var(int c);
+char_u *v_exception(char_u *oldval);
+char_u *v_throwpoint(char_u *oldval);
+char_u *set_cmdarg(exarg_T *eap, char_u *oldarg);
+int eval_variable(char_u *name, int len, scid_T sid, typval_T *rettv, dictitem_T **dip, int flags);
+int eval_variable_import(char_u *name, typval_T *rettv);
+void check_vars(char_u *name, int len);
+dictitem_T *find_var(char_u *name, hashtab_T **htp, int no_autoload);
+dictitem_T *find_var_also_in_script(char_u *name, hashtab_T **htp, int no_autoload);
+dictitem_T *find_var_in_ht(hashtab_T *ht, int htname, char_u *varname, int no_autoload);
+hashtab_T *get_script_local_ht(void);
+int lookup_scriptitem(char_u *name, size_t len, int cmd, cctx_T *dummy);
+hashtab_T *find_var_ht(char_u *name, char_u **varname);
+char_u *get_var_value(char_u *name);
+void new_script_vars(scid_T id);
+void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope);
+void unref_var_dict(dict_T *dict);
+void vars_clear(hashtab_T *ht);
+void vars_clear_ext(hashtab_T *ht, int free_val);
+void delete_var(hashtab_T *ht, hashitem_T *hi);
+void set_var(char_u *name, typval_T *tv, int copy);
+void set_var_const(char_u *name, scid_T sid, type_T *type_arg, typval_T *tv_arg, int copy, int flags_arg, int var_idx);
+int var_check_permission(dictitem_T *di, char_u *name);
+int var_check_ro(int flags, char_u *name, int use_gettext);
+int var_check_lock(int flags, char_u *name, int use_gettext);
+int var_check_fixed(int flags, char_u *name, int use_gettext);
+int var_wrong_func_name(char_u *name, int new_var);
+int value_check_lock(int lock, char_u *name, int use_gettext);
+int valid_varname(char_u *varname, int len, int autoload);
+void reset_v_option_vars(void);
+void assert_error(garray_T *gap);
+int var_exists(char_u *var);
+int alloc_redir_lval(void);
+void clear_redir_lval(void);
+void init_redir_ga(void);
+int var_redir_start(char_u *name, int append);
+void var_redir_str(char_u *value, int value_len);
+void var_redir_stop(void);
+char_u *get_clear_redir_ga(void);
+void f_gettabvar(typval_T *argvars, typval_T *rettv);
+void f_gettabwinvar(typval_T *argvars, typval_T *rettv);
+void f_getwinvar(typval_T *argvars, typval_T *rettv);
+void f_getbufvar(typval_T *argvars, typval_T *rettv);
+void f_settabvar(typval_T *argvars, typval_T *rettv);
+void f_settabwinvar(typval_T *argvars, typval_T *rettv);
+void f_setwinvar(typval_T *argvars, typval_T *rettv);
+void f_setbufvar(typval_T *argvars, typval_T *rettv);
+callback_T get_callback(typval_T *arg);
+void put_callback(callback_T *cb, typval_T *tv);
+void set_callback(callback_T *dest, callback_T *src);
+void copy_callback(callback_T *dest, callback_T *src);
+void expand_autload_callback(callback_T *cb);
+void free_callback(callback_T *callback);
+/* vim: set ft=c : */
diff --git a/src/proto/evalwindow.pro b/src/proto/evalwindow.pro
new file mode 100644
index 0000000..b2f8981
--- /dev/null
+++ b/src/proto/evalwindow.pro
@@ -0,0 +1,41 @@
+/* evalwindow.c */
+win_T *win_id2wp(int id);
+win_T *win_id2wp_tp(int id, tabpage_T **tpp);
+void win_findbuf(typval_T *argvars, list_T *list);
+win_T *find_win_by_nr(typval_T *vp, tabpage_T *tp);
+win_T *find_win_by_nr_or_id(typval_T *vp);
+win_T *find_tabwin(typval_T *wvp, typval_T *tvp, tabpage_T **ptp);
+void f_gettabinfo(typval_T *argvars, typval_T *rettv);
+void f_getwininfo(typval_T *argvars, typval_T *rettv);
+void f_getwinpos(typval_T *argvars, typval_T *rettv);
+void f_getwinposx(typval_T *argvars, typval_T *rettv);
+void f_getwinposy(typval_T *argvars, typval_T *rettv);
+void f_tabpagenr(typval_T *argvars, typval_T *rettv);
+void f_tabpagewinnr(typval_T *argvars, typval_T *rettv);
+void f_win_execute(typval_T *argvars, typval_T *rettv);
+void f_win_findbuf(typval_T *argvars, typval_T *rettv);
+void f_win_getid(typval_T *argvars, typval_T *rettv);
+void f_win_gotoid(typval_T *argvars, typval_T *rettv);
+void f_win_id2tabwin(typval_T *argvars, typval_T *rettv);
+void f_win_id2win(typval_T *argvars, typval_T *rettv);
+void f_win_move_separator(typval_T *argvars, typval_T *rettv);
+void f_win_move_statusline(typval_T *argvars, typval_T *rettv);
+void f_win_screenpos(typval_T *argvars, typval_T *rettv);
+void f_win_splitmove(typval_T *argvars, typval_T *rettv);
+void f_win_gettype(typval_T *argvars, typval_T *rettv);
+void f_getcmdwintype(typval_T *argvars, typval_T *rettv);
+void f_winbufnr(typval_T *argvars, typval_T *rettv);
+void f_wincol(typval_T *argvars, typval_T *rettv);
+void f_winheight(typval_T *argvars, typval_T *rettv);
+void f_winlayout(typval_T *argvars, typval_T *rettv);
+void f_winline(typval_T *argvars, typval_T *rettv);
+void f_winnr(typval_T *argvars, typval_T *rettv);
+void f_winrestcmd(typval_T *argvars, typval_T *rettv);
+void f_winrestview(typval_T *argvars, typval_T *rettv);
+void f_winsaveview(typval_T *argvars, typval_T *rettv);
+void f_winwidth(typval_T *argvars, typval_T *rettv);
+int switch_win(switchwin_T *switchwin, win_T *win, tabpage_T *tp, int no_display);
+int switch_win_noblock(switchwin_T *switchwin, win_T *win, tabpage_T *tp, int no_display);
+void restore_win(switchwin_T *switchwin, int no_display);
+void restore_win_noblock(switchwin_T *switchwin, int no_display);
+/* vim: set ft=c : */
diff --git a/src/proto/ex_cmds.pro b/src/proto/ex_cmds.pro
new file mode 100644
index 0000000..c083cec
--- /dev/null
+++ b/src/proto/ex_cmds.pro
@@ -0,0 +1,44 @@
+/* ex_cmds.c */
+void do_ascii(exarg_T *eap);
+void ex_align(exarg_T *eap);
+void ex_sort(exarg_T *eap);
+int do_move(linenr_T line1, linenr_T line2, linenr_T dest);
+void ex_copy(linenr_T line1, linenr_T line2, linenr_T n);
+void free_prev_shellcmd(void);
+void do_bang(int addr_count, exarg_T *eap, int forceit, int do_in, int do_out);
+void do_shell(char_u *cmd, int flags);
+char_u *make_filter_cmd(char_u *cmd, char_u *itmp, char_u *otmp);
+void append_redir(char_u *buf, int buflen, char_u *opt, char_u *fname);
+void do_fixdel(exarg_T *eap);
+void print_line_no_prefix(linenr_T lnum, int use_number, int list);
+void print_line(linenr_T lnum, int use_number, int list);
+int rename_buffer(char_u *new_fname);
+void ex_file(exarg_T *eap);
+void ex_update(exarg_T *eap);
+void ex_write(exarg_T *eap);
+int do_write(exarg_T *eap);
+int check_overwrite(exarg_T *eap, buf_T *buf, char_u *fname, char_u *ffname, int other);
+void ex_wnext(exarg_T *eap);
+void do_wqall(exarg_T *eap);
+int getfile(int fnum, char_u *ffname_arg, char_u *sfname_arg, int setpm, linenr_T lnum, int forceit);
+int do_ecmd(int fnum, char_u *ffname, char_u *sfname, exarg_T *eap, linenr_T newlnum, int flags, win_T *oldwin);
+void ex_append(exarg_T *eap);
+void ex_change(exarg_T *eap);
+void ex_z(exarg_T *eap);
+int check_restricted(void);
+int check_secure(void);
+char_u *skip_substitute(char_u *start, int delimiter);
+void ex_substitute(exarg_T *eap);
+int do_sub_msg(int count_only);
+void ex_global(exarg_T *eap);
+void global_exe(char_u *cmd);
+char_u *get_old_sub(void);
+void set_old_sub(char_u *val);
+void free_old_sub(void);
+int prepare_tagpreview(int undo_sync, int use_previewpopup, use_popup_T use_popup);
+void ex_smile(exarg_T *eap);
+void ex_drop(exarg_T *eap);
+char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags);
+char_u *skip_vimgrep_pat_ext(char_u *p, char_u **s, int *flags, char_u **nulp, int *cp);
+void ex_oldfiles(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/ex_cmds2.pro b/src/proto/ex_cmds2.pro
new file mode 100644
index 0000000..127e018
--- /dev/null
+++ b/src/proto/ex_cmds2.pro
@@ -0,0 +1,18 @@
+/* ex_cmds2.c */
+int autowrite(buf_T *buf, int forceit);
+void autowrite_all(void);
+int check_changed(buf_T *buf, int flags);
+void browse_save_fname(buf_T *buf);
+void dialog_changed(buf_T *buf, int checkall);
+int can_abandon(buf_T *buf, int forceit);
+int check_changed_any(int hidden, int unload);
+int check_fname(void);
+int buf_write_all(buf_T *buf, int forceit);
+void ex_listdo(exarg_T *eap);
+void ex_compiler(exarg_T *eap);
+void init_pyxversion(void);
+void ex_pyxfile(exarg_T *eap);
+void ex_pyx(exarg_T *eap);
+void ex_pyxdo(exarg_T *eap);
+void ex_checktime(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/ex_docmd.pro b/src/proto/ex_docmd.pro
new file mode 100644
index 0000000..f5d7a48
--- /dev/null
+++ b/src/proto/ex_docmd.pro
@@ -0,0 +1,75 @@
+/* ex_docmd.c */
+void do_exmode(int improved);
+int do_cmdline_cmd(char_u *cmd);
+int do_cmdline(char_u *cmdline, char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie, int flags);
+void handle_did_throw(void);
+int getline_equal(char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie, char_u *(*func)(int, void *, int, getline_opt_T));
+void *getline_cookie(char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
+char_u *getline_peek(char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
+char *ex_errmsg(char *msg, char_u *arg);
+char *ex_range_without_command(exarg_T *eap);
+int checkforcmd(char_u **pp, char *cmd, int len);
+int checkforcmd_noparen(char_u **pp, char *cmd, int len);
+int parse_command_modifiers(exarg_T *eap, char **errormsg, cmdmod_T *cmod, int skip_only);
+int has_cmdmod(cmdmod_T *cmod, int ignore_silent);
+int cmdmod_error(int ignore_silent);
+void apply_cmdmod(cmdmod_T *cmod);
+void undo_cmdmod(cmdmod_T *cmod);
+int parse_cmd_address(exarg_T *eap, char **errormsg, int silent);
+char_u *skip_option_env_lead(char_u *start);
+int number_method(char_u *cmd);
+char_u *find_ex_command(exarg_T *eap, int *full, int (*lookup)(char_u *, size_t, int cmd, cctx_T *), cctx_T *cctx);
+int modifier_len(char_u *cmd);
+int cmd_exists(char_u *name);
+void f_fullcommand(typval_T *argvars, typval_T *rettv);
+cmdidx_T excmd_get_cmdidx(char_u *cmd, int len);
+long excmd_get_argt(cmdidx_T idx);
+char_u *skip_range(char_u *cmd_start, int skip_star, int *ctx);
+void ex_ni(exarg_T *eap);
+int expand_filename(exarg_T *eap, char_u **cmdlinep, char **errormsgp);
+void separate_nextcmd(exarg_T *eap, int keep_backslash);
+char_u *skip_cmd_arg(char_u *p, int rembs);
+int get_bad_opt(char_u *p, exarg_T *eap);
+int ends_excmd(int c);
+int ends_excmd2(char_u *cmd_start, char_u *cmd);
+char_u *find_nextcmd(char_u *p);
+char_u *check_nextcmd(char_u *p);
+void set_nextcmd(exarg_T *eap, char_u *arg);
+char_u *get_command_name(expand_T *xp, int idx);
+void not_exiting(void);
+int before_quit_autocmds(win_T *wp, int quit_all, int forceit);
+void ex_quit(exarg_T *eap);
+void tabpage_close(int forceit);
+void tabpage_close_other(tabpage_T *tp, int forceit);
+void ex_stop(exarg_T *eap);
+void handle_drop(int filec, char_u **filev, int split, void (*callback)(void *), void *cookie);
+void handle_any_postponed_drop(void);
+void ex_splitview(exarg_T *eap);
+void tabpage_new(void);
+void do_exedit(exarg_T *eap, win_T *old_curwin);
+void free_cd_dir(void);
+void post_chdir(cdscope_T scope);
+void trigger_DirChangedPre(char_u *acmd_fname, char_u *new_dir);
+int changedir_func(char_u *new_dir, int forceit, cdscope_T scope);
+void ex_cd(exarg_T *eap);
+void do_sleep(long msec, int hide_cursor);
+void ex_may_print(exarg_T *eap);
+void ex_redraw(exarg_T *eap);
+void redraw_cmd(int clear);
+int vim_mkdir_emsg(char_u *name, int prot);
+FILE *open_exfile(char_u *fname, int forceit, char *mode);
+void update_topline_cursor(void);
+int save_current_state(save_state_T *sst);
+void restore_current_state(save_state_T *sst);
+void ex_normal(exarg_T *eap);
+void exec_normal_cmd(char_u *cmd, int remap, int silent);
+void exec_normal(int was_typed, int use_vpeekc, int may_use_terminal_loop);
+int find_cmdline_var(char_u *src, int *usedlen);
+char_u *eval_vars(char_u *src, char_u *srcstart, int *usedlen, linenr_T *lnump, char **errormsg, int *escaped, int empty_is_error);
+char_u *expand_sfile(char_u *arg);
+void dialog_msg(char_u *buff, char *format, char_u *fname);
+void set_no_hlsearch(int flag);
+int is_loclist_cmd(int cmdidx);
+int get_pressedreturn(void);
+void set_pressedreturn(int val);
+/* vim: set ft=c : */
diff --git a/src/proto/ex_eval.pro b/src/proto/ex_eval.pro
new file mode 100644
index 0000000..a3be429
--- /dev/null
+++ b/src/proto/ex_eval.pro
@@ -0,0 +1,39 @@
+/* ex_eval.c */
+int aborting(void);
+void update_force_abort(void);
+int should_abort(int retcode);
+int aborted_in_try(void);
+int cause_errthrow(char_u *mesg, int severe, int *ignore);
+void free_global_msglist(void);
+void do_errthrow(cstack_T *cstack, char_u *cmdname);
+int do_intthrow(cstack_T *cstack);
+char *get_exception_string(void *value, except_type_T type, char_u *cmdname, int *should_free);
+int throw_exception(void *value, except_type_T type, char_u *cmdname);
+void discard_current_exception(void);
+void catch_exception(except_T *excp);
+void report_make_pending(int pending, void *value);
+int cmd_is_name_only(char_u *arg);
+void ex_eval(exarg_T *eap);
+void ex_if(exarg_T *eap);
+void ex_endif(exarg_T *eap);
+void ex_else(exarg_T *eap);
+void ex_while(exarg_T *eap);
+void ex_continue(exarg_T *eap);
+void ex_break(exarg_T *eap);
+void ex_endwhile(exarg_T *eap);
+void ex_block(exarg_T *eap);
+void ex_endblock(exarg_T *eap);
+int inside_block(exarg_T *eap);
+void ex_throw(exarg_T *eap);
+void do_throw(cstack_T *cstack);
+void ex_try(exarg_T *eap);
+void ex_catch(exarg_T *eap);
+void ex_finally(exarg_T *eap);
+void ex_endtry(exarg_T *eap);
+void enter_cleanup(cleanup_T *csp);
+void leave_cleanup(cleanup_T *csp);
+int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive);
+void rewind_conditionals(cstack_T *cstack, int idx, int cond_type, int *cond_level);
+void ex_endfunction(exarg_T *eap);
+int has_loop_cmd(char_u *p);
+/* vim: set ft=c : */
diff --git a/src/proto/ex_getln.pro b/src/proto/ex_getln.pro
new file mode 100644
index 0000000..956916d
--- /dev/null
+++ b/src/proto/ex_getln.pro
@@ -0,0 +1,46 @@
+/* ex_getln.c */
+void cmdline_init(void);
+char_u *getcmdline(int firstc, long count, int indent, getline_opt_T do_concat);
+char_u *getcmdline_prompt(int firstc, char_u *prompt, int attr, int xp_context, char_u *xp_arg);
+int check_opt_wim(void);
+int text_locked(void);
+void text_locked_msg(void);
+char *get_text_locked_msg(void);
+int text_or_buf_locked(void);
+int curbuf_locked(void);
+int allbuf_locked(void);
+char_u *getexline(int c, void *cookie, int indent, getline_opt_T options);
+char_u *getexmodeline(int promptc, void *cookie, int indent, getline_opt_T options);
+int cmdline_overstrike(void);
+int cmdline_at_end(void);
+colnr_T cmdline_getvcol_cursor(void);
+int realloc_cmdbuff(int len);
+void free_arshape_buf(void);
+void putcmdline(int c, int shift);
+void unputcmdline(void);
+int put_on_cmdline(char_u *str, int len, int redraw);
+void cmdline_paste_str(char_u *s, int literally);
+void redrawcmdline(void);
+void redrawcmdline_ex(int do_compute_cmdrow);
+void redrawcmd(void);
+void compute_cmdrow(void);
+void cursorcmd(void);
+void gotocmdline(int clr);
+char_u *vim_strsave_fnameescape(char_u *fname, int what);
+void escape_fname(char_u **pp);
+void tilde_replace(char_u *orig_pat, int num_files, char_u **files);
+cmdline_info_T *get_cmdline_info(void);
+void f_getcmdcompltype(typval_T *argvars, typval_T *rettv);
+void f_getcmdline(typval_T *argvars, typval_T *rettv);
+void f_getcmdpos(typval_T *argvars, typval_T *rettv);
+void f_getcmdscreenpos(typval_T *argvars, typval_T *rettv);
+void f_getcmdtype(typval_T *argvars, typval_T *rettv);
+void f_setcmdline(typval_T *argvars, typval_T *rettv);
+void f_setcmdpos(typval_T *argvars, typval_T *rettv);
+int get_cmdline_firstc(void);
+int get_list_range(char_u **str, int *num1, int *num2);
+char *did_set_cedit(optset_T *args);
+int is_in_cmdwin(void);
+char_u *script_get(exarg_T *eap, char_u *cmd);
+void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog, int secret);
+/* vim: set ft=c : */
diff --git a/src/proto/fileio.pro b/src/proto/fileio.pro
new file mode 100644
index 0000000..3f7b30d
--- /dev/null
+++ b/src/proto/fileio.pro
@@ -0,0 +1,44 @@
+/* fileio.c */
+void filemess(buf_T *buf, char_u *name, char_u *s, int attr);
+int readfile(char_u *fname, char_u *sfname, linenr_T from, linenr_T lines_to_skip, linenr_T lines_to_read, exarg_T *eap, int flags);
+int is_dev_fd_file(char_u *fname);
+int prep_exarg(exarg_T *eap, buf_T *buf);
+void set_file_options(int set_options, exarg_T *eap);
+void set_forced_fenc(exarg_T *eap);
+int check_file_readonly(char_u *fname, int perm);
+int vim_fsync(int fd);
+int set_rw_fname(char_u *fname, char_u *sfname);
+void msg_add_fname(buf_T *buf, char_u *fname);
+int msg_add_fileformat(int eol_type);
+void msg_add_lines(int insert_space, long lnum, off_T nchars);
+void msg_add_eol(void);
+int time_differs(stat_T *st, long mtime, long mtime_ns);
+int need_conversion(char_u *fenc);
+int get_fio_flags(char_u *ptr);
+int get_win_fio_flags(char_u *ptr);
+int get_mac_fio_flags(char_u *ptr);
+char_u *shorten_fname1(char_u *full_path);
+char_u *shorten_fname(char_u *full_path, char_u *dir_name);
+void shorten_buf_fname(buf_T *buf, char_u *dirname, int force);
+void shorten_fnames(int force);
+void shorten_filenames(char_u **fnames, int count);
+char_u *modname(char_u *fname, char_u *ext, int prepend_dot);
+char_u *buf_modname(int shortname, char_u *fname, char_u *ext, int prepend_dot);
+int vim_fgets(char_u *buf, int size, FILE *fp);
+int vim_rename(char_u *from, char_u *to);
+int check_timestamps(int focus);
+int buf_check_timestamp(buf_T *buf, int focus);
+void buf_reload(buf_T *buf, int orig_mode, int reload_options);
+void buf_store_time(buf_T *buf, stat_T *st, char_u *fname);
+void write_lnum_adjust(linenr_T offset);
+int readdir_core(garray_T *gap, char_u *path, int withattr, void *context, int (*checkitem)(void *context, void *item), int sort);
+int delete_recursive(char_u *name);
+void vim_deltempdir(void);
+char_u *vim_tempname(int extra_char, int keep);
+void forward_slash(char_u *fname);
+int match_file_pat(char_u *pattern, regprog_T **prog, char_u *fname, char_u *sfname, char_u *tail, int allow_dirs);
+int match_file_list(char_u *list, char_u *sfname, char_u *ffname);
+char_u *file_pat_to_reg_pat(char_u *pat, char_u *pat_end, char *allow_dirs, int no_bslash);
+long read_eintr(int fd, void *buf, size_t bufsize);
+long write_eintr(int fd, void *buf, size_t bufsize);
+/* vim: set ft=c : */
diff --git a/src/proto/filepath.pro b/src/proto/filepath.pro
new file mode 100644
index 0000000..fd8de80
--- /dev/null
+++ b/src/proto/filepath.pro
@@ -0,0 +1,64 @@
+/* filepath.c */
+int modify_fname(char_u *src, int tilde_file, int *usedlen, char_u **fnamep, char_u **bufp, int *fnamelen);
+void shorten_dir(char_u *str);
+int file_is_readable(char_u *fname);
+void f_chdir(typval_T *argvars, typval_T *rettv);
+void f_delete(typval_T *argvars, typval_T *rettv);
+void f_executable(typval_T *argvars, typval_T *rettv);
+void f_exepath(typval_T *argvars, typval_T *rettv);
+void f_filereadable(typval_T *argvars, typval_T *rettv);
+void f_filewritable(typval_T *argvars, typval_T *rettv);
+void f_finddir(typval_T *argvars, typval_T *rettv);
+void f_findfile(typval_T *argvars, typval_T *rettv);
+void f_fnamemodify(typval_T *argvars, typval_T *rettv);
+void f_getcwd(typval_T *argvars, typval_T *rettv);
+char_u *getfpermst(stat_T *st, char_u *perm);
+void f_getfperm(typval_T *argvars, typval_T *rettv);
+void f_getfsize(typval_T *argvars, typval_T *rettv);
+void f_getftime(typval_T *argvars, typval_T *rettv);
+char_u *getftypest(stat_T *st);
+void f_getftype(typval_T *argvars, typval_T *rettv);
+void f_glob(typval_T *argvars, typval_T *rettv);
+void f_glob2regpat(typval_T *argvars, typval_T *rettv);
+void f_globpath(typval_T *argvars, typval_T *rettv);
+void f_isdirectory(typval_T *argvars, typval_T *rettv);
+void f_isabsolutepath(typval_T *argvars, typval_T *rettv);
+void f_mkdir(typval_T *argvars, typval_T *rettv);
+void f_pathshorten(typval_T *argvars, typval_T *rettv);
+void f_readdir(typval_T *argvars, typval_T *rettv);
+void f_readdirex(typval_T *argvars, typval_T *rettv);
+void f_readblob(typval_T *argvars, typval_T *rettv);
+void f_readfile(typval_T *argvars, typval_T *rettv);
+void f_resolve(typval_T *argvars, typval_T *rettv);
+void f_tempname(typval_T *argvars, typval_T *rettv);
+void f_writefile(typval_T *argvars, typval_T *rettv);
+char_u *do_browse(int flags, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter, buf_T *buf);
+void f_browse(typval_T *argvars, typval_T *rettv);
+void f_browsedir(typval_T *argvars, typval_T *rettv);
+void home_replace(buf_T *buf, char_u *src, char_u *dst, int dstlen, int one);
+char_u *home_replace_save(buf_T *buf, char_u *src);
+int fullpathcmp(char_u *s1, char_u *s2, int checkname, int expandenv);
+char_u *gettail(char_u *fname);
+char_u *gettail_sep(char_u *fname);
+char_u *getnextcomp(char_u *fname);
+char_u *get_past_head(char_u *path);
+int vim_ispathsep(int c);
+int vim_ispathsep_nocolon(int c);
+int dir_of_file_exists(char_u *fname);
+int vim_fnamecmp(char_u *x, char_u *y);
+int vim_fnamencmp(char_u *x, char_u *y, size_t len);
+char_u *concat_fnames(char_u *fname1, char_u *fname2, int sep);
+void add_pathsep(char_u *p);
+char_u *FullName_save(char_u *fname, int force);
+int vim_fexists(char_u *fname);
+int expand_wildcards_eval(char_u **pat, int *num_file, char_u ***file, int flags);
+int expand_wildcards(int num_pat, char_u **pat, int *num_files, char_u ***files, int flags);
+int match_suffix(char_u *fname);
+int unix_expandpath(garray_T *gap, char_u *path, int wildoff, int flags, int didstar);
+int gen_expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u ***file, int flags);
+void addfile(garray_T *gap, char_u *f, int flags);
+void FreeWild(int count, char_u **files);
+int pathcmp(const char *p, const char *q, int maxlen);
+int vim_isAbsName(char_u *name);
+int vim_FullName(char_u *fname, char_u *buf, int len, int force);
+/* vim: set ft=c : */
diff --git a/src/proto/findfile.pro b/src/proto/findfile.pro
new file mode 100644
index 0000000..bffc124
--- /dev/null
+++ b/src/proto/findfile.pro
@@ -0,0 +1,19 @@
+/* findfile.c */
+void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int level, int free_visited, int find_what, void *search_ctx_arg, int tagfile, char_u *rel_fname);
+char_u *vim_findfile_stopdir(char_u *buf);
+void vim_findfile_cleanup(void *ctx);
+char_u *vim_findfile(void *search_ctx_arg);
+char_u *find_file_in_path(char_u *ptr, int len, int options, int first, char_u *rel_fname);
+void free_findfile(void);
+char_u *find_directory_in_path(char_u *ptr, int len, int options, char_u *rel_fname);
+char_u *find_file_in_path_option(char_u *ptr, int len, int options, int first, char_u *path_option, int find_what, char_u *rel_fname, char_u *suffixes);
+char_u *grab_file_name(long count, linenr_T *file_lnum);
+char_u *file_name_at_cursor(int options, long count, linenr_T *file_lnum);
+char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u *rel_fname, linenr_T *file_lnum);
+char_u *find_file_name_in_path(char_u *ptr, int len, int options, long count, char_u *rel_fname);
+int vim_ispathlistsep(int c);
+void uniquefy_paths(garray_T *gap, char_u *pattern);
+int expand_in_path(garray_T *gap, char_u *pattern, int flags);
+void simplify_filename(char_u *filename);
+void f_simplify(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/float.pro b/src/proto/float.pro
new file mode 100644
index 0000000..cceb157
--- /dev/null
+++ b/src/proto/float.pro
@@ -0,0 +1,29 @@
+/* float.c */
+int string2float(char_u *text, float_T *value, int skip_quotes);
+void f_abs(typval_T *argvars, typval_T *rettv);
+void f_acos(typval_T *argvars, typval_T *rettv);
+void f_asin(typval_T *argvars, typval_T *rettv);
+void f_atan(typval_T *argvars, typval_T *rettv);
+void f_atan2(typval_T *argvars, typval_T *rettv);
+void f_ceil(typval_T *argvars, typval_T *rettv);
+void f_cos(typval_T *argvars, typval_T *rettv);
+void f_cosh(typval_T *argvars, typval_T *rettv);
+void f_exp(typval_T *argvars, typval_T *rettv);
+void f_float2nr(typval_T *argvars, typval_T *rettv);
+void f_floor(typval_T *argvars, typval_T *rettv);
+void f_fmod(typval_T *argvars, typval_T *rettv);
+void f_isinf(typval_T *argvars, typval_T *rettv);
+void f_isnan(typval_T *argvars, typval_T *rettv);
+void f_log(typval_T *argvars, typval_T *rettv);
+void f_log10(typval_T *argvars, typval_T *rettv);
+void f_pow(typval_T *argvars, typval_T *rettv);
+float_T vim_round(float_T f);
+void f_round(typval_T *argvars, typval_T *rettv);
+void f_sin(typval_T *argvars, typval_T *rettv);
+void f_sinh(typval_T *argvars, typval_T *rettv);
+void f_sqrt(typval_T *argvars, typval_T *rettv);
+void f_str2float(typval_T *argvars, typval_T *rettv);
+void f_tan(typval_T *argvars, typval_T *rettv);
+void f_tanh(typval_T *argvars, typval_T *rettv);
+void f_trunc(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/fold.pro b/src/proto/fold.pro
new file mode 100644
index 0000000..93d1dc5
--- /dev/null
+++ b/src/proto/fold.pro
@@ -0,0 +1,45 @@
+/* fold.c */
+void copyFoldingState(win_T *wp_from, win_T *wp_to);
+int hasAnyFolding(win_T *win);
+int hasFolding(linenr_T lnum, linenr_T *firstp, linenr_T *lastp);
+int hasFoldingWin(win_T *win, linenr_T lnum, linenr_T *firstp, linenr_T *lastp, int cache, foldinfo_T *infop);
+int lineFolded(win_T *win, linenr_T lnum);
+long foldedCount(win_T *win, linenr_T lnum, foldinfo_T *infop);
+int foldmethodIsManual(win_T *wp);
+int foldmethodIsIndent(win_T *wp);
+int foldmethodIsExpr(win_T *wp);
+int foldmethodIsMarker(win_T *wp);
+int foldmethodIsSyntax(win_T *wp);
+int foldmethodIsDiff(win_T *wp);
+void closeFold(linenr_T lnum, long count);
+void closeFoldRecurse(linenr_T lnum);
+void opFoldRange(linenr_T first, linenr_T last, int opening, int recurse, int had_visual);
+void openFold(linenr_T lnum, long count);
+void openFoldRecurse(linenr_T lnum);
+void foldOpenCursor(void);
+void newFoldLevel(void);
+void foldCheckClose(void);
+int foldManualAllowed(int create);
+void foldCreate(linenr_T start, linenr_T end);
+void deleteFold(linenr_T start, linenr_T end, int recursive, int had_visual);
+void clearFolding(win_T *win);
+void foldUpdate(win_T *wp, linenr_T top, linenr_T bot);
+void foldUpdateAll(win_T *win);
+int foldMoveTo(int updown, int dir, long count);
+void foldInitWin(win_T *new_win);
+int find_wl_entry(win_T *win, linenr_T lnum);
+void foldAdjustVisual(void);
+void foldAdjustCursor(void);
+void cloneFoldGrowArray(garray_T *from, garray_T *to);
+void deleteFoldRecurse(garray_T *gap);
+void foldMarkAdjust(win_T *wp, linenr_T line1, linenr_T line2, long amount, long amount_after);
+int getDeepestNesting(void);
+char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T *foldinfo, char_u *buf);
+void foldMoveRange(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest);
+int put_folds(FILE *fd, win_T *wp);
+void f_foldclosed(typval_T *argvars, typval_T *rettv);
+void f_foldclosedend(typval_T *argvars, typval_T *rettv);
+void f_foldlevel(typval_T *argvars, typval_T *rettv);
+void f_foldtext(typval_T *argvars, typval_T *rettv);
+void f_foldtextresult(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/getchar.pro b/src/proto/getchar.pro
new file mode 100644
index 0000000..66c1e9b
--- /dev/null
+++ b/src/proto/getchar.pro
@@ -0,0 +1,58 @@
+/* getchar.c */
+char_u *get_recorded(void);
+char_u *get_inserted(void);
+int stuff_empty(void);
+int readbuf1_empty(void);
+void typeahead_noflush(int c);
+void flush_buffers(flush_buffers_T flush_typeahead);
+void ResetRedobuff(void);
+void CancelRedo(void);
+void saveRedobuff(save_redo_T *save_redo);
+void restoreRedobuff(save_redo_T *save_redo);
+void AppendToRedobuff(char_u *s);
+void AppendToRedobuffLit(char_u *str, int len);
+void AppendCharToRedobuff(int c);
+void AppendNumberToRedobuff(long n);
+void stuffReadbuff(char_u *s);
+void stuffRedoReadbuff(char_u *s);
+void stuffReadbuffSpec(char_u *s);
+void stuffcharReadbuff(int c);
+void stuffnumReadbuff(long n);
+void stuffescaped(char_u *arg, int literally);
+int start_redo(long count, int old_redo);
+int start_redo_ins(void);
+void stop_redo_ins(void);
+int noremap_keys(void);
+int ins_typebuf(char_u *str, int noremap, int offset, int nottyped, int silent);
+int ins_char_typebuf(int c, int modifiers);
+int typebuf_changed(int tb_change_cnt);
+int typebuf_typed(void);
+int typebuf_maplen(void);
+void del_typebuf(int len, int offset);
+void ungetchars(int len);
+int save_typebuf(void);
+void save_typeahead(tasave_T *tp);
+void restore_typeahead(tasave_T *tp, int overwrite);
+void openscript(char_u *name, int directly);
+void close_all_scripts(void);
+int using_script(void);
+void before_blocking(void);
+int merge_modifyOtherKeys(int c_arg, int *modifiers);
+int vgetc(void);
+int safe_vgetc(void);
+int plain_vgetc(void);
+int vpeekc(void);
+int vpeekc_nomap(void);
+int vpeekc_any(void);
+int char_avail(void);
+void f_getchar(typval_T *argvars, typval_T *rettv);
+void f_getcharstr(typval_T *argvars, typval_T *rettv);
+void f_getcharmod(typval_T *argvars, typval_T *rettv);
+void parse_queued_messages(void);
+void vungetc(int c);
+int fix_input_buffer(char_u *buf, int len);
+int input_available(void);
+void may_add_last_used_map_to_redobuff(void);
+int do_cmdkey_command(int key, int flags);
+void reset_last_used_map(mapblock_T *mp);
+/* vim: set ft=c : */
diff --git a/src/proto/gui.pro b/src/proto/gui.pro
new file mode 100644
index 0000000..47613f5
--- /dev/null
+++ b/src/proto/gui.pro
@@ -0,0 +1,68 @@
+/* gui.c */
+void gui_start(char_u *arg);
+void gui_prepare(int *argc, char **argv);
+int gui_init_check(void);
+void gui_init(void);
+void gui_exit(int rc);
+void gui_shell_closed(void);
+int gui_init_font(char_u *font_list, int fontset);
+int gui_get_wide_font(void);
+void gui_set_ligatures(void);
+void gui_update_cursor(int force, int clear_selection);
+int gui_get_base_width(void);
+int gui_get_base_height(void);
+void gui_resize_shell(int pixel_width, int pixel_height);
+void gui_may_resize_shell(void);
+int gui_get_shellsize(void);
+void gui_set_shellsize(int mustset, int fit_to_display, int direction);
+void gui_new_shellsize(void);
+void gui_stop_highlight(int mask);
+void gui_clear_block(int row1, int col1, int row2, int col2);
+void gui_update_cursor_later(void);
+void gui_write(char_u *s, int len);
+void gui_dont_update_cursor(int undraw);
+void gui_can_update_cursor(void);
+void gui_disable_flush(void);
+void gui_enable_flush(void);
+void gui_may_flush(void);
+void gui_undraw_cursor(void);
+void gui_redraw(int x, int y, int w, int h);
+void gui_redraw_block(int row1, int col1, int row2, int col2, int flags);
+int gui_wait_for_chars(long wtime, int tb_change_cnt);
+int gui_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
+void gui_send_mouse_event(int button, int x, int y, int repeated_click, int_u modifiers);
+void gui_menu_cb(vimmenu_T *menu);
+void gui_init_which_components(char_u *oldval);
+int gui_use_tabline(void);
+void gui_update_tabline(void);
+void get_tabline_label(tabpage_T *tp, int tooltip);
+int send_tabline_event(int nr);
+void send_tabline_menu_event(int tabidx, int event);
+void gui_remove_scrollbars(void);
+void gui_create_scrollbar(scrollbar_T *sb, int type, win_T *wp);
+scrollbar_T *gui_find_scrollbar(long ident);
+void gui_drag_scrollbar(scrollbar_T *sb, long value, int still_dragging);
+void gui_may_update_scrollbars(void);
+void gui_update_scrollbars(int force);
+int gui_do_scroll(void);
+void gui_check_colors(void);
+guicolor_T gui_get_color(char_u *name);
+int gui_get_lightness(guicolor_T pixel);
+char_u *gui_bg_default(void);
+void gui_new_scrollbar_colors(void);
+void gui_focus_change(int in_focus);
+void gui_mouse_moved(int x, int y);
+win_T *gui_mouse_window(mouse_find_T popup);
+void gui_mouse_correct(void);
+void ex_gui(exarg_T *eap);
+int gui_find_bitmap(char_u *name, char_u *buffer, char *ext);
+void gui_find_iconfile(char_u *name, char_u *buffer, char *ext);
+void display_errors(void);
+int no_console_input(void);
+void gui_update_screen(void);
+char_u *get_find_dialog_text(char_u *arg, int *wwordp, int *mcasep);
+int gui_do_findrepl(int flags, char_u *find_text, char_u *repl_text, int down);
+void gui_handle_drop(int x, int y, int_u modifiers, char_u **fnames, int count);
+int check_for_interrupt(int key, int modifiers_arg);
+int gui_dialog_log(char_u *title, char_u *message);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_beval.pro b/src/proto/gui_beval.pro
new file mode 100644
index 0000000..4edb45c
--- /dev/null
+++ b/src/proto/gui_beval.pro
@@ -0,0 +1,9 @@
+/* gui_beval.c */
+BalloonEval *gui_mch_create_beval_area(void *target, char_u *mesg, void (*mesgCB)(BalloonEval *, int), void *clientData);
+void gui_mch_destroy_beval_area(BalloonEval *beval);
+void gui_mch_enable_beval_area(BalloonEval *beval);
+void gui_mch_disable_beval_area(BalloonEval *beval);
+BalloonEval *gui_mch_currently_showing_beval(void);
+void gui_mch_post_balloon(BalloonEval *beval, char_u *mesg);
+void gui_mch_unpost_balloon(BalloonEval *beval);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_gtk.pro b/src/proto/gui_gtk.pro
new file mode 100644
index 0000000..7b87ba0
--- /dev/null
+++ b/src/proto/gui_gtk.pro
@@ -0,0 +1,24 @@
+/* gui_gtk.c */
+void gui_gtk_register_stock_icons(void);
+void gui_mch_add_menu(vimmenu_T *menu, int idx);
+void gui_mch_add_menu_item(vimmenu_T *menu, int idx);
+void gui_mch_set_text_area_pos(int x, int y, int w, int h);
+void gui_gtk_set_mnemonics(int enable);
+void gui_mch_toggle_tearoffs(int enable);
+void gui_mch_menu_set_tip(vimmenu_T *menu);
+void gui_mch_destroy_menu(vimmenu_T *menu);
+void gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max);
+void gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h);
+int gui_mch_get_scrollbar_xpadding(void);
+int gui_mch_get_scrollbar_ypadding(void);
+void gui_mch_create_scrollbar(scrollbar_T *sb, int orient);
+void gui_mch_destroy_scrollbar(scrollbar_T *sb);
+char_u *gui_mch_browse(int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter);
+char_u *gui_mch_browsedir(char_u *title, char_u *initdir);
+int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *buttons, int def_but, char_u *textfield, int ex_cmd);
+void gui_mch_show_popupmenu(vimmenu_T *menu);
+void gui_make_popup(char_u *path_name, int mouse_pos);
+void gui_mch_find_dialog(exarg_T *eap);
+void gui_mch_replace_dialog(exarg_T *eap);
+void ex_helpfind(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_gtk_gresources.pro b/src/proto/gui_gtk_gresources.pro
new file mode 100644
index 0000000..c09c793
--- /dev/null
+++ b/src/proto/gui_gtk_gresources.pro
@@ -0,0 +1,5 @@
+/* auto/gui_gtk_gresources.c */
+GResource *gui_gtk_get_resource(void);
+void gui_gtk_unregister_resource(void);
+void gui_gtk_register_resource(void);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_gtk_x11.pro b/src/proto/gui_gtk_x11.pro
new file mode 100644
index 0000000..3fa2ac9
--- /dev/null
+++ b/src/proto/gui_gtk_x11.pro
@@ -0,0 +1,81 @@
+/* gui_gtk_x11.c */
+void gui_mch_prepare(int *argc, char **argv);
+void gui_mch_free_all(void);
+int gui_mch_is_blinking(void);
+int gui_mch_is_blink_off(void);
+void gui_mch_set_blinking(long waittime, long on, long off);
+void gui_mch_stop_blink(int may_call_gui_update_cursor);
+void gui_mch_start_blink(void);
+int gui_mch_early_init_check(int give_message);
+int gui_mch_init_check(void);
+void gui_mch_set_dark_theme(int dark);
+void gui_mch_show_tabline(int showit);
+int gui_mch_showing_tabline(void);
+void gui_mch_update_tabline(void);
+void gui_mch_set_curtab(int nr);
+void gui_gtk_set_selection_targets(void);
+void gui_gtk_set_dnd_targets(void);
+int gui_mch_init(void);
+void gui_mch_forked(void);
+void gui_mch_new_colors(void);
+void gui_gtk_get_screen_geom_of_win(GtkWidget *wid, int point_x, int point_y, int *screen_x, int *screen_y, int *width, int *height);
+void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h);
+int gui_mch_open(void);
+void gui_mch_exit(int rc);
+int gui_mch_get_winpos(int *x, int *y);
+void gui_mch_set_winpos(int x, int y);
+int gui_mch_maximized(void);
+void gui_mch_unmaximize(void);
+void gui_mch_newfont(void);
+void gui_mch_set_shellsize(int width, int height, int min_width, int min_height, int base_width, int base_height, int direction);
+void gui_mch_settitle(char_u *title, char_u *icon);
+void gui_mch_enable_menu(int showit);
+void gui_mch_show_toolbar(int showit);
+int gui_mch_adjust_charheight(void);
+char_u *gui_mch_font_dialog(char_u *oldval);
+int gui_mch_init_font(char_u *font_name, int fontset);
+GuiFont gui_mch_get_font(char_u *name, int report_error);
+char_u *gui_mch_get_fontname(GuiFont font, char_u *name);
+void gui_mch_free_font(GuiFont font);
+guicolor_T gui_mch_get_color(char_u *name);
+guicolor_T gui_mch_get_rgb_color(int r, int g, int b);
+void gui_mch_set_fg_color(guicolor_T color);
+void gui_mch_set_bg_color(guicolor_T color);
+void gui_mch_set_sp_color(guicolor_T color);
+int gui_gtk2_draw_string(int row, int col, char_u *s, int len, int flags);
+int gui_gtk2_draw_string_ext(int row, int col, char_u *s, int len, int flags, int force_pango);
+int gui_mch_haskey(char_u *name);
+int gui_get_x11_windis(Window *win, Display **dis);
+Display *gui_mch_get_display(void);
+void gui_mch_beep(void);
+void gui_mch_flash(int msec);
+void gui_mch_invert_rectangle(int r, int c, int nr, int nc);
+void gui_mch_iconify(void);
+void gui_mch_set_foreground(void);
+void gui_mch_draw_hollow_cursor(guicolor_T color);
+void gui_mch_draw_part_cursor(int w, int h, guicolor_T color);
+void gui_mch_update(void);
+int gui_mch_wait_for_chars(long wtime);
+void gui_mch_flush(void);
+void gui_mch_clear_block(int row1arg, int col1arg, int row2arg, int col2arg);
+void gui_mch_clear_all(void);
+void gui_mch_delete_lines(int row, int num_lines);
+void gui_mch_insert_lines(int row, int num_lines);
+void clip_mch_request_selection(Clipboard_T *cbd);
+void clip_mch_lose_selection(Clipboard_T *cbd);
+int clip_mch_own_selection(Clipboard_T *cbd);
+void clip_mch_set_selection(Clipboard_T *cbd);
+int clip_gtk_owner_exists(Clipboard_T *cbd);
+void gui_mch_menu_grey(vimmenu_T *menu, int grey);
+void gui_mch_menu_hidden(vimmenu_T *menu, int hidden);
+void gui_mch_draw_menubar(void);
+void gui_mch_enable_scrollbar(scrollbar_T *sb, int flag);
+guicolor_T gui_mch_get_rgb(guicolor_T pixel);
+void gui_mch_getmouse(int *x, int *y);
+void gui_mch_setmouse(int x, int y);
+void gui_mch_mousehide(int hide);
+void mch_set_mouse_shape(int shape);
+void gui_mch_drawsign(int row, int col, int typenr);
+void *gui_mch_register_sign(char_u *signfile);
+void gui_mch_destroy_sign(void *sign);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_haiku.pro b/src/proto/gui_haiku.pro
new file mode 100644
index 0000000..51ee93a
--- /dev/null
+++ b/src/proto/gui_haiku.pro
@@ -0,0 +1,97 @@
+/* gui_haiku.cc - hand crafted */
+
+void gui_mch_prepare(int *argc, char **argv);
+int gui_mch_init(void);
+int gui_mch_open(void);
+void gui_mch_exit(int vim_exitcode);
+int gui_mch_init_check(void);
+void gui_mch_flush(void);
+int gui_mch_is_blink_off(void);
+void gui_mch_new_colors(void);
+void gui_mch_set_bg_color(guicolor_T color);
+void gui_mch_set_fg_color(guicolor_T color);
+void gui_mch_set_sp_color(guicolor_T color);
+guicolor_T gui_mch_get_rgb(guicolor_T pixel);
+guicolor_T gui_mch_get_rgb_color(int r, int g, int b);
+guicolor_T gui_mch_get_color(char_u *name);
+
+GuiFont gui_mch_get_font(char_u *name, int giveErrorIfMissing);
+void gui_mch_set_font(GuiFont font);
+int gui_mch_init_font(char_u *font_name, int fontset);
+void gui_mch_free_font(GuiFont font);
+char_u *gui_mch_get_fontname(GuiFont font, char_u *name);
+
+void gui_mch_set_winpos(int x, int y);
+int gui_mch_get_winpos(int *x, int *y);
+void gui_mch_set_shellsize(int w, int h, int m_w, int m_h, int b_w, int b_h, int d);
+void gui_mch_get_screen_dimensions(int* screen_w, int* screen_h);
+void gui_mch_set_text_area_pos(int x, int y, int w, int h);
+
+void gui_mch_enable_scrollbar(scrollbar_T *sb, int flag);
+
+//void gui_mch_set_scrollbar_thumb __ARGS((scrollbar_T *sb,int val, int size, int max));
+void gui_mch_set_scrollbar_thumb(scrollbar_T *sb, int val, int size, int max);
+
+void gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h);
+int gui_mch_get_scrollbar_xpadding(void);
+int gui_mch_get_scrollbar_ypadding(void);
+void gui_mch_create_scrollbar(scrollbar_T *sb, int orient);
+void gui_mch_destroy_scrollbar(scrollbar_T *sb);
+
+void gui_mch_set_blinking(long waittime, long on, long off);
+void gui_mch_stop_blink(int may_call_gui_update_cursor);
+void gui_mch_start_blink(void);
+
+int gui_mch_adjust_charheight(void);
+void gui_mch_draw_string(int row, int col, char_u *s, int len, int flags);
+int gui_mch_haskey(char_u *name);
+void gui_mch_beep(void);
+void gui_mch_flash(int msec);
+void gui_mch_invert_rectangle(int r, int c, int nr, int nc);
+void gui_mch_iconify(void);
+void gui_mch_set_foreground(void);
+void gui_mch_settitle(char_u *title, char_u *icon);
+void gui_mch_draw_hollow_cursor(guicolor_T color);
+void gui_mch_draw_part_cursor(int w, int h, guicolor_T color);
+void gui_mch_update(void);
+int gui_mch_wait_for_chars(int wtime);
+void gui_mch_clear_block(int row1, int col1, int row2, int col2);
+void gui_mch_clear_all(void);
+void gui_mch_delete_lines(int row, int num_lines);
+void gui_mch_insert_lines(int row, int num_lines);
+
+void gui_mch_getmouse(int *x, int *y);
+void gui_mch_setmouse(int x, int y);
+void gui_mch_mousehide(int hide);
+
+void gui_mch_enable_menu(int flag);
+void gui_mch_set_menu_pos(int x, int y, int w, int h);
+void gui_mch_add_menu(vimmenu_T *menu, int idx);
+void gui_mch_add_menu_item(vimmenu_T *menu, int idx);
+void gui_mch_destroy_menu(vimmenu_T *menu);
+void gui_mch_menu_grey(vimmenu_T *menu, int grey);
+void gui_mch_menu_hidden(vimmenu_T *menu, int hidden);
+void gui_mch_draw_menubar(void);
+void gui_mch_show_popupmenu(vimmenu_T *menu);
+void gui_mch_toggle_tearoffs(int enable);
+
+void clip_mch_request_selection(Clipboard_T *cbd);
+void clip_mch_set_selection(Clipboard_T *cbd);
+void clip_mch_lose_selection(Clipboard_T *cbd);
+int clip_mch_own_selection(Clipboard_T *cbd);
+
+char_u *gui_mch_browse(int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter);
+int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton, char_u *textfield, int ex_cmd);
+
+void im_set_position(int row, int col);
+void im_set_active(int activate);
+int im_get_status(void);
+
+void gui_mch_show_toolbar(int showit);
+void gui_mch_set_toolbar_pos(int x, int y, int w, int h);
+
+void gui_mch_show_tabline(int showit);
+void gui_mch_set_tabline_pos(int x, int y, int w, int h);
+int gui_mch_showing_tabline(void);
+void gui_mch_update_tabline(void);
+void gui_mch_set_curtab(int nr);
diff --git a/src/proto/gui_motif.pro b/src/proto/gui_motif.pro
new file mode 100644
index 0000000..400fa86
--- /dev/null
+++ b/src/proto/gui_motif.pro
@@ -0,0 +1,46 @@
+/* gui_motif.c */
+void gui_x11_create_widgets(void);
+void gui_x11_destroy_widgets(void);
+void gui_mch_set_text_area_pos(int x, int y, int w, int h);
+void gui_x11_set_back_color(void);
+void manage_centered(Widget dialog_child);
+XmFontList gui_motif_create_fontlist(XFontStruct *font);
+XmFontList gui_motif_fontset2fontlist(XFontSet *fontset);
+void gui_mch_enable_menu(int flag);
+void gui_motif_set_mnemonics(int enable);
+void gui_mch_add_menu(vimmenu_T *menu, int idx);
+void gui_mch_toggle_tearoffs(int enable);
+int gui_mch_text_area_extra_height(void);
+void gui_mch_compute_menu_height(Widget id);
+void gui_mch_add_menu_item(vimmenu_T *menu, int idx);
+void gui_motif_update_mousemodel(vimmenu_T *menu);
+void gui_mch_new_menu_colors(void);
+void gui_mch_new_menu_font(void);
+void gui_mch_new_tooltip_font(void);
+void gui_mch_new_tooltip_colors(void);
+void gui_mch_destroy_menu(vimmenu_T *menu);
+void gui_mch_show_popupmenu(vimmenu_T *menu);
+void gui_mch_def_colors(void);
+void gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max);
+void gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h);
+int gui_mch_get_scrollbar_xpadding(void);
+int gui_mch_get_scrollbar_ypadding(void);
+void gui_mch_enable_scrollbar(scrollbar_T *sb, int flag);
+void gui_mch_create_scrollbar(scrollbar_T *sb, int orient);
+void gui_mch_destroy_scrollbar(scrollbar_T *sb);
+void gui_mch_set_scrollbar_colors(scrollbar_T *sb);
+Window gui_x11_get_wid(void);
+char_u *gui_mch_browse(int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter);
+int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *button_names, int dfltbutton, char_u *textfield, int ex_cmd);
+void gui_mch_show_toolbar(int showit);
+int gui_mch_compute_toolbar_height(void);
+void motif_get_toolbar_colors(Pixel *bgp, Pixel *fgp, Pixel *bsp, Pixel *tsp, Pixel *hsp);
+void gui_mch_show_tabline(int showit);
+int gui_mch_showing_tabline(void);
+void gui_mch_update_tabline(void);
+void gui_mch_set_curtab(int nr);
+void gui_motif_menu_fontlist(Widget id);
+void gui_mch_find_dialog(exarg_T *eap);
+void gui_mch_replace_dialog(exarg_T *eap);
+void gui_motif_synch_fonts(void);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_photon.pro b/src/proto/gui_photon.pro
new file mode 100644
index 0000000..5fcc9ba
--- /dev/null
+++ b/src/proto/gui_photon.pro
@@ -0,0 +1,72 @@
+/* gui_photon.c */
+void gui_ph_encoding_changed(int new_encoding);
+void gui_mch_prepare(int *argc, char **argv);
+int gui_mch_init(void);
+int gui_mch_init_check(void);
+int gui_mch_open(void);
+void gui_mch_exit(int rc);
+void gui_mch_update(void);
+int gui_mch_wait_for_chars(int wtime);
+char_u *gui_mch_browse(int saving, char_u *title, char_u *default_name, char_u *ext, char_u *initdir, char_u *filter);
+int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *buttons, int default_button, char_u *textfield, int ex_cmd);
+int gui_mch_get_winpos(int *x, int *y);
+void gui_mch_set_winpos(int x, int y);
+void gui_mch_set_shellsize(int width, int height, int min_width, int min_height, int base_width, int base_height, int direction);
+void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h);
+void gui_mch_iconify(void);
+void gui_mch_set_foreground(void);
+void gui_mch_settitle(char_u *title, char_u *icon);
+void gui_mch_set_scrollbar_thumb(scrollbar_T *sb, int val, int size, int max);
+void gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h);
+int gui_mch_get_scrollbar_xpadding(void);
+int gui_mch_get_scrollbar_ypadding(void);
+void gui_mch_create_scrollbar(scrollbar_T *sb, int orient);
+void gui_mch_enable_scrollbar(scrollbar_T *sb, int flag);
+void gui_mch_destroy_scrollbar(scrollbar_T *sb);
+void mch_set_mouse_shape(int shape);
+void gui_mch_mousehide(int hide);
+void gui_mch_getmouse(int *x, int *y);
+void gui_mch_setmouse(int x, int y);
+guicolor_T gui_mch_get_rgb(guicolor_T pixel);
+void gui_mch_new_colors(void);
+guicolor_T gui_mch_get_color(char_u *name);
+guicolor_T gui_mch_get_rgb_color(int r, int g, int b);
+void gui_mch_set_fg_color(guicolor_T color);
+void gui_mch_set_bg_color(guicolor_T color);
+void gui_mch_set_sp_color(guicolor_T color);
+void gui_mch_invert_rectangle(int row, int col, int nr, int nc);
+void gui_mch_clear_block(int row1, int col1, int row2, int col2);
+void gui_mch_clear_all(void);
+void gui_mch_delete_lines(int row, int num_lines);
+void gui_mch_insert_lines(int row, int num_lines);
+void gui_mch_draw_string(int row, int col, char_u *s, int len, int flags);
+void gui_mch_draw_hollow_cursor(guicolor_T color);
+void gui_mch_draw_part_cursor(int w, int h, guicolor_T color);
+int gui_mch_is_blinking(void);
+int gui_mch_is_blink_off(void);
+void gui_mch_set_blinking(long wait, long on, long off);
+void gui_mch_start_blink(void);
+void gui_mch_stop_blink(int may_call_gui_update_cursor);
+void gui_mch_beep(void);
+void gui_mch_flash(int msec);
+void gui_mch_flush(void);
+void gui_mch_set_text_area_pos(int x, int y, int w, int h);
+int gui_mch_haskey(char_u *name);
+void gui_mch_enable_menu(int flag);
+void gui_mch_set_menu_pos(int x, int y, int w, int h);
+void gui_mch_add_menu(vimmenu_T *menu, int index);
+void gui_mch_add_menu_item(vimmenu_T *menu, int index);
+void gui_mch_destroy_menu(vimmenu_T *menu);
+void gui_mch_menu_grey(vimmenu_T *menu, int grey);
+void gui_mch_menu_hidden(vimmenu_T *menu, int hidden);
+void gui_mch_draw_menubar(void);
+void gui_mch_show_popupmenu(vimmenu_T *menu);
+void gui_mch_toggle_tearoffs(int enable);
+void gui_mch_show_toolbar(int showit);
+int gui_mch_init_font(char_u *vim_font_name, int fontset);
+int gui_mch_adjust_charheight(void);
+GuiFont gui_mch_get_font(char_u *vim_font_name, int report_error);
+char_u *gui_mch_get_fontname(GuiFont font, char_u *name);
+void gui_mch_set_font(GuiFont font);
+void gui_mch_free_font(GuiFont font);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_w32.pro b/src/proto/gui_w32.pro
new file mode 100644
index 0000000..c5c6585
--- /dev/null
+++ b/src/proto/gui_w32.pro
@@ -0,0 +1,100 @@
+/* gui_w32.c */
+int gui_mch_set_rendering_options(char_u *s);
+int gui_mch_is_blinking(void);
+int gui_mch_is_blink_off(void);
+void gui_mch_set_blinking(long wait, long on, long off);
+void gui_mch_stop_blink(int may_call_gui_update_cursor);
+void gui_mch_start_blink(void);
+void gui_mch_new_colors(void);
+void gui_mch_def_colors(void);
+int gui_mch_open(void);
+int gui_mch_get_winpos(int *x, int *y);
+void gui_mch_set_winpos(int x, int y);
+void gui_mch_set_text_area_pos(int x, int y, int w, int h);
+void gui_mch_enable_scrollbar(scrollbar_T *sb, int flag);
+void gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h);
+int gui_mch_get_scrollbar_xpadding(void);
+int gui_mch_get_scrollbar_ypadding(void);
+void gui_mch_create_scrollbar(scrollbar_T *sb, int orient);
+int gui_mch_adjust_charheight(void);
+GuiFont gui_mch_get_font(char_u *name, int giveErrorIfMissing);
+char_u *gui_mch_get_fontname(GuiFont font, char_u *name);
+void gui_mch_free_font(GuiFont font);
+guicolor_T gui_mch_get_color(char_u *name);
+guicolor_T gui_mch_get_rgb_color(int r, int g, int b);
+int gui_mch_haskey(char_u *name);
+void gui_mch_beep(void);
+void gui_mch_invert_rectangle(int r, int c, int nr, int nc);
+void gui_mch_iconify(void);
+void gui_mch_draw_hollow_cursor(guicolor_T color);
+void gui_mch_draw_part_cursor(int w, int h, guicolor_T color);
+void gui_mch_update(void);
+int gui_mch_wait_for_chars(int wtime);
+void gui_mch_clear_block(int row1, int col1, int row2, int col2);
+void gui_mch_clear_all(void);
+void gui_mch_enable_menu(int flag);
+void gui_mch_set_menu_pos(int x, int y, int w, int h);
+void gui_mch_menu_hidden(vimmenu_T *menu, int hidden);
+void gui_mch_draw_menubar(void);
+guicolor_T gui_mch_get_rgb(guicolor_T pixel);
+void gui_mch_show_toolbar(int showit);
+void gui_mch_show_tabline(int showit);
+int gui_mch_showing_tabline(void);
+void gui_mch_update_tabline(void);
+void gui_mch_set_curtab(int nr);
+void ex_simalt(exarg_T *eap);
+void gui_mch_find_dialog(exarg_T *eap);
+void gui_mch_replace_dialog(exarg_T *eap);
+void gui_mch_mousehide(int hide);
+void gui_mch_destroy_scrollbar(scrollbar_T *sb);
+void gui_mch_getmouse(int *x, int *y);
+void gui_mch_setmouse(int x, int y);
+void gui_mch_flash(int msec);
+void gui_mch_delete_lines(int row, int num_lines);
+void gui_mch_insert_lines(int row, int num_lines);
+void gui_mch_exit(int rc);
+void gui_mch_wide_font_changed(void);
+int gui_mch_init_font(char_u *font_name, int fontset);
+int gui_mch_maximized(void);
+void gui_mch_newfont(void);
+void gui_mch_settitle(char_u *title, char_u *icon);
+void mch_set_mouse_shape(int shape);
+char_u *gui_mch_browse(int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter);
+char_u *gui_mch_browsedir(char_u *title, char_u *initdir);
+void gui_mch_set_parent(char *title);
+char *gui_mch_do_spawn(char_u *arg);
+void gui_mch_prepare(int *argc, char **argv);
+int gui_mch_init(void);
+void gui_mch_set_shellsize(int width, int height, int min_width, int min_height, int base_width, int base_height, int direction);
+void gui_mch_set_scrollbar_thumb(scrollbar_T *sb, long val, long size, long max);
+void gui_mch_set_font(GuiFont font);
+void gui_mch_set_fg_color(guicolor_T color);
+void gui_mch_set_bg_color(guicolor_T color);
+void gui_mch_set_sp_color(guicolor_T color);
+void im_set_font(LOGFONTW *lf);
+void im_set_position(int row, int col);
+void im_set_active(int active);
+int im_get_status(void);
+void gui_mch_draw_string(int row, int col, char_u *text, int len, int flags);
+void gui_mch_flush(void);
+void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h);
+void gui_mch_add_menu(vimmenu_T *menu, int pos);
+void gui_mch_show_popupmenu(vimmenu_T *menu);
+void gui_make_popup(char_u *path_name, int mouse_pos);
+void gui_make_tearoff(char_u *path_name);
+void gui_mch_add_menu_item(vimmenu_T *menu, int idx);
+void gui_mch_destroy_menu(vimmenu_T *menu);
+void gui_mch_menu_grey(vimmenu_T *menu, int grey);
+int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton, char_u *textfield, int ex_cmd);
+void gui_mch_set_foreground(void);
+void gui_mch_drawsign(int row, int col, int typenr);
+void *gui_mch_register_sign(char_u *signfile);
+void gui_mch_destroy_sign(void *sign);
+void gui_mch_disable_beval_area(BalloonEval *beval);
+void gui_mch_enable_beval_area(BalloonEval *beval);
+void gui_mch_post_balloon(BalloonEval *beval, char_u *mesg);
+BalloonEval *gui_mch_create_beval_area(void *target, char_u *mesg, void (*mesgCB)(BalloonEval *, int), void *clientData);
+void gui_mch_destroy_beval_area(BalloonEval *beval);
+void netbeans_draw_multisign_indicator(int row);
+int test_gui_w32_sendevent(char_u *event, dict_T *args);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_x11.pro b/src/proto/gui_x11.pro
new file mode 100644
index 0000000..6e8974e
--- /dev/null
+++ b/src/proto/gui_x11.pro
@@ -0,0 +1,72 @@
+/* gui_x11.c */
+void gui_x11_key_hit_cb(Widget w, XtPointer dud, XEvent *event, Boolean *dum);
+void gui_mch_prepare(int *argc, char **argv);
+int gui_mch_init_check(void);
+int gui_mch_init(void);
+void gui_mch_uninit(void);
+void gui_mch_new_colors(void);
+int gui_mch_open(void);
+void gui_init_tooltip_font(void);
+void gui_init_menu_font(void);
+void gui_mch_exit(int rc);
+int gui_mch_get_winpos(int *x, int *y);
+void gui_mch_set_winpos(int x, int y);
+void gui_mch_set_shellsize(int width, int height, int min_width, int min_height, int base_width, int base_height, int direction);
+void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h);
+int gui_mch_init_font(char_u *font_name, int do_fontset);
+GuiFont gui_mch_get_font(char_u *name, int giveErrorIfMissing);
+char_u *gui_mch_get_fontname(GuiFont font, char_u *name);
+int gui_mch_adjust_charheight(void);
+void gui_mch_set_font(GuiFont font);
+void gui_mch_set_fontset(GuiFontset fontset);
+void gui_mch_free_font(GuiFont font);
+void gui_mch_free_fontset(GuiFontset fontset);
+GuiFontset gui_mch_get_fontset(char_u *name, int giveErrorIfMissing, int fixed_width);
+int fontset_height(XFontSet fs);
+guicolor_T gui_mch_get_color(char_u *name);
+guicolor_T gui_mch_get_rgb_color(int r, int g, int b);
+void gui_mch_set_fg_color(guicolor_T color);
+void gui_mch_set_bg_color(guicolor_T color);
+void gui_mch_set_sp_color(guicolor_T color);
+void gui_mch_draw_string(int row, int col, char_u *s, int len, int flags);
+int gui_mch_haskey(char_u *name);
+int gui_get_x11_windis(Window *win, Display **dis);
+void gui_mch_beep(void);
+void gui_mch_flash(int msec);
+void gui_mch_invert_rectangle(int r, int c, int nr, int nc);
+void gui_mch_iconify(void);
+void gui_mch_set_foreground(void);
+void gui_mch_draw_hollow_cursor(guicolor_T color);
+void gui_mch_draw_part_cursor(int w, int h, guicolor_T color);
+void gui_mch_update(void);
+int gui_mch_wait_for_chars(long wtime);
+void gui_mch_flush(void);
+void gui_mch_clear_block(int row1, int col1, int row2, int col2);
+void gui_mch_clear_all(void);
+void gui_mch_delete_lines(int row, int num_lines);
+void gui_mch_insert_lines(int row, int num_lines);
+void clip_mch_lose_selection(Clipboard_T *cbd);
+int clip_mch_own_selection(Clipboard_T *cbd);
+void clip_mch_request_selection(Clipboard_T *cbd);
+void clip_mch_set_selection(Clipboard_T *cbd);
+void gui_mch_menu_grey(vimmenu_T *menu, int grey);
+void gui_mch_menu_hidden(vimmenu_T *menu, int hidden);
+void gui_mch_draw_menubar(void);
+void gui_x11_menu_cb(Widget w, XtPointer client_data, XtPointer call_data);
+int gui_mch_is_blinking(void);
+int gui_mch_is_blink_off(void);
+void gui_mch_set_blinking(long waittime, long on, long off);
+void gui_mch_stop_blink(int may_call_gui_update_cursor);
+void gui_mch_start_blink(void);
+guicolor_T gui_mch_get_rgb(guicolor_T pixel);
+void gui_x11_callbacks(Widget textArea, Widget vimForm);
+void gui_mch_getmouse(int *x, int *y);
+void gui_mch_setmouse(int x, int y);
+XButtonPressedEvent *gui_x11_get_last_mouse_event(void);
+void gui_mch_drawsign(int row, int col, int typenr);
+void *gui_mch_register_sign(char_u *signfile);
+void gui_mch_destroy_sign(void *sign);
+void gui_mch_mousehide(int hide);
+void mch_set_mouse_shape(int shape);
+void gui_mch_menu_set_tip(vimmenu_T *menu);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_xim.pro b/src/proto/gui_xim.pro
new file mode 100644
index 0000000..bac7321
--- /dev/null
+++ b/src/proto/gui_xim.pro
@@ -0,0 +1,21 @@
+/* gui_xim.c */
+char *did_set_imactivatefunc(optset_T *args);
+char *did_set_imstatusfunc(optset_T *args);
+void free_xim_stuff(void);
+int set_ref_in_im_funcs(int copyID);
+void im_set_active(int active);
+void xim_set_focus(int focus);
+void im_set_position(int row, int col);
+void xim_set_preedit(void);
+int im_get_feedback_attr(int col);
+void xim_init(void);
+void im_shutdown(void);
+int im_xim_isvalid_imactivate(void);
+void xim_reset(void);
+int xim_queue_key_press_event(GdkEventKey *event, int down);
+int im_get_status(void);
+int preedit_get_status(void);
+int im_is_preediting(void);
+void xim_set_status_area(void);
+int xim_get_status_area_height(void);
+/* vim: set ft=c : */
diff --git a/src/proto/gui_xmdlg.pro b/src/proto/gui_xmdlg.pro
new file mode 100644
index 0000000..256fad7
--- /dev/null
+++ b/src/proto/gui_xmdlg.pro
@@ -0,0 +1,3 @@
+/* gui_xmdlg.c */
+char_u *gui_xm_select_font(char_u *current);
+/* vim: set ft=c : */
diff --git a/src/proto/hardcopy.pro b/src/proto/hardcopy.pro
new file mode 100644
index 0000000..8a8c73e
--- /dev/null
+++ b/src/proto/hardcopy.pro
@@ -0,0 +1,20 @@
+/* hardcopy.c */
+char *parse_printoptions(optset_T *args);
+char *parse_printmbfont(optset_T *args);
+int prt_header_height(void);
+int prt_use_number(void);
+int prt_get_unit(int idx);
+void ex_hardcopy(exarg_T *eap);
+void mch_print_cleanup(void);
+int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit);
+int mch_print_begin(prt_settings_T *psettings);
+void mch_print_end(prt_settings_T *psettings);
+int mch_print_end_page(void);
+int mch_print_begin_page(char_u *str);
+int mch_print_blank_page(void);
+void mch_print_start_line(int margin, int page_line);
+int mch_print_text_out(char_u *textp, int len);
+void mch_print_set_font(int iBold, int iItalic, int iUnderline);
+void mch_print_set_bg(long_u bgcol);
+void mch_print_set_fg(long_u fgcol);
+/* vim: set ft=c : */
diff --git a/src/proto/hashtab.pro b/src/proto/hashtab.pro
new file mode 100644
index 0000000..320889e
--- /dev/null
+++ b/src/proto/hashtab.pro
@@ -0,0 +1,16 @@
+/* hashtab.c */
+void hash_init(hashtab_T *ht);
+int check_hashtab_frozen(hashtab_T *ht, char *command);
+void hash_clear(hashtab_T *ht);
+void hash_clear_all(hashtab_T *ht, int off);
+hashitem_T *hash_find(hashtab_T *ht, char_u *key);
+hashitem_T *hash_lookup(hashtab_T *ht, char_u *key, hash_T hash);
+void hash_debug_results(void);
+int hash_add(hashtab_T *ht, char_u *key, char *command);
+int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash);
+int hash_remove(hashtab_T *ht, hashitem_T *hi, char *command);
+void hash_lock(hashtab_T *ht);
+void hash_lock_size(hashtab_T *ht, int size);
+void hash_unlock(hashtab_T *ht);
+hash_T hash_hash(char_u *key);
+/* vim: set ft=c : */
diff --git a/src/proto/help.pro b/src/proto/help.pro
new file mode 100644
index 0000000..d5fa8d6
--- /dev/null
+++ b/src/proto/help.pro
@@ -0,0 +1,13 @@
+/* help.c */
+void ex_help(exarg_T *eap);
+void ex_helpclose(exarg_T *eap);
+char_u *check_help_lang(char_u *arg);
+int help_heuristic(char_u *matched_string, int offset, int wrong_case);
+int find_help_tags(char_u *arg, int *num_matches, char_u ***matches, int keep_lang);
+void cleanup_help_tags(int num_file, char_u **file);
+void prepare_help_buffer(void);
+void fix_help_buffer(void);
+void ex_exusage(exarg_T *eap);
+void ex_viusage(exarg_T *eap);
+void ex_helptags(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/highlight.pro b/src/proto/highlight.pro
new file mode 100644
index 0000000..33f90c6
--- /dev/null
+++ b/src/proto/highlight.pro
@@ -0,0 +1,49 @@
+/* highlight.c */
+int highlight_num_groups(void);
+char_u *highlight_group_name(int id);
+int highlight_link_id(int id);
+void init_highlight(int both, int reset);
+int load_colors(char_u *name);
+void do_highlight(char_u *line, int forceit, int init);
+void free_highlight(void);
+void restore_cterm_colors(void);
+void set_normal_colors(void);
+char_u *hl_get_font_name(void);
+void hl_set_font_name(char_u *font_name);
+void hl_set_bg_color_name(char_u *name);
+void hl_set_fg_color_name(char_u *name);
+guicolor_T color_name2handle(char_u *name);
+guicolor_T gui_get_color_cmn(char_u *name);
+guicolor_T gui_get_rgb_color_cmn(int r, int g, int b);
+int get_cterm_attr_idx(int attr, int fg, int bg);
+int get_tgc_attr_idx(int attr, guicolor_T fg, guicolor_T bg);
+int get_gui_attr_idx(int attr, guicolor_T fg, guicolor_T bg);
+void clear_hl_tables(void);
+int hl_combine_attr(int char_attr, int prim_attr);
+attrentry_T *syn_gui_attr2entry(int attr);
+int syn_attr2attr(int attr);
+attrentry_T *syn_term_attr2entry(int attr);
+attrentry_T *syn_cterm_attr2entry(int attr);
+char_u *highlight_has_attr(int id, int flag, int modec);
+char_u *highlight_color(int id, char_u *what, int modec);
+long_u highlight_gui_color_rgb(int id, int fg);
+int syn_list_header(int did_header, int outlen, int id);
+int syn_name2id(char_u *name);
+int syn_name2attr(char_u *name);
+int highlight_exists(char_u *name);
+char_u *syn_id2name(int id);
+int syn_namen2id(char_u *linep, int len);
+int syn_check_group(char_u *pp, int len);
+int syn_id2attr(int hl_id);
+int syn_id2colors(int hl_id, guicolor_T *fgp, guicolor_T *bgp);
+void syn_id2cterm_bg(int hl_id, int *fgp, int *bgp);
+int syn_get_final_id(int hl_id);
+void highlight_gui_started(void);
+int highlight_changed(void);
+void set_context_in_highlight_cmd(expand_T *xp, char_u *arg);
+char_u *get_highlight_name(expand_T *xp, int idx);
+char_u *get_highlight_name_ext(expand_T *xp, int idx, int skip_cleared);
+void free_highlight_fonts(void);
+void f_hlget(typval_T *argvars, typval_T *rettv);
+void f_hlset(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/if_cscope.pro b/src/proto/if_cscope.pro
new file mode 100644
index 0000000..cfabc3c
--- /dev/null
+++ b/src/proto/if_cscope.pro
@@ -0,0 +1,12 @@
+/* if_cscope.c */
+char_u *get_cscope_name(expand_T *xp, int idx);
+void set_context_in_cscope_cmd(expand_T *xp, char_u *arg, cmdidx_T cmdidx);
+void ex_cscope(exarg_T *eap);
+void ex_scscope(exarg_T *eap);
+void ex_cstag(exarg_T *eap);
+int cs_fgets(char_u *buf, int size);
+void cs_free_tags(void);
+void cs_print_tags(void);
+void cs_end(void);
+void f_cscope_connection(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/if_lua.pro b/src/proto/if_lua.pro
new file mode 100644
index 0000000..2e5da0c
--- /dev/null
+++ b/src/proto/if_lua.pro
@@ -0,0 +1,12 @@
+/* if_lua.c */
+int lua_enabled(int verbose);
+void lua_end(void);
+void ex_lua(exarg_T *eap);
+void ex_luado(exarg_T *eap);
+void ex_luafile(exarg_T *eap);
+void lua_buffer_free(buf_T *o);
+void lua_window_free(win_T *o);
+void do_luaeval(char_u *str, typval_T *arg, typval_T *rettv);
+int set_ref_in_lua(int copyID);
+void update_package_paths_in_lua(void);
+/* vim: set ft=c : */
diff --git a/src/proto/if_mzsch.pro b/src/proto/if_mzsch.pro
new file mode 100644
index 0000000..26ffa77
--- /dev/null
+++ b/src/proto/if_mzsch.pro
@@ -0,0 +1,17 @@
+/* if_mzsch.c */
+int mzscheme_enabled(int verbose);
+void mzvim_check_threads(void);
+char *did_set_mzquantum(optset_T *args);
+void mzscheme_end(void);
+int mzscheme_main(void);
+void mzscheme_buffer_free(buf_T *buf);
+void mzscheme_window_free(win_T *win);
+void ex_mzscheme(exarg_T *eap);
+void ex_mzfile(exarg_T *eap);
+void do_mzeval(char_u *str, typval_T *rettv);
+void raise_vim_exn(const char *add_info);
+void raise_if_error(void);
+buf_T *get_valid_buffer(void *obj);
+win_T *get_valid_window(void *obj);
+int mzthreads_allowed(void);
+/* vim: set ft=c : */
diff --git a/src/proto/if_ole.pro b/src/proto/if_ole.pro
new file mode 100644
index 0000000..adedf6a
--- /dev/null
+++ b/src/proto/if_ole.pro
@@ -0,0 +1,5 @@
+/* if_ole.cpp */
+void InitOLE(int* pbDoRestart);
+void UninitOLE(void);
+void RegisterMe(int silent);
+void UnregisterMe(int bNotifyUser);
diff --git a/src/proto/if_perl.pro b/src/proto/if_perl.pro
new file mode 100644
index 0000000..066c0db
--- /dev/null
+++ b/src/proto/if_perl.pro
@@ -0,0 +1,9 @@
+/* auto/if_perl.c */
+int perl_enabled(int verbose);
+void perl_end(void);
+void msg_split(char_u *s, int attr);
+void perl_win_free(win_T *wp);
+void perl_buf_free(buf_T *bp);
+void ex_perl(exarg_T *eap);
+void do_perleval(char_u *str, typval_T *rettv);
+void ex_perldo(exarg_T *eap);
diff --git a/src/proto/if_perlsfio.pro b/src/proto/if_perlsfio.pro
new file mode 100644
index 0000000..df8e438
--- /dev/null
+++ b/src/proto/if_perlsfio.pro
@@ -0,0 +1,3 @@
+/* if_perlsfio.c */
+int *sfdcnewvim(void);
+/* vim: set ft=c : */
diff --git a/src/proto/if_python.pro b/src/proto/if_python.pro
new file mode 100644
index 0000000..51054ca
--- /dev/null
+++ b/src/proto/if_python.pro
@@ -0,0 +1,13 @@
+/* if_python.c */
+int python_enabled(int verbose);
+void python_end(void);
+int python_loaded(void);
+void ex_python(exarg_T *eap);
+void ex_pyfile(exarg_T *eap);
+void ex_pydo(exarg_T *eap);
+void python_buffer_free(buf_T *buf);
+void python_window_free(win_T *win);
+void python_tabpage_free(tabpage_T *tab);
+void do_pyeval(char_u *str, typval_T *rettv);
+int set_ref_in_python(int copyID);
+/* vim: set ft=c : */
diff --git a/src/proto/if_python3.pro b/src/proto/if_python3.pro
new file mode 100644
index 0000000..4e71ad2
--- /dev/null
+++ b/src/proto/if_python3.pro
@@ -0,0 +1,13 @@
+/* if_python3.c */
+int python3_enabled(int verbose);
+void python3_end(void);
+int python3_loaded(void);
+void ex_py3(exarg_T *eap);
+void ex_py3file(exarg_T *eap);
+void ex_py3do(exarg_T *eap);
+void python3_buffer_free(buf_T *buf);
+void python3_window_free(win_T *win);
+void python3_tabpage_free(tabpage_T *tab);
+void do_py3eval(char_u *str, typval_T *rettv);
+int set_ref_in_python3(int copyID);
+/* vim: set ft=c : */
diff --git a/src/proto/if_ruby.pro b/src/proto/if_ruby.pro
new file mode 100644
index 0000000..cc7c7e6
--- /dev/null
+++ b/src/proto/if_ruby.pro
@@ -0,0 +1,11 @@
+/* if_ruby.c */
+int ruby_enabled(int verbose);
+void ruby_end(void);
+void ex_ruby(exarg_T *eap);
+void ex_rubydo(exarg_T *eap);
+void ex_rubyfile(exarg_T *eap);
+void ruby_buffer_free(buf_T *buf);
+void ruby_window_free(win_T *win);
+void vim_ruby_init(void *stack_start);
+void do_rubyeval(char_u *str, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/if_tcl.pro b/src/proto/if_tcl.pro
new file mode 100644
index 0000000..b5f1cc2
--- /dev/null
+++ b/src/proto/if_tcl.pro
@@ -0,0 +1,11 @@
+/* if_tcl.c */
+void vim_tcl_init(char *arg);
+int tcl_enabled(int verbose);
+void vim_tcl_finalize(void);
+void tcl_end(void);
+void ex_tcl(exarg_T *eap);
+void ex_tclfile(exarg_T *eap);
+void ex_tcldo(exarg_T *eap);
+void tcl_buffer_free(buf_T *buf);
+void tcl_window_free(win_T *win);
+/* vim: set ft=c : */
diff --git a/src/proto/if_xcmdsrv.pro b/src/proto/if_xcmdsrv.pro
new file mode 100644
index 0000000..801dc00
--- /dev/null
+++ b/src/proto/if_xcmdsrv.pro
@@ -0,0 +1,13 @@
+/* if_xcmdsrv.c */
+int serverRegisterName(Display *dpy, char_u *name);
+void serverChangeRegisteredWindow(Display *dpy, Window newwin);
+int serverSendToVim(Display *dpy, char_u *name, char_u *cmd, char_u **result, Window *server, int asExpr, int timeout, int localLoop, int silent);
+char_u *serverGetVimNames(Display *dpy);
+Window serverStrToWin(char_u *str);
+int serverSendReply(char_u *name, char_u *str);
+int serverReadReply(Display *dpy, Window win, char_u **str, int localLoop, int timeout);
+int serverPeekReply(Display *dpy, Window win, char_u **str);
+void serverEventProc(Display *dpy, XEvent *eventPtr, int immediate);
+void server_parse_messages(void);
+int server_waiting(void);
+/* vim: set ft=c : */
diff --git a/src/proto/indent.pro b/src/proto/indent.pro
new file mode 100644
index 0000000..5ab338d
--- /dev/null
+++ b/src/proto/indent.pro
@@ -0,0 +1,38 @@
+/* indent.c */
+int tabstop_set(char_u *var, int **array);
+int tabstop_padding(colnr_T col, int ts_arg, int *vts);
+int tabstop_at(colnr_T col, int ts, int *vts);
+colnr_T tabstop_start(colnr_T col, int ts, int *vts);
+void tabstop_fromto(colnr_T start_col, colnr_T end_col, int ts_arg, int *vts, int *ntabs, int *nspcs);
+int *tabstop_copy(int *oldts);
+int tabstop_count(int *ts);
+int tabstop_first(int *ts);
+long get_sw_value(buf_T *buf);
+long get_sw_value_indent(buf_T *buf);
+long get_sw_value_col(buf_T *buf, colnr_T col);
+long get_sts_value(void);
+int get_indent(void);
+int get_indent_lnum(linenr_T lnum);
+int get_indent_buf(buf_T *buf, linenr_T lnum);
+int get_indent_str(char_u *ptr, int ts, int list);
+int get_indent_str_vtab(char_u *ptr, int ts, int *vts, int list);
+int set_indent(int size, int flags);
+int get_number_indent(linenr_T lnum);
+int briopt_check(win_T *wp);
+int get_breakindent_win(win_T *wp, char_u *line);
+int inindent(int extra);
+void op_reindent(oparg_T *oap, int (*how)(void));
+int preprocs_left(void);
+int may_do_si(void);
+void ins_try_si(int c);
+void change_indent(int type, int amount, int round, int replaced, int call_changed_bytes);
+int copy_indent(int size, char_u *src);
+void ex_retab(exarg_T *eap);
+int get_expr_indent(void);
+int get_lisp_indent(void);
+void fixthisline(int (*get_the_indent)(void));
+int use_indentexpr_for_lisp(void);
+void fix_indent(void);
+void f_indent(typval_T *argvars, typval_T *rettv);
+void f_lispindent(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/insexpand.pro b/src/proto/insexpand.pro
new file mode 100644
index 0000000..51f5db0
--- /dev/null
+++ b/src/proto/insexpand.pro
@@ -0,0 +1,62 @@
+/* insexpand.c */
+void ins_ctrl_x(void);
+int ctrl_x_mode_none(void);
+int ctrl_x_mode_normal(void);
+int ctrl_x_mode_scroll(void);
+int ctrl_x_mode_whole_line(void);
+int ctrl_x_mode_files(void);
+int ctrl_x_mode_tags(void);
+int ctrl_x_mode_path_patterns(void);
+int ctrl_x_mode_path_defines(void);
+int ctrl_x_mode_dictionary(void);
+int ctrl_x_mode_thesaurus(void);
+int ctrl_x_mode_cmdline(void);
+int ctrl_x_mode_function(void);
+int ctrl_x_mode_omni(void);
+int ctrl_x_mode_spell(void);
+int ctrl_x_mode_line_or_eval(void);
+int ctrl_x_mode_not_default(void);
+int ctrl_x_mode_not_defined_yet(void);
+int compl_status_adding(void);
+int compl_status_sol(void);
+int compl_status_local(void);
+void compl_status_clear(void);
+int has_compl_option(int dict_opt);
+int vim_is_ctrl_x_key(int c);
+int ins_compl_accept_char(int c);
+int ins_compl_add_infercase(char_u *str_arg, int len, int icase, char_u *fname, int dir, int cont_s_ipos);
+int ins_compl_has_shown_match(void);
+int ins_compl_long_shown_match(void);
+void completeopt_was_set(void);
+int pum_wanted(void);
+void ins_compl_show_pum(void);
+char_u *find_word_start(char_u *ptr);
+char_u *find_word_end(char_u *ptr);
+void ins_compl_clear(void);
+int ins_compl_active(void);
+int ins_compl_used_match(void);
+void ins_compl_init_get_longest(void);
+int ins_compl_interrupted(void);
+int ins_compl_enter_selects(void);
+colnr_T ins_compl_col(void);
+int ins_compl_len(void);
+int ins_compl_bs(void);
+void ins_compl_addleader(int c);
+void ins_compl_addfrommatch(void);
+int ins_compl_prep(int c);
+char *did_set_completefunc(optset_T *args);
+void set_buflocal_cfu_callback(buf_T *buf);
+char *did_set_omnifunc(optset_T *args);
+void set_buflocal_ofu_callback(buf_T *buf);
+char *did_set_thesaurusfunc(optset_T *args);
+int set_ref_in_insexpand_funcs(int copyID);
+void f_complete(typval_T *argvars, typval_T *rettv);
+void f_complete_add(typval_T *argvars, typval_T *rettv);
+void f_complete_check(typval_T *argvars, typval_T *rettv);
+void f_complete_info(typval_T *argvars, typval_T *rettv);
+void ins_compl_delete(void);
+void ins_compl_insert(int in_compl_func);
+void ins_compl_check_keys(int frequency, int in_compl_func);
+int ins_complete(int c, int enable_pum);
+void free_insexpand_stuff(void);
+/* vim: set ft=c : */
diff --git a/src/proto/job.pro b/src/proto/job.pro
new file mode 100644
index 0000000..f740bd2
--- /dev/null
+++ b/src/proto/job.pro
@@ -0,0 +1,37 @@
+/* job.c */
+void clear_job_options(jobopt_T *opt);
+void free_job_options(jobopt_T *opt);
+int get_job_options(typval_T *tv, jobopt_T *opt, int supported, int supported2);
+void job_free_all(void);
+int job_any_running(void);
+int win32_build_cmd(list_T *l, garray_T *gap);
+void job_cleanup(job_T *job);
+int set_ref_in_job(int copyID);
+void job_unref(job_T *job);
+int free_unused_jobs_contents(int copyID, int mask);
+void free_unused_jobs(int copyID, int mask);
+job_T *job_alloc(void);
+void job_set_options(job_T *job, jobopt_T *opt);
+void job_stop_on_exit(void);
+int has_pending_job(void);
+int job_check_ended(void);
+job_T *job_start(typval_T *argvars, char **argv_arg, jobopt_T *opt_arg, job_T **term_job);
+char *job_status(job_T *job);
+int job_stop(job_T *job, typval_T *argvars, char *type);
+void invoke_prompt_callback(void);
+int invoke_prompt_interrupt(void);
+char_u *prompt_text(void);
+void init_prompt(int cmdchar_todo);
+int prompt_curpos_editable(void);
+void f_prompt_setcallback(typval_T *argvars, typval_T *rettv);
+void f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv);
+void f_prompt_getprompt(typval_T *argvars, typval_T *rettv);
+void f_prompt_setprompt(typval_T *argvars, typval_T *rettv);
+void f_job_getchannel(typval_T *argvars, typval_T *rettv);
+void f_job_info(typval_T *argvars, typval_T *rettv);
+void f_job_setoptions(typval_T *argvars, typval_T *rettv);
+void f_job_start(typval_T *argvars, typval_T *rettv);
+void f_job_status(typval_T *argvars, typval_T *rettv);
+void f_job_stop(typval_T *argvars, typval_T *rettv);
+char_u *job_to_string_buf(typval_T *varp, char_u *buf);
+/* vim: set ft=c : */
diff --git a/src/proto/json.pro b/src/proto/json.pro
new file mode 100644
index 0000000..f05c131
--- /dev/null
+++ b/src/proto/json.pro
@@ -0,0 +1,11 @@
+/* json.c */
+char_u *json_encode(typval_T *val, int options);
+char_u *json_encode_nr_expr(int nr, typval_T *val, int options);
+char_u *json_encode_lsp_msg(typval_T *val);
+int json_decode(js_read_T *reader, typval_T *res, int options);
+int json_find_end(js_read_T *reader, int options);
+void f_js_decode(typval_T *argvars, typval_T *rettv);
+void f_js_encode(typval_T *argvars, typval_T *rettv);
+void f_json_decode(typval_T *argvars, typval_T *rettv);
+void f_json_encode(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/list.pro b/src/proto/list.pro
new file mode 100644
index 0000000..5abe03c
--- /dev/null
+++ b/src/proto/list.pro
@@ -0,0 +1,67 @@
+/* list.c */
+void list_add_watch(list_T *l, listwatch_T *lw);
+void list_rem_watch(list_T *l, listwatch_T *lwrem);
+list_T *list_alloc(void);
+list_T *list_alloc_id(alloc_id_T id);
+list_T *list_alloc_with_items(int count);
+void list_set_item(list_T *l, int idx, typval_T *tv);
+int rettv_list_alloc(typval_T *rettv);
+int rettv_list_alloc_id(typval_T *rettv, alloc_id_T id);
+void rettv_list_set(typval_T *rettv, list_T *l);
+void list_unref(list_T *l);
+int list_free_nonref(int copyID);
+void list_free_items(int copyID);
+void list_free(list_T *l);
+listitem_T *listitem_alloc(void);
+void listitem_free(list_T *l, listitem_T *item);
+void listitem_remove(list_T *l, listitem_T *item);
+long list_len(list_T *l);
+int list_equal(list_T *l1, list_T *l2, int ic, int recursive);
+listitem_T *list_find(list_T *l, long n);
+long list_find_nr(list_T *l, long idx, int *errorp);
+char_u *list_find_str(list_T *l, long idx);
+listitem_T *list_find_index(list_T *l, long *idx);
+long list_idx_of_item(list_T *l, listitem_T *item);
+void list_append(list_T *l, listitem_T *item);
+int list_append_tv(list_T *l, typval_T *tv);
+int list_append_dict(list_T *list, dict_T *dict);
+int list_append_list(list_T *list1, list_T *list2);
+int list_append_string(list_T *l, char_u *str, int len);
+int list_append_number(list_T *l, varnumber_T n);
+int list_insert_tv(list_T *l, typval_T *tv, listitem_T *item);
+void list_insert(list_T *l, listitem_T *ni, listitem_T *item);
+listitem_T *check_range_index_one(list_T *l, long *n1, int can_append, int quiet);
+int check_range_index_two(list_T *l, long *n1, listitem_T *li1, long *n2, int quiet);
+int list_assign_range(list_T *dest, list_T *src, long idx1_arg, long idx2, int empty_idx2, char_u *op, char_u *varname);
+void f_flatten(typval_T *argvars, typval_T *rettv);
+void f_flattennew(typval_T *argvars, typval_T *rettv);
+void list2items(typval_T *argvars, typval_T *rettv);
+void string2items(typval_T *argvars, typval_T *rettv);
+int list_extend(list_T *l1, list_T *l2, listitem_T *bef);
+int list_concat(list_T *l1, list_T *l2, typval_T *tv);
+list_T *list_slice(list_T *ol, long n1, long n2);
+int list_slice_or_index(list_T *list, int range, varnumber_T n1_arg, varnumber_T n2_arg, int exclusive, typval_T *rettv, int verbose);
+list_T *list_copy(list_T *orig, int deep, int top, int copyID);
+void vimlist_remove(list_T *l, listitem_T *item, listitem_T *item2);
+char_u *list2string(typval_T *tv, int copyID, int restore_copyID);
+int list_join(garray_T *gap, list_T *l, char_u *sep, int echo_style, int restore_copyID, int copyID);
+void f_join(typval_T *argvars, typval_T *rettv);
+int eval_list(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int do_error);
+int write_list(FILE *fd, list_T *list, int binary);
+void init_static_list(staticList10_T *sl);
+void f_list2str(typval_T *argvars, typval_T *rettv);
+void f_sort(typval_T *argvars, typval_T *rettv);
+void f_uniq(typval_T *argvars, typval_T *rettv);
+int filter_map_one(typval_T *tv, typval_T *expr, filtermap_T filtermap, funccall_T *fc, typval_T *newtv, int *remp);
+void f_filter(typval_T *argvars, typval_T *rettv);
+void f_map(typval_T *argvars, typval_T *rettv);
+void f_mapnew(typval_T *argvars, typval_T *rettv);
+void f_add(typval_T *argvars, typval_T *rettv);
+void f_count(typval_T *argvars, typval_T *rettv);
+void f_extend(typval_T *argvars, typval_T *rettv);
+void f_extendnew(typval_T *argvars, typval_T *rettv);
+void f_insert(typval_T *argvars, typval_T *rettv);
+void f_remove(typval_T *argvars, typval_T *rettv);
+void f_reverse(typval_T *argvars, typval_T *rettv);
+void f_reduce(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/locale.pro b/src/proto/locale.pro
new file mode 100644
index 0000000..151e68a
--- /dev/null
+++ b/src/proto/locale.pro
@@ -0,0 +1,9 @@
+/* locale.c */
+char_u *get_mess_lang(void);
+void set_lang_var(void);
+void init_locale(void);
+void ex_language(exarg_T *eap);
+void free_locales(void);
+char_u *get_lang_arg(expand_T *xp, int idx);
+char_u *get_locales(expand_T *xp, int idx);
+/* vim: set ft=c : */
diff --git a/src/proto/logfile.pro b/src/proto/logfile.pro
new file mode 100644
index 0000000..1c4334e
--- /dev/null
+++ b/src/proto/logfile.pro
@@ -0,0 +1,7 @@
+/* logfile.c */
+void ch_logfile(char_u *fname, char_u *opt);
+int ch_log_active(void);
+void ch_log_literal(char *lead, channel_T *ch, ch_part_T part, char_u *buf, int len);
+void f_ch_log(typval_T *argvars, typval_T *rettv);
+void f_ch_logfile(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/main.pro b/src/proto/main.pro
new file mode 100644
index 0000000..307b606
--- /dev/null
+++ b/src/proto/main.pro
@@ -0,0 +1,18 @@
+/* main.c */
+int vim_main2(void);
+void common_init(mparm_T *paramp);
+int is_not_a_term(void);
+int is_not_a_term_or_gui(void);
+char_u *get_gui_dialog_file(void);
+int op_pending(void);
+void may_trigger_safestate(int safe);
+void state_no_longer_safe(char *reason);
+int get_was_safe_state(void);
+void may_trigger_safestateagain(void);
+int work_pending(void);
+void main_loop(int cmdwin, int noexmode);
+void getout_preserve_modified(int exitval);
+void getout(int exitval);
+int process_env(char_u *env, int is_viminit);
+void mainerr_arg_missing(char_u *str);
+/* vim: set ft=c : */
diff --git a/src/proto/map.pro b/src/proto/map.pro
new file mode 100644
index 0000000..d696aab
--- /dev/null
+++ b/src/proto/map.pro
@@ -0,0 +1,35 @@
+/* map.c */
+mapblock_T *get_maphash_list(int state, int c);
+mapblock_T *get_buf_maphash_list(int state, int c);
+int is_maphash_valid(void);
+int do_map(int maptype, char_u *arg, int mode, int abbrev);
+void map_clear_mode(buf_T *buf, int mode, int local, int abbr);
+int mode_str2flags(char_u *modechars);
+int map_to_exists(char_u *str, char_u *modechars, int abbr);
+int map_to_exists_mode(char_u *rhs, int mode, int abbr);
+char_u *set_context_in_map_cmd(expand_T *xp, char_u *cmd, char_u *arg, int forceit, int isabbrev, int isunmap, cmdidx_T cmdidx);
+int ExpandMappings(char_u *pat, regmatch_T *regmatch, int *numMatches, char_u ***matches);
+int check_abbr(int c, char_u *ptr, int col, int mincol);
+char_u *eval_map_expr(mapblock_T *mp, int c);
+char_u *vim_strsave_escape_csi(char_u *p);
+void vim_unescape_csi(char_u *p);
+int makemap(FILE *fd, buf_T *buf);
+int put_escstr(FILE *fd, char_u *strstart, int what);
+void check_map_keycodes(void);
+char_u *check_map(char_u *keys, int mode, int exact, int ign_mod, int abbr, mapblock_T **mp_ptr, int *local_ptr);
+void f_hasmapto(typval_T *argvars, typval_T *rettv);
+void f_maplist(typval_T *argvars, typval_T *rettv);
+void f_maparg(typval_T *argvars, typval_T *rettv);
+void f_mapcheck(typval_T *argvars, typval_T *rettv);
+void f_mapset(typval_T *argvars, typval_T *rettv);
+void init_mappings(void);
+void add_map(char_u *map, int mode, int nore);
+int langmap_adjust_mb(int c);
+void langmap_init(void);
+char *did_set_langmap(optset_T *args);
+void ex_abbreviate(exarg_T *eap);
+void ex_map(exarg_T *eap);
+void ex_unmap(exarg_T *eap);
+void ex_mapclear(exarg_T *eap);
+void ex_abclear(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/mark.pro b/src/proto/mark.pro
new file mode 100644
index 0000000..cc45f0d
--- /dev/null
+++ b/src/proto/mark.pro
@@ -0,0 +1,31 @@
+/* mark.c */
+int setmark(int c);
+int setmark_pos(int c, pos_T *pos, int fnum);
+void setpcmark(void);
+void checkpcmark(void);
+pos_T *movemark(int count);
+pos_T *movechangelist(int count);
+pos_T *getmark_buf(buf_T *buf, int c, int changefile);
+pos_T *getmark(int c, int changefile);
+pos_T *getmark_buf_fnum(buf_T *buf, int c, int changefile, int *fnum);
+pos_T *getnextmark(pos_T *startpos, int dir, int begin_line);
+void fmarks_check_names(buf_T *buf);
+int check_mark(pos_T *pos);
+void clrallmarks(buf_T *buf);
+char_u *fm_getname(fmark_T *fmark, int lead_len);
+void ex_marks(exarg_T *eap);
+void ex_delmarks(exarg_T *eap);
+void ex_jumps(exarg_T *eap);
+void ex_clearjumps(exarg_T *eap);
+void ex_changes(exarg_T *eap);
+void mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
+void mark_adjust_nofold(linenr_T line1, linenr_T line2, long amount, long amount_after);
+void mark_col_adjust(linenr_T lnum, colnr_T mincol, long lnum_amount, long col_amount, int spaces_removed);
+void cleanup_jumplist(win_T *wp, int loadfiles);
+void copy_jumplist(win_T *from, win_T *to);
+void free_jumplist(win_T *wp);
+void set_last_cursor(win_T *win);
+void free_all_marks(void);
+xfmark_T *get_namedfm(void);
+void f_getmarklist(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/match.pro b/src/proto/match.pro
new file mode 100644
index 0000000..f96a4e6
--- /dev/null
+++ b/src/proto/match.pro
@@ -0,0 +1,17 @@
+/* match.c */
+void clear_matches(win_T *wp);
+void init_search_hl(win_T *wp, match_T *search_hl);
+void prepare_search_hl(win_T *wp, match_T *search_hl, linenr_T lnum);
+int prepare_search_hl_line(win_T *wp, linenr_T lnum, colnr_T mincol, char_u **line, match_T *search_hl, int *search_attr);
+int update_search_hl(win_T *wp, linenr_T lnum, colnr_T col, char_u **line, match_T *search_hl, int *has_match_conc, int *match_conc, int did_line_attr, int lcs_eol_one, int *on_last_col);
+int get_prevcol_hl_flag(win_T *wp, match_T *search_hl, long curcol);
+void get_search_match_hl(win_T *wp, match_T *search_hl, long col, int *char_attr);
+void f_clearmatches(typval_T *argvars, typval_T *rettv);
+void f_getmatches(typval_T *argvars, typval_T *rettv);
+void f_setmatches(typval_T *argvars, typval_T *rettv);
+void f_matchadd(typval_T *argvars, typval_T *rettv);
+void f_matchaddpos(typval_T *argvars, typval_T *rettv);
+void f_matcharg(typval_T *argvars, typval_T *rettv);
+void f_matchdelete(typval_T *argvars, typval_T *rettv);
+void ex_match(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/mbyte.pro b/src/proto/mbyte.pro
new file mode 100644
index 0000000..1bd3aa0
--- /dev/null
+++ b/src/proto/mbyte.pro
@@ -0,0 +1,91 @@
+/* mbyte.c */
+int enc_canon_props(char_u *name);
+char *mb_init(void);
+int bomb_size(void);
+void remove_bom(char_u *s);
+int mb_get_class(char_u *p);
+int mb_get_class_buf(char_u *p, buf_T *buf);
+int dbcs_class(unsigned lead, unsigned trail);
+int latin_char2len(int c);
+int latin_char2bytes(int c, char_u *buf);
+int latin_ptr2len(char_u *p);
+int latin_ptr2len_len(char_u *p, int size);
+int utf_uint2cells(UINT32_T c);
+int utf_char2cells(int c);
+int latin_ptr2cells(char_u *p);
+int utf_ptr2cells(char_u *p);
+int dbcs_ptr2cells(char_u *p);
+int latin_ptr2cells_len(char_u *p, int size);
+int latin_char2cells(int c);
+int mb_string2cells(char_u *p, int len);
+int latin_off2cells(unsigned off, unsigned max_off);
+int dbcs_off2cells(unsigned off, unsigned max_off);
+int utf_off2cells(unsigned off, unsigned max_off);
+int latin_ptr2char(char_u *p);
+int utf_ptr2char(char_u *p);
+int mb_ptr2char_adv(char_u **pp);
+int mb_cptr2char_adv(char_u **pp);
+int utf_composinglike(char_u *p1, char_u *p2);
+int utfc_ptr2char(char_u *p, int *pcc);
+int utfc_ptr2char_len(char_u *p, int *pcc, int maxlen);
+int utfc_char2bytes(int off, char_u *buf);
+int utf_ptr2len(char_u *p);
+int utf_byte2len(int b);
+int utf_ptr2len_len(char_u *p, int size);
+int utfc_ptr2len(char_u *p);
+int utfc_ptr2len_len(char_u *p, int size);
+int utf_char2len(int c);
+int utf_char2bytes(int c, char_u *buf);
+int utf_iscomposing_uint(UINT32_T c);
+int utf_iscomposing(int c);
+int utf_printable(int c);
+int utf_class(int c);
+int utf_class_buf(int c, buf_T *buf);
+int utf_ambiguous_width(int c);
+int utf_fold(int a);
+int utf_toupper(int a);
+int utf_islower(int a);
+int utf_tolower(int a);
+int utf_isupper(int a);
+int mb_strnicmp(char_u *s1, char_u *s2, size_t nn);
+void show_utf8(void);
+int latin_head_off(char_u *base, char_u *p);
+int dbcs_screen_head_off(char_u *base, char_u *p);
+int utf_head_off(char_u *base, char_u *p);
+int utf_eat_space(int cc);
+int utf_allow_break_before(int cc);
+int utf_allow_break(int cc, int ncc);
+void mb_copy_char(char_u **fp, char_u **tp);
+int mb_off_next(char_u *base, char_u *p);
+int mb_tail_off(char_u *base, char_u *p);
+void utf_find_illegal(void);
+int utf_valid_string(char_u *s, char_u *end);
+int dbcs_screen_tail_off(char_u *base, char_u *p);
+void mb_adjust_cursor(void);
+void mb_adjustpos(buf_T *buf, pos_T *lp);
+char_u *mb_prevptr(char_u *line, char_u *p);
+int mb_charlen(char_u *str);
+int mb_charlen_len(char_u *str, int len);
+char_u *mb_unescape(char_u **pp);
+int mb_lefthalve(int row, int col);
+int mb_fix_col(int col, int row);
+char_u *enc_skip(char_u *p);
+char_u *enc_canonize(char_u *enc);
+char_u *enc_locale_env(char *locale);
+char_u *enc_locale(void);
+int encname2codepage(char_u *name);
+void *my_iconv_open(char_u *to, char_u *from);
+int iconv_enabled(int verbose);
+void iconv_end(void);
+void f_getimstatus(typval_T *argvars, typval_T *rettv);
+void f_iconv(typval_T *argvars, typval_T *rettv);
+int convert_setup(vimconv_T *vcp, char_u *from, char_u *to);
+int convert_setup_ext(vimconv_T *vcp, char_u *from, int from_unicode_is_utf8, char_u *to, int to_unicode_is_utf8);
+int convert_input(char_u *ptr, int len, int maxlen);
+int convert_input_safe(char_u *ptr, int len, int maxlen, char_u **restp, int *restlenp);
+char_u *string_convert(vimconv_T *vcp, char_u *ptr, int *lenp);
+char_u *string_convert_ext(vimconv_T *vcp, char_u *ptr, int *lenp, int *unconvlenp);
+void f_setcellwidths(typval_T *argvars, typval_T *rettv);
+void f_getcellwidths(typval_T *argvars, typval_T *rettv);
+void f_charclass(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/memfile.pro b/src/proto/memfile.pro
new file mode 100644
index 0000000..4662194
--- /dev/null
+++ b/src/proto/memfile.pro
@@ -0,0 +1,18 @@
+/* memfile.c */
+memfile_T *mf_open(char_u *fname, int flags);
+int mf_open_file(memfile_T *mfp, char_u *fname);
+void mf_close(memfile_T *mfp, int del_file);
+void mf_close_file(buf_T *buf, int getlines);
+void mf_new_page_size(memfile_T *mfp, unsigned new_size);
+bhdr_T *mf_new(memfile_T *mfp, int negative, int page_count);
+bhdr_T *mf_get(memfile_T *mfp, blocknr_T nr, int page_count);
+void mf_put(memfile_T *mfp, bhdr_T *hp, int dirty, int infile);
+void mf_free(memfile_T *mfp, bhdr_T *hp);
+int mf_sync(memfile_T *mfp, int flags);
+void mf_set_dirty(memfile_T *mfp);
+int mf_release_all(void);
+blocknr_T mf_trans_del(memfile_T *mfp, blocknr_T old_nr);
+void mf_set_ffname(memfile_T *mfp);
+void mf_fullname(memfile_T *mfp);
+int mf_need_trans(memfile_T *mfp);
+/* vim: set ft=c : */
diff --git a/src/proto/memline.pro b/src/proto/memline.pro
new file mode 100644
index 0000000..3fa8707
--- /dev/null
+++ b/src/proto/memline.pro
@@ -0,0 +1,42 @@
+/* memline.c */
+int ml_open(buf_T *buf);
+void ml_set_crypt_key(buf_T *buf, char_u *old_key, char_u *old_cm);
+void ml_setname(buf_T *buf);
+void ml_open_files(void);
+void ml_open_file(buf_T *buf);
+void check_need_swap(int newfile);
+void ml_close(buf_T *buf, int del_file);
+void ml_close_all(int del_file);
+void ml_close_notmod(void);
+void ml_timestamp(buf_T *buf);
+void ml_recover(int checkext);
+int recover_names(char_u *fname, int do_list, list_T *ret_list, int nr, char_u **fname_out);
+char_u *make_percent_swname(char_u *dir, char_u *name);
+void get_b0_dict(char_u *fname, dict_T *d);
+void ml_sync_all(int check_file, int check_char);
+void ml_preserve(buf_T *buf, int message);
+char_u *ml_get(linenr_T lnum);
+char_u *ml_get_pos(pos_T *pos);
+char_u *ml_get_curline(void);
+char_u *ml_get_cursor(void);
+char_u *ml_get_buf(buf_T *buf, linenr_T lnum, int will_change);
+int ml_line_alloced(void);
+int ml_append(linenr_T lnum, char_u *line, colnr_T len, int newfile);
+int ml_append_flags(linenr_T lnum, char_u *line, colnr_T len, int flags);
+int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, int newfile);
+int ml_replace(linenr_T lnum, char_u *line, int copy);
+int ml_replace_len(linenr_T lnum, char_u *line_arg, colnr_T len_arg, int has_props, int copy);
+int ml_delete(linenr_T lnum);
+int ml_delete_flags(linenr_T lnum, int flags);
+void ml_setmarked(linenr_T lnum);
+linenr_T ml_firstmarked(void);
+void ml_clearmarked(void);
+int resolve_symlink(char_u *fname, char_u *buf);
+char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name);
+char_u *get_file_in_dir(char_u *fname, char_u *dname);
+void ml_setflags(buf_T *buf);
+char_u *ml_encrypt_data(memfile_T *mfp, char_u *data, off_T offset, unsigned size);
+void ml_decrypt_data(memfile_T *mfp, char_u *data, off_T offset, unsigned size);
+long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp);
+void goto_byte(long cnt);
+/* vim: set ft=c : */
diff --git a/src/proto/menu.pro b/src/proto/menu.pro
new file mode 100644
index 0000000..b95f531
--- /dev/null
+++ b/src/proto/menu.pro
@@ -0,0 +1,27 @@
+/* menu.c */
+int winbar_height(win_T *wp);
+void ex_menu(exarg_T *eap);
+void remove_winbar(win_T *wp);
+char_u *set_context_in_menu_cmd(expand_T *xp, char_u *cmd, char_u *arg, int forceit);
+char_u *get_menu_name(expand_T *xp, int idx);
+char_u *get_menu_names(expand_T *xp, int idx);
+int get_menu_index(vimmenu_T *menu, int state);
+int menu_is_menubar(char_u *name);
+int menu_is_popup(char_u *name);
+int menu_is_child_of_popup(vimmenu_T *menu);
+int menu_is_toolbar(char_u *name);
+int menu_is_separator(char_u *name);
+int get_menu_mode_flag(void);
+void show_popupmenu(void);
+int check_menu_pointer(vimmenu_T *root, vimmenu_T *menu_to_check);
+void gui_create_initial_menus(vimmenu_T *menu);
+void gui_update_menus(int modes);
+int gui_is_menu_shortcut(int key);
+void gui_mch_toggle_tearoffs(int enable);
+void execute_menu(exarg_T *eap, vimmenu_T *menu, int mode_idx);
+void ex_emenu(exarg_T *eap);
+void winbar_click(win_T *wp, int col);
+vimmenu_T *gui_find_menu(char_u *path_name);
+void ex_menutranslate(exarg_T *eap);
+void f_menu_info(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/message.pro b/src/proto/message.pro
new file mode 100644
index 0000000..6657a08
--- /dev/null
+++ b/src/proto/message.pro
@@ -0,0 +1,80 @@
+/* message.c */
+int msg(char *s);
+int verb_msg(char *s);
+int msg_attr(char *s, int attr);
+int msg_attr_keep(char *s, int attr, int keep);
+char_u *msg_strtrunc(char_u *s, int force);
+void trunc_string(char_u *s, char_u *buf, int room_in, int buflen);
+void reset_last_sourcing(void);
+void msg_source(int attr);
+void ignore_error_for_testing(char_u *error);
+void do_perror(char *msg);
+int emsg(char *s);
+void iemsg(char *s);
+void internal_error(char *where);
+void internal_error_no_abort(char *where);
+void emsg_invreg(int name);
+void emsg_namelen(char *msg, char_u *name, int len);
+char *msg_trunc_attr(char *s, int force, int attr);
+char_u *msg_may_trunc(int force, char_u *s);
+int delete_first_msg(void);
+void ex_messages(exarg_T *eap);
+void msg_end_prompt(void);
+void wait_return(int redraw);
+void set_keep_msg(char_u *s, int attr);
+void set_keep_msg_from_hist(void);
+void msg_start(void);
+void msg_starthere(void);
+void msg_putchar(int c);
+void msg_putchar_attr(int c, int attr);
+void msg_outnum(long n);
+void msg_home_replace(char_u *fname);
+void msg_home_replace_hl(char_u *fname);
+int msg_outtrans(char_u *str);
+int msg_outtrans_attr(char_u *str, int attr);
+int msg_outtrans_len(char_u *str, int len);
+char_u *msg_outtrans_one(char_u *p, int attr);
+int msg_outtrans_len_attr(char_u *msgstr, int len, int attr);
+void msg_make(char_u *arg);
+int msg_outtrans_special(char_u *strstart, int from, int maxlen);
+char_u *str2special_save(char_u *str, int replace_spaces, int replace_lt);
+char_u *str2special(char_u **sp, int replace_spaces, int replace_lt);
+void str2specialbuf(char_u *sp, char_u *buf, int len);
+void msg_prt_line(char_u *s, int list);
+void msg_puts(char *s);
+void msg_puts_title(char *s);
+void msg_outtrans_long_attr(char_u *longstr, int attr);
+void msg_puts_attr(char *s, int attr);
+int message_filtered(char_u *msg);
+void may_clear_sb_text(void);
+void sb_text_start_cmdline(void);
+void sb_text_restart_cmdline(void);
+void sb_text_end_cmdline(void);
+void clear_sb_text(int all);
+void show_sb_text(void);
+void msg_sb_eol(void);
+int msg_use_printf(void);
+void mch_errmsg(char *str);
+void mch_msg(char *str);
+void repeat_message(void);
+void msg_clr_eos(void);
+void msg_clr_eos_force(void);
+void msg_clr_cmdline(void);
+int msg_end(void);
+void msg_check(void);
+int redirecting(void);
+void verbose_enter(void);
+void verbose_leave(void);
+void verbose_enter_scroll(void);
+void verbose_leave_scroll(void);
+void verbose_stop(void);
+int verbose_open(void);
+void give_warning(char_u *message, int hl);
+void give_warning_with_source(char_u *message, int hl, int with_source);
+void give_warning2(char_u *message, char_u *a1, 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 ex_cmd);
+int vim_dialog_yesno(int type, char_u *title, char_u *message, int dflt);
+int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt);
+int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message, int dflt);
+/* vim: set ft=c : */
diff --git a/src/proto/misc1.pro b/src/proto/misc1.pro
new file mode 100644
index 0000000..5884821
--- /dev/null
+++ b/src/proto/misc1.pro
@@ -0,0 +1,56 @@
+/* misc1.c */
+int get_leader_len(char_u *line, char_u **flags, int backward, int include_space);
+int get_last_leader_offset(char_u *line, char_u **flags);
+int plines(linenr_T lnum);
+int plines_win(win_T *wp, linenr_T lnum, int winheight);
+int plines_nofill(linenr_T lnum);
+int plines_win_nofill(win_T *wp, linenr_T lnum, int winheight);
+int plines_win_nofold(win_T *wp, linenr_T lnum);
+int plines_win_col(win_T *wp, linenr_T lnum, long column);
+int plines_m_win(win_T *wp, linenr_T first, linenr_T last);
+int gchar_pos(pos_T *pos);
+int gchar_cursor(void);
+void pchar_cursor(int c);
+char_u *skip_to_option_part(char_u *p);
+void check_status(buf_T *buf);
+int ask_yesno(char_u *str, int direct);
+void get_mode(char_u *buf);
+void f_mode(typval_T *argvars, typval_T *rettv);
+void f_state(typval_T *argvars, typval_T *rettv);
+int get_keystroke(void);
+int get_number(int colon, int *mouse_used);
+int prompt_for_number(int *mouse_used);
+void msgmore(long n);
+void beep_flush(void);
+void vim_beep(unsigned val);
+void init_homedir(void);
+void free_homedir(void);
+void free_users(void);
+void init_vimdir(void);
+char_u *expand_env_save(char_u *src);
+char_u *expand_env_save_opt(char_u *src, int one);
+void expand_env(char_u *src, char_u *dst, int dstlen);
+void expand_env_esc(char_u *srcp, char_u *dst, int dstlen, int esc, int one, char_u *startstr);
+char_u *vim_getenv(char_u *name, int *mustfree);
+void vim_unsetenv(char_u *var);
+void vim_unsetenv_ext(char_u *var);
+void vim_setenv_ext(char_u *name, char_u *val);
+void vim_setenv(char_u *name, char_u *val);
+char_u *get_env_name(expand_T *xp, int idx);
+char_u *get_users(expand_T *xp, int idx);
+int match_user(char_u *name);
+void preserve_exit(void);
+void line_breakcheck(void);
+void fast_breakcheck(void);
+void veryfast_breakcheck(void);
+char_u *get_cmd_output(char_u *cmd, char_u *infile, int flags, int *ret_len);
+void f_system(typval_T *argvars, typval_T *rettv);
+void f_systemlist(typval_T *argvars, typval_T *rettv);
+int goto_im(void);
+char_u *get_isolated_shell_name(void);
+int path_is_url(char_u *p);
+int path_with_url(char_u *fname);
+dict_T *get_v_event(save_v_event_T *sve);
+void restore_v_event(dict_T *v_event, save_v_event_T *sve);
+void may_trigger_modechanged(void);
+/* vim: set ft=c : */
diff --git a/src/proto/misc2.pro b/src/proto/misc2.pro
new file mode 100644
index 0000000..f596ffa
--- /dev/null
+++ b/src/proto/misc2.pro
@@ -0,0 +1,64 @@
+/* misc2.c */
+int virtual_active(void);
+int getviscol(void);
+int coladvance_force(colnr_T wcol);
+int getviscol2(colnr_T col, colnr_T coladd);
+int coladvance(colnr_T wantcol);
+int getvpos(pos_T *pos, colnr_T wantcol);
+int inc_cursor(void);
+int inc(pos_T *lp);
+int incl(pos_T *lp);
+int dec_cursor(void);
+int dec(pos_T *lp);
+int decl(pos_T *lp);
+linenr_T get_cursor_rel_lnum(win_T *wp, linenr_T lnum);
+void check_pos(buf_T *buf, pos_T *pos);
+void check_cursor_lnum(void);
+void check_cursor_col(void);
+void check_cursor_col_win(win_T *win);
+void check_cursor(void);
+void check_visual_pos(void);
+void adjust_cursor_col(void);
+int set_leftcol(colnr_T leftcol);
+int copy_option_part(char_u **option, char_u *buf, int maxlen, char *sep_chars);
+int vim_isspace(int x);
+int simplify_key(int key, int *modifiers);
+int handle_x_keys(int key);
+char_u *get_special_key_name(int c, int modifiers);
+int trans_special(char_u **srcp, char_u *dst, int flags, int escape_ks, int *did_simplify);
+int special_to_buf(int key, int modifiers, int escape_ks, char_u *dst);
+int find_special_key(char_u **srcp, int *modp, int flags, int *did_simplify);
+int may_adjust_key_for_ctrl(int modifiers, int key);
+int may_remove_shift_modifier(int modifiers, int key);
+int extract_modifiers(int key, int *modp, int simplify, int *did_simplify);
+int find_special_key_in_table(int c);
+int get_special_key_code(char_u *name);
+char_u *get_key_name(int i);
+int get_fileformat(buf_T *buf);
+int get_fileformat_force(buf_T *buf, exarg_T *eap);
+void set_fileformat(int t, int opt_flags);
+int default_fileformat(void);
+int call_shell(char_u *cmd, int opt);
+int get_real_state(void);
+int after_pathsep(char_u *b, char_u *p);
+int same_directory(char_u *f1, char_u *f2);
+int vim_chdirfile(char_u *fname, char *trigger_autocmd);
+int vim_stat(const char *name, stat_T *stp);
+char *parse_shape_opt(int what);
+int get_shape_idx(int mouse);
+void update_mouseshape(int shape_idx);
+void f_getmouseshape(typval_T *argvars, typval_T *rettv);
+int vim_chdir(char_u *new_dir);
+int get_user_name(char_u *buf, int len);
+void free_username(void);
+int filewritable(char_u *fname);
+int get2c(FILE *fd);
+int get3c(FILE *fd);
+int get4c(FILE *fd);
+char_u *read_string(FILE *fd, int cnt);
+int put_bytes(FILE *fd, long_u nr, int len);
+int mch_parse_cmd(char_u *cmd, int use_shcf, char ***argv, int *argc);
+int build_argv_from_string(char_u *cmd, char ***argv, int *argc);
+int build_argv_from_list(list_T *l, char ***argv, int *argc);
+int get_special_pty_type(void);
+/* vim: set ft=c : */
diff --git a/src/proto/mouse.pro b/src/proto/mouse.pro
new file mode 100644
index 0000000..2127d82
--- /dev/null
+++ b/src/proto/mouse.pro
@@ -0,0 +1,26 @@
+/* mouse.c */
+void mouse_set_vert_scroll_step(long step);
+void mouse_set_hor_scroll_step(long step);
+int do_mouse(oparg_T *oap, int c, int dir, long count, int fixindent);
+void ins_mouse(int c);
+void ins_mousescroll(int dir);
+int is_mouse_key(int c);
+int get_mouse_button(int code, int *is_click, int *is_drag);
+int get_pseudo_mouse_code(int button, int is_click, int is_drag);
+void set_mouse_termcode(int n, char_u *s);
+void del_mouse_termcode(int n);
+void setmouse(void);
+int mouse_has(int c);
+int mouse_model_popup(void);
+void reset_dragwin(void);
+int jump_to_mouse(int flags, int *inclusive, int which_button);
+int do_mousescroll_horiz(long_u leftcol);
+void nv_mousescroll(cmdarg_T *cap);
+void nv_mouse(cmdarg_T *cap);
+void reset_held_button(void);
+int check_termcode_mouse(char_u *tp, int *slen, char_u *key_name, char_u *modifiers_start, int idx, int *modifiers);
+int mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump, int *plines_cache);
+win_T *mouse_find_win(int *rowp, int *colp, mouse_find_T popup);
+int vcol2col(win_T *wp, linenr_T lnum, int vcol);
+void f_getmousepos(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/move.pro b/src/proto/move.pro
new file mode 100644
index 0000000..0858e26
--- /dev/null
+++ b/src/proto/move.pro
@@ -0,0 +1,51 @@
+/* move.c */
+void redraw_for_cursorline(win_T *wp);
+void update_topline_redraw(void);
+void update_topline(void);
+void update_curswant_force(void);
+void update_curswant(void);
+void check_cursor_moved(win_T *wp);
+void changed_window_setting(void);
+void changed_window_setting_win(win_T *wp);
+void changed_window_setting_buf(buf_T *buf);
+void set_topline(win_T *wp, linenr_T lnum);
+void changed_cline_bef_curs(void);
+void changed_cline_bef_curs_win(win_T *wp);
+void changed_line_abv_curs(void);
+void changed_line_abv_curs_win(win_T *wp);
+void changed_line_display_buf(buf_T *buf);
+void validate_botline(void);
+void validate_botline_win(win_T *wp);
+void invalidate_botline(void);
+void invalidate_botline_win(win_T *wp);
+void approximate_botline_win(win_T *wp);
+int cursor_valid(void);
+void validate_cursor(void);
+void validate_cline_row(void);
+void validate_virtcol(void);
+void validate_virtcol_win(win_T *wp);
+void validate_cheight(void);
+void validate_cursor_col(void);
+int win_col_off(win_T *wp);
+int curwin_col_off(void);
+int win_col_off2(win_T *wp);
+int curwin_col_off2(void);
+void curs_columns(int may_scroll);
+void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp, int *ecolp);
+void f_screenpos(typval_T *argvars, typval_T *rettv);
+void f_virtcol2col(typval_T *argvars, typval_T *rettv);
+void scrolldown(long line_count, int byfold);
+void scrollup(long line_count, int byfold);
+void adjust_skipcol(void);
+void check_topfill(win_T *wp, int down);
+void scrolldown_clamp(void);
+void scrollup_clamp(void);
+void scroll_cursor_top(int min_scroll, int always);
+void set_empty_rows(win_T *wp, int used);
+void scroll_cursor_bot(int min_scroll, int set_topbot);
+void scroll_cursor_halfway(int atend, int prefer_above);
+void cursor_correct(void);
+int onepage(int dir, long count);
+void halfpage(int flag, linenr_T Prenum);
+void do_check_cursorbind(void);
+/* vim: set ft=c : */
diff --git a/src/proto/netbeans.pro b/src/proto/netbeans.pro
new file mode 100644
index 0000000..869e966
--- /dev/null
+++ b/src/proto/netbeans.pro
@@ -0,0 +1,28 @@
+/* netbeans.c */
+void netbeans_parse_messages(void);
+int isNetbeansBuffer(buf_T *bufp);
+int isNetbeansModified(buf_T *bufp);
+void netbeans_end(void);
+void ex_nbclose(exarg_T *eap);
+void ex_nbkey(exarg_T *eap);
+void ex_nbstart(exarg_T *eap);
+void netbeans_beval_cb(BalloonEval *beval, int state);
+int netbeans_active(void);
+void netbeans_open(char *params, int doabort);
+void netbeans_send_disconnect(void);
+int set_ref_in_nb_channel(int copyID);
+void netbeans_frame_moved(int new_x, int new_y);
+void netbeans_file_activated(buf_T *bufp);
+void netbeans_file_opened(buf_T *bufp);
+void netbeans_file_killed(buf_T *bufp);
+void netbeans_inserted(buf_T *bufp, linenr_T linenr, colnr_T col, char_u *txt, int newlen);
+void netbeans_removed(buf_T *bufp, linenr_T linenr, colnr_T col, long len);
+void netbeans_unmodified(buf_T *bufp);
+void netbeans_button_release(int button);
+int netbeans_keycommand(int key);
+void netbeans_save_buffer(buf_T *bufp);
+void netbeans_deleted_all_lines(buf_T *bufp);
+int netbeans_is_guarded(linenr_T top, linenr_T bot);
+void netbeans_draw_multisign_indicator(int row);
+void netbeans_gutter_click(linenr_T lnum);
+/* vim: set ft=c : */
diff --git a/src/proto/normal.pro b/src/proto/normal.pro
new file mode 100644
index 0000000..eff08df
--- /dev/null
+++ b/src/proto/normal.pro
@@ -0,0 +1,34 @@
+/* normal.c */
+int check_text_or_curbuf_locked(oparg_T *oap);
+void normal_cmd(oparg_T *oap, int toplevel);
+void check_visual_highlight(void);
+void end_visual_mode(void);
+void end_visual_mode_keep_button(void);
+void reset_VIsual_and_resel(void);
+void reset_VIsual(void);
+void restore_visual_mode(void);
+int find_ident_under_cursor(char_u **text, int find_type);
+int find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char_u **text, int *textcol, int find_type);
+void prep_redo(int regname, long num, int cmd1, int cmd2, int cmd3, int cmd4, int cmd5);
+void prep_redo_num2(int regname, long num1, int cmd1, int cmd2, long num2, int cmd3, int cmd4, int cmd5);
+void clearop(oparg_T *oap);
+void clearopbeep(oparg_T *oap);
+void may_clear_cmdline(void);
+void clear_showcmd(void);
+int add_to_showcmd(int c);
+void add_to_showcmd_c(int c);
+void push_showcmd(void);
+void pop_showcmd(void);
+void do_check_scrollbind(int check);
+void check_scrollbind(linenr_T topline_diff, long leftcol_diff);
+int find_decl(char_u *ptr, int len, int locally, int thisblock, int flags_arg);
+void nv_scroll_line(cmdarg_T *cap);
+void scroll_redraw(int up, long count);
+void handle_tabmenu(void);
+void do_nv_ident(int c1, int c2);
+int get_visual_text(cmdarg_T *cap, char_u **pp, int *lenp);
+void start_selection(void);
+void may_start_select(int c);
+int unadjust_for_sel(void);
+void set_cursor_for_append_to_line(void);
+/* vim: set ft=c : */
diff --git a/src/proto/ops.pro b/src/proto/ops.pro
new file mode 100644
index 0000000..193e894
--- /dev/null
+++ b/src/proto/ops.pro
@@ -0,0 +1,24 @@
+/* ops.c */
+int get_op_type(int char1, int char2);
+int op_is_change(int op);
+int get_op_char(int optype);
+int get_extra_op_char(int optype);
+void op_shift(oparg_T *oap, int curs_top, int amount);
+void shift_line(int left, int round, int amount, int call_changed_bytes);
+int op_delete(oparg_T *oap);
+int op_replace(oparg_T *oap, int c);
+int swapchar(int op_type, pos_T *pos);
+void op_insert(oparg_T *oap, long count1);
+int op_change(oparg_T *oap);
+void adjust_cursor_eol(void);
+char_u *skip_comment(char_u *line, int process, int include_space, int *is_comment);
+int do_join(long count, int insert_space, int save_undo, int use_formatoptions, int setmark);
+void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, int is_del);
+void op_addsub(oparg_T *oap, linenr_T Prenum1, int g_cmd);
+void clear_oparg(oparg_T *oap);
+void cursor_pos_info(dict_T *dict);
+char *did_set_operatorfunc(optset_T *args);
+void free_operatorfunc_option(void);
+int set_ref_in_opfunc(int copyID);
+void do_pending_operator(cmdarg_T *cap, int old_col, int gui_yank);
+/* vim: set ft=c : */
diff --git a/src/proto/option.pro b/src/proto/option.pro
new file mode 100644
index 0000000..a4a2b9f
--- /dev/null
+++ b/src/proto/option.pro
@@ -0,0 +1,150 @@
+/* option.c */
+void set_init_1(int clean_arg);
+void set_fencs_unicode(void);
+void set_string_default(char *name, char_u *val);
+void set_number_default(char *name, long val);
+void set_local_options_default(win_T *wp, int do_buffer);
+void free_all_options(void);
+void set_init_2(void);
+void set_init_3(void);
+void set_helplang_default(char_u *lang);
+void set_title_defaults(void);
+void ex_set(exarg_T *eap);
+int do_set(char_u *arg_start, int opt_flags);
+void did_set_option(int opt_idx, int opt_flags, int new_value, int value_checked);
+int string_to_key(char_u *arg, int multi_byte);
+void did_set_title(void);
+void set_options_bin(int oldval, int newval, int opt_flags);
+void check_options(void);
+int get_term_opt_idx(char_u **p);
+int set_term_option_alloced(char_u **p);
+int was_set_insecurely(char_u *opt, int opt_flags);
+void redraw_titles(void);
+int valid_name(char_u *val, char *allowed);
+void set_option_sctx_idx(int opt_idx, int opt_flags, sctx_T script_ctx);
+sctx_T *get_option_sctx(char *name);
+void set_term_option_sctx_idx(char *name, int opt_idx);
+char *did_set_compatible(optset_T *args);
+char *did_set_langremap(optset_T *args);
+char *did_set_langnoremap(optset_T *args);
+char *did_set_undofile(optset_T *args);
+char *did_set_readonly(optset_T *args);
+char *did_set_mousehide(optset_T *args);
+char *did_set_modifiable(optset_T *args);
+char *did_set_eof_eol_fixeol_bomb(optset_T *args);
+char *did_set_binary(optset_T *args);
+char *did_set_buflisted(optset_T *args);
+char *did_set_swapfile(optset_T *args);
+char *did_set_terse(optset_T *args);
+char *did_set_paste(optset_T *args);
+char *did_set_insertmode(optset_T *args);
+char *did_set_ignorecase(optset_T *args);
+char *did_set_hlsearch(optset_T *args);
+char *did_set_scrollbind(optset_T *args);
+char *did_set_previewwindow(optset_T *args);
+char *did_set_smoothscroll(optset_T *args);
+char *did_set_textmode(optset_T *args);
+char *did_set_textauto(optset_T *args);
+char *did_set_lisp(optset_T *args);
+char *did_set_title_icon(optset_T *args);
+char *did_set_modified(optset_T *args);
+char *did_set_shellslash(optset_T *args);
+char *did_set_wrap(optset_T *args);
+char *did_set_equalalways(optset_T *args);
+char *did_set_weirdinvert(optset_T *args);
+char *did_set_ballooneval(optset_T *args);
+char *did_set_balloonevalterm(optset_T *args);
+char *did_set_autochdir(optset_T *args);
+char *did_set_diff(optset_T *args);
+char *did_set_imdisable(optset_T *args);
+char *did_set_spell(optset_T *args);
+char *did_set_arabic(optset_T *args);
+char *did_set_number_relativenumber(optset_T *args);
+char *did_set_termguicolors(optset_T *args);
+char *did_set_winheight_helpheight(optset_T *args);
+char *did_set_winminheight(optset_T *args);
+char *did_set_winwidth(optset_T *args);
+char *did_set_winminwidth(optset_T *args);
+char *did_set_laststatus(optset_T *args);
+char *did_set_showtabline(optset_T *args);
+char *did_set_linespace(optset_T *args);
+char *did_set_foldlevel(optset_T *args);
+char *did_set_foldminlines(optset_T *args);
+char *did_set_foldnestmax(optset_T *args);
+char *did_set_foldcolumn(optset_T *args);
+char *did_set_shiftwidth_tabstop(optset_T *args);
+char *did_set_maxcombine(optset_T *args);
+char *did_set_iminsert(optset_T *args);
+char *did_set_imstyle(optset_T *args);
+char *did_set_window(optset_T *args);
+char *did_set_imsearch(optset_T *args);
+char *did_set_titlelen(optset_T *args);
+char *did_set_cmdheight(optset_T *args);
+char *did_set_updatecount(optset_T *args);
+char *did_set_conceallevel(optset_T *args);
+char *did_set_pyxversion(optset_T *args);
+char *did_set_numberwidth(optset_T *args);
+char *did_set_textwidth(optset_T *args);
+char *did_set_undolevels(optset_T *args);
+void check_redraw(long_u flags);
+int findoption(char_u *arg);
+getoption_T get_option_value(char_u *name, long *numval, char_u **stringval, int *flagsp, int scope);
+int get_option_value_strict(char_u *name, long *numval, char_u **stringval, int opt_type, void *from);
+char_u *option_iter_next(void **option, int opt_type);
+long_u get_option_flags(int opt_idx);
+void set_option_flag(int opt_idx, long_u flag);
+void clear_option_flag(int opt_idx, long_u flag);
+int is_global_option(int opt_idx);
+int is_global_local_option(int opt_idx);
+int is_window_local_option(int opt_idx);
+int is_hidden_option(int opt_idx);
+int is_crypt_key_option(int opt_idx);
+char *set_option_value(char_u *name, long number, char_u *string, int opt_flags);
+void set_option_value_give_err(char_u *name, long number, char_u *string, int opt_flags);
+char_u *get_term_code(char_u *tname);
+char_u *get_highlight_default(void);
+char_u *get_encoding_default(void);
+int is_option_allocated(char *name);
+int is_string_option(char_u *name);
+int makeset(FILE *fd, int opt_flags, int local_only);
+int makefoldset(FILE *fd);
+void clear_termoptions(void);
+void free_termoptions(void);
+void free_one_termoption(char_u *var);
+void set_term_defaults(void);
+int istermoption_idx(int opt_idx);
+void unset_global_local_option(char_u *name, void *from);
+char_u *get_option_varp_scope(int opt_idx, int scope);
+char_u *get_option_var(int opt_idx);
+char_u *get_option_fullname(int opt_idx);
+opt_did_set_cb_T get_option_did_set_cb(int opt_idx);
+char_u *get_equalprg(void);
+void win_copy_options(win_T *wp_from, win_T *wp_to);
+void after_copy_winopt(win_T *wp);
+void copy_winopt(winopt_T *from, winopt_T *to);
+void clear_winopt(winopt_T *wop);
+void buf_copy_options(buf_T *buf, int flags);
+void reset_modifiable(void);
+void set_iminsert_global(void);
+void set_imsearch_global(void);
+void set_context_in_set_cmd(expand_T *xp, char_u *arg, int opt_flags);
+int ExpandSettings(expand_T *xp, regmatch_T *regmatch, char_u *fuzzystr, int *numMatches, char_u ***matches, int can_fuzzy);
+int ExpandOldSetting(int *numMatches, char_u ***matches);
+int shortmess(int x);
+void vimrc_found(char_u *fname, char_u *envname);
+void change_compatible(int on);
+int option_was_set(char_u *name);
+int reset_option_was_set(char_u *name);
+char *did_set_breakat(optset_T *args);
+int can_bs(int what);
+long get_scrolloff_value(void);
+long get_sidescrolloff_value(void);
+unsigned int get_bkc_value(buf_T *buf);
+char_u *get_flp_value(buf_T *buf);
+unsigned int get_ve_flags(void);
+char_u *get_showbreak_value(win_T *win);
+dict_T *get_winbuf_options(int bufopt);
+int fill_culopt_flags(char_u *val, win_T *wp);
+int magic_isset(void);
+int option_set_callback_func(char_u *optval, callback_T *optcb);
+/* vim: set ft=c : */
diff --git a/src/proto/optionstr.pro b/src/proto/optionstr.pro
new file mode 100644
index 0000000..43f285a
--- /dev/null
+++ b/src/proto/optionstr.pro
@@ -0,0 +1,126 @@
+/* optionstr.c */
+void didset_string_options(void);
+void trigger_optionset_string(int opt_idx, int opt_flags, char_u *oldval, char_u *oldval_l, char_u *oldval_g, char_u *newval);
+void check_buf_options(buf_T *buf);
+void free_string_option(char_u *p);
+void clear_string_option(char_u **pp);
+void check_string_option(char_u **pp);
+void set_string_option_direct(char_u *name, int opt_idx, char_u *val, int opt_flags, int set_sid);
+void set_string_option_direct_in_win(win_T *wp, char_u *name, int opt_idx, char_u *val, int opt_flags, int set_sid);
+void set_string_option_direct_in_buf(buf_T *buf, char_u *name, int opt_idx, char_u *val, int opt_flags, int set_sid);
+char *set_string_option(int opt_idx, char_u *value, int opt_flags, char *errbuf);
+char *did_set_ambiwidth(optset_T *args);
+char *did_set_background(optset_T *args);
+char *did_set_backspace(optset_T *args);
+char *did_set_backupcopy(optset_T *args);
+char *did_set_backupext_or_patchmode(optset_T *args);
+char *did_set_belloff(optset_T *args);
+char *did_set_breakindentopt(optset_T *args);
+char *did_set_browsedir(optset_T *args);
+char *did_set_bufhidden(optset_T *args);
+char *did_set_buftype(optset_T *args);
+char *did_set_casemap(optset_T *args);
+char *did_set_chars_option(optset_T *args);
+char *did_set_cinoptions(optset_T *args);
+char *did_set_colorcolumn(optset_T *args);
+char *did_set_comments(optset_T *args);
+char *did_set_commentstring(optset_T *args);
+char *did_set_complete(optset_T *args);
+char *did_set_completeopt(optset_T *args);
+char *did_set_completepopup(optset_T *args);
+char *did_set_completeslash(optset_T *args);
+char *did_set_concealcursor(optset_T *args);
+char *did_set_cpoptions(optset_T *args);
+char *did_set_cryptkey(optset_T *args);
+char *did_set_cryptmethod(optset_T *args);
+char *did_set_cscopequickfix(optset_T *args);
+char *did_set_cursorlineopt(optset_T *args);
+char *did_set_debug(optset_T *args);
+char *did_set_diffopt(optset_T *args);
+char *did_set_display(optset_T *args);
+char *did_set_eadirection(optset_T *args);
+char *did_set_encoding(optset_T *args);
+char *did_set_eventignore(optset_T *args);
+char *did_set_fileformat(optset_T *args);
+char *did_set_fileformats(optset_T *args);
+char *did_set_filetype_or_syntax(optset_T *args);
+char *did_set_foldclose(optset_T *args);
+char *did_set_foldexpr(optset_T *args);
+char *did_set_foldignore(optset_T *args);
+char *did_set_foldmarker(optset_T *args);
+char *did_set_foldmethod(optset_T *args);
+char *did_set_foldopen(optset_T *args);
+char *did_set_formatoptions(optset_T *args);
+char *did_set_guicursor(optset_T *args);
+char *did_set_guifont(optset_T *args);
+char *did_set_guifontset(optset_T *args);
+char *did_set_guifontwide(optset_T *args);
+char *did_set_guiligatures(optset_T *args);
+char *did_set_guioptions(optset_T *args);
+char *did_set_guitablabel(optset_T *args);
+char *did_set_helpfile(optset_T *args);
+char *did_set_helplang(optset_T *args);
+char *did_set_highlight(optset_T *args);
+char *did_set_iconstring(optset_T *args);
+char *did_set_imactivatekey(optset_T *args);
+char *did_set_isopt(optset_T *args);
+char *did_set_keymap(optset_T *args);
+char *did_set_keymodel(optset_T *args);
+char *did_set_keyprotocol(optset_T *args);
+char *did_set_lispoptions(optset_T *args);
+char *did_set_matchpairs(optset_T *args);
+char *did_set_mkspellmem(optset_T *args);
+char *did_set_mouse(optset_T *args);
+char *did_set_mousemodel(optset_T *args);
+char *did_set_mouseshape(optset_T *args);
+char *did_set_nrformats(optset_T *args);
+char *did_set_optexpr(optset_T *args);
+char *did_set_pastetoggle(optset_T *args);
+char *did_set_previewpopup(optset_T *args);
+char *did_set_printencoding(optset_T *args);
+char *did_set_renderoptions(optset_T *args);
+char *did_set_rightleftcmd(optset_T *args);
+char *did_set_rulerformat(optset_T *args);
+char *did_set_scrollopt(optset_T *args);
+char *did_set_selection(optset_T *args);
+char *did_set_selectmode(optset_T *args);
+char *did_set_sessionoptions(optset_T *args);
+char *did_set_shortmess(optset_T *args);
+char *did_set_showbreak(optset_T *args);
+char *did_set_showcmdloc(optset_T *args);
+char *did_set_signcolumn(optset_T *args);
+char *did_set_spellcapcheck(optset_T *args);
+char *did_set_spellfile(optset_T *args);
+char *did_set_spelllang(optset_T *args);
+char *did_set_spelloptions(optset_T *args);
+char *did_set_spellsuggest(optset_T *args);
+char *did_set_splitkeep(optset_T *args);
+char *did_set_statusline(optset_T *args);
+char *did_set_swapsync(optset_T *args);
+char *did_set_switchbuf(optset_T *args);
+char *did_set_tabline(optset_T *args);
+char *did_set_tagcase(optset_T *args);
+char *did_set_term_option(optset_T *args);
+char *did_set_termwinkey(optset_T *args);
+char *did_set_termwinsize(optset_T *args);
+char *did_set_termwintype(optset_T *args);
+char *did_set_titlestring(optset_T *args);
+char *did_set_toolbar(optset_T *args);
+char *did_set_toolbariconsize(optset_T *args);
+char *did_set_ttymouse(optset_T *args);
+char *did_set_varsofttabstop(optset_T *args);
+char *did_set_vartabstop(optset_T *args);
+char *did_set_verbosefile(optset_T *args);
+char *did_set_viewoptions(optset_T *args);
+char *did_set_viminfo(optset_T *args);
+char *did_set_virtualedit(optset_T *args);
+char *did_set_whichwrap(optset_T *args);
+char *did_set_wildmode(optset_T *args);
+char *did_set_wildoptions(optset_T *args);
+char *did_set_winaltkeys(optset_T *args);
+char *did_set_wincolor(optset_T *args);
+char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char_u *value, char *errbuf, int opt_flags, int *value_checked);
+int check_ff_value(char_u *p);
+void save_clear_shm_value(void);
+void restore_shm_value(void);
+/* vim: set ft=c : */
diff --git a/src/proto/os_amiga.pro b/src/proto/os_amiga.pro
new file mode 100644
index 0000000..abebae1
--- /dev/null
+++ b/src/proto/os_amiga.pro
@@ -0,0 +1,46 @@
+/* os_amiga.c */
+void win_resize_on(void);
+void win_resize_off(void);
+void mch_write(char_u *p, int len);
+int mch_inchar(char_u *buf, int maxlen, long time, int tb_change_cnt);
+int mch_char_avail(void);
+long_u mch_avail_mem(int special);
+void mch_delay(long msec, int flags);
+void mch_suspend(void);
+void mch_init(void);
+int mch_check_win(int argc, char **argv);
+int mch_input_isatty(void);
+void fname_case(char_u *name, int len);
+void mch_settitle(char_u *title, char_u *icon);
+void mch_restore_title(int which);
+int mch_can_restore_title(void);
+int mch_can_restore_icon(void);
+void mch_setmouse(int on);
+int mch_get_user_name(char_u *s, int len);
+void mch_get_host_name(char_u *s, int len);
+long mch_get_pid(void);
+int mch_dirname(char_u *buf, int len);
+int mch_FullName(char_u *fname, char_u *buf, int len, int force);
+int mch_isFullName(char_u *fname);
+long mch_getperm(char_u *name);
+int mch_setperm(char_u *name, long perm);
+void mch_hide(char_u *name);
+int mch_isdir(char_u *name);
+int mch_mkdir(char_u *name);
+int mch_can_exe(char_u *name, char_u **path, int use_path);
+int mch_nodetype(char_u *name);
+void mch_early_init(void);
+void mch_exit(int r);
+void mch_settmode(tmode_T tmode);
+int mch_get_shellsize(void);
+void mch_set_shellsize(void);
+void mch_new_shellsize(void);
+int mch_call_shell(char_u *cmd, int options);
+void mch_breakcheck(int force);
+long Chk_Abort(void);
+int mch_expandpath(garray_T *gap, char_u *pat, int flags);
+int mch_has_exp_wildcard(char_u *p);
+int mch_has_wildcard(char_u *p);
+char_u *mch_getenv(char_u *var);
+int mch_setenv(char *var, char *value, int x);
+/* vim: set ft=c : */
diff --git a/src/proto/os_mac_conv.pro b/src/proto/os_mac_conv.pro
new file mode 100644
index 0000000..e86e408
--- /dev/null
+++ b/src/proto/os_mac_conv.pro
@@ -0,0 +1,12 @@
+/* os_mac_conv.c */
+char_u *mac_string_convert(char_u *ptr, int len, int *lenp, int fail_on_error, int from_enc, int to_enc, int *unconvlenp);
+int macroman2enc(char_u *ptr, long *sizep, long real_size);
+int enc2macroman(char_u *from, size_t fromlen, char_u *to, int *tolenp, int maxtolen, char_u *rest, int *restlenp);
+void mac_conv_init(void);
+void mac_conv_cleanup(void);
+char_u *mac_utf16_to_enc(unsigned short *from, size_t fromLen, size_t *actualLen);
+unsigned short *mac_enc_to_utf16(char_u *from, size_t fromLen, size_t *actualLen);
+void *mac_enc_to_cfstring(char_u *from, size_t fromLen);
+char_u *mac_precompose_path(char_u *decompPath, size_t decompLen, size_t *precompLen);
+void mac_lang_init(void);
+/* vim: set ft=c : */
diff --git a/src/proto/os_macosx.pro b/src/proto/os_macosx.pro
new file mode 100644
index 0000000..5b96b75
--- /dev/null
+++ b/src/proto/os_macosx.pro
@@ -0,0 +1,7 @@
+/* os_macosx.m */
+void process_cfrunloop();
+bool sound_mch_play(const char_u* event, long sound_id, soundcb_T *callback, bool playfile);
+void sound_mch_stop(long sound_id);
+void sound_mch_clear();
+void sound_mch_free();
+/* vim: set ft=c : */
diff --git a/src/proto/os_mswin.pro b/src/proto/os_mswin.pro
new file mode 100644
index 0000000..c63129f
--- /dev/null
+++ b/src/proto/os_mswin.pro
@@ -0,0 +1,54 @@
+/* os_mswin.c */
+void mch_exit_g(int r);
+void mch_early_init(void);
+int mch_input_isatty(void);
+void mch_settitle(char_u *title, char_u *icon);
+void mch_restore_title(int which);
+int mch_can_restore_title(void);
+int mch_can_restore_icon(void);
+int mch_FullName(char_u *fname, char_u *buf, int len, int force);
+int mch_isFullName(char_u *fname);
+void slash_adjust(char_u *p);
+char_u *resolve_appexeclink(char_u *fname);
+int vim_stat(const char *name, stat_T *stp);
+void mch_settmode(tmode_T tmode);
+int mch_get_shellsize(void);
+void mch_set_shellsize(void);
+void mch_new_shellsize(void);
+void mch_suspend(void);
+void display_errors(void);
+int mch_has_exp_wildcard(char_u *p);
+int mch_has_wildcard(char_u *p);
+int mch_chdir(char *path);
+int mch_icon_load(HANDLE *iconp);
+int mch_libcall(char_u *libname, char_u *funcname, char_u *argstring, int argint, char_u **string_result, int *number_result);
+void DumpPutS(const char *psz);
+int mch_get_winpos(int *x, int *y);
+void mch_set_winpos(int x, int y);
+void mch_print_cleanup(void);
+int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit);
+int mch_print_begin(prt_settings_T *psettings);
+void mch_print_end(prt_settings_T *psettings);
+int mch_print_end_page(void);
+int mch_print_begin_page(char_u *msg);
+int mch_print_blank_page(void);
+void mch_print_start_line(int margin, int page_line);
+int mch_print_text_out(char_u *p, int len);
+void mch_print_set_font(int iBold, int iItalic, int iUnderline);
+void mch_print_set_bg(long_u bgcol);
+void mch_print_set_fg(long_u fgcol);
+char_u *mch_resolve_path(char_u *fname, int reparse_point);
+void win32_set_foreground(void);
+void serverInitMessaging(void);
+void serverSetName(char_u *name);
+char_u *serverGetVimNames(void);
+int serverSendReply(char_u *name, char_u *reply);
+int serverSendToVim(char_u *name, char_u *cmd, char_u **result, void *ptarget, int asExpr, int timeout, int silent);
+void serverForeground(char_u *name);
+char_u *serverGetReply(HWND server, int *expr_res, int remove, int wait, int timeout);
+void serverProcessPendingMessages(void);
+char *charset_id2name(int id);
+char *quality_id2name(DWORD id);
+int get_logfont(LOGFONTW *lf, char_u *name, HDC printer_dc, int verbose);
+void channel_init_winsock(void);
+/* vim: set ft=c : */
diff --git a/src/proto/os_qnx.pro b/src/proto/os_qnx.pro
new file mode 100644
index 0000000..a3fab62
--- /dev/null
+++ b/src/proto/os_qnx.pro
@@ -0,0 +1,8 @@
+/* os_qnx.c */
+void qnx_init(void);
+void qnx_clip_init (void);
+int clip_mch_own_selection(Clipboard_T *cbd);
+void clip_mch_lose_selection(Clipboard_T *cbd);
+void clip_mch_request_selection(Clipboard_T *cbd);
+void clip_mch_set_selection(Clipboard_T *cbd);
+/* vim: set ft=c : */
diff --git a/src/proto/os_unix.pro b/src/proto/os_unix.pro
new file mode 100644
index 0000000..9266364
--- /dev/null
+++ b/src/proto/os_unix.pro
@@ -0,0 +1,91 @@
+/* os_unix.c */
+int mch_chdir(char *path);
+void mch_write(char_u *s, int len);
+int mch_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
+int mch_char_avail(void);
+int mch_check_messages(void);
+long_u mch_total_mem(int special);
+void mch_delay(long msec, int flags);
+int mch_stackcheck(char *p);
+void mch_suspend(void);
+void mch_init(void);
+void reset_signals(void);
+int vim_handle_signal(int sig);
+int mch_check_win(int argc, char **argv);
+int mch_input_isatty(void);
+void ex_xrestore(exarg_T *eap);
+int mch_can_restore_title(void);
+int mch_can_restore_icon(void);
+void mch_settitle(char_u *title, char_u *icon);
+void mch_restore_title(int which);
+int vim_is_xterm(char_u *name);
+int use_xterm_like_mouse(char_u *name);
+int use_xterm_mouse(void);
+int vim_is_iris(char_u *name);
+int vim_is_vt300(char_u *name);
+int mch_get_user_name(char_u *s, int len);
+int mch_get_uname(uid_t uid, char_u *s, int len);
+void mch_get_host_name(char_u *s, int len);
+long mch_get_pid(void);
+int mch_process_running(long pid);
+int mch_dirname(char_u *buf, int len);
+int mch_FullName(char_u *fname, char_u *buf, int len, int force);
+int mch_isFullName(char_u *fname);
+void fname_case(char_u *name, int len);
+long mch_getperm(char_u *name);
+int mch_setperm(char_u *name, long perm);
+int mch_fsetperm(int fd, long perm);
+void mch_copy_sec(char_u *from_file, char_u *to_file);
+vim_acl_T mch_get_acl(char_u *fname);
+void mch_set_acl(char_u *fname, vim_acl_T aclent);
+void mch_free_acl(vim_acl_T aclent);
+void mch_hide(char_u *name);
+int mch_isdir(char_u *name);
+int mch_isrealdir(char_u *name);
+int mch_can_exe(char_u *name, char_u **path, int use_path);
+int mch_nodetype(char_u *name);
+void mch_early_init(void);
+void mch_free_mem(void);
+void mch_exit(int r);
+void mch_settmode(tmode_T tmode);
+void get_stty(void);
+int get_tty_info(int fd, ttyinfo_T *info);
+void mch_setmouse(int on);
+void mch_bevalterm_changed(void);
+void check_mouse_termcode(void);
+int mch_get_shellsize(void);
+int mch_report_winsize(int fd, int rows, int cols);
+void mch_set_shellsize(void);
+void mch_new_shellsize(void);
+int unix_build_argv(char_u *cmd, char ***argvp, char_u **sh_tofree, char_u **shcf_tofree);
+int mch_call_shell(char_u *cmd, int options);
+void mch_job_start(char **argv, job_T *job, jobopt_T *options, int is_terminal);
+char *mch_job_status(job_T *job);
+job_T *mch_detect_ended_job(job_T *job_list);
+int mch_signal_job(job_T *job, char_u *how);
+void mch_clear_job(job_T *job);
+int mch_create_pty_channel(job_T *job, jobopt_T *options);
+void mch_breakcheck(int force);
+int mch_expandpath(garray_T *gap, char_u *path, int flags);
+int mch_expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u ***file, int flags);
+int mch_has_exp_wildcard(char_u *p);
+int mch_has_wildcard(char_u *p);
+int mch_rename(const char *src, const char *dest);
+int gpm_available(void);
+int gpm_enabled(void);
+int mch_libcall(char_u *libname, char_u *funcname, char_u *argstring, int argint, char_u **string_result, int *number_result);
+void setup_term_clip(void);
+void start_xterm_trace(int button);
+void stop_xterm_trace(void);
+void clear_xterm_clip(void);
+int clip_xterm_own_selection(Clipboard_T *cbd);
+void clip_xterm_lose_selection(Clipboard_T *cbd);
+void clip_xterm_request_selection(Clipboard_T *cbd);
+void clip_xterm_set_selection(Clipboard_T *cbd);
+int xsmp_handle_requests(void);
+void xsmp_init(void);
+void xsmp_close(void);
+void stop_timeout(void);
+volatile sig_atomic_t *start_timeout(long msec);
+void delete_timer(void);
+/* vim: set ft=c : */
diff --git a/src/proto/os_vms.pro b/src/proto/os_vms.pro
new file mode 100644
index 0000000..b58118d
--- /dev/null
+++ b/src/proto/os_vms.pro
@@ -0,0 +1,16 @@
+/* os_vms.c */
+void mch_settmode(tmode_T tmode);
+int mch_get_shellsize(void);
+void mch_set_shellsize(void);
+char_u *mch_getenv(char_u *lognam);
+int mch_setenv(char *var, char *value, int x);
+int vms_sys(char *cmd, char *out, char *inp);
+char *vms_tolower(char *name);
+int vms_sys_status(int status);
+int vms_read(char *inbuf, size_t nbytes);
+int mch_expand_wildcards(int num_pat, char_u **pat, int *num_file, char_u ***file, int flags);
+int mch_expandpath(garray_T *gap, char_u *path, int flags);
+void *vms_fixfilename(void *instring);
+void vms_remove_version(void *fname);
+int RealWaitForChar(int fd, long msec, int *check_for_gpm, int *interrupted);
+/* vim: set ft=c : */
diff --git a/src/proto/os_win32.pro b/src/proto/os_win32.pro
new file mode 100644
index 0000000..7ea5388
--- /dev/null
+++ b/src/proto/os_win32.pro
@@ -0,0 +1,90 @@
+/* os_win32.c */
+void mch_get_exe_name(void);
+HINSTANCE vimLoadLib(const char *name);
+int mch_is_gui_executable(void);
+HINSTANCE find_imported_module_by_funcname(HINSTANCE hInst, const char *funcname);
+void *get_dll_import_func(HINSTANCE hInst, const char *funcname);
+void *hook_dll_import_func(HINSTANCE hInst, const char *funcname, const void *hook);
+int dyn_libintl_init(void);
+void dyn_libintl_end(void);
+void PlatformId(void);
+void mch_setmouse(int on);
+void mch_bevalterm_changed(void);
+int test_mswin_event(char_u *event, dict_T *args);
+void mch_update_cursor(void);
+int mch_char_avail(void);
+int mch_check_messages(void);
+int mch_inchar(char_u *buf, int maxlen, long time, int tb_change_cnt);
+void mch_init(void);
+void mch_exit(int r);
+int mch_check_win(int argc, char **argv);
+void fname_case(char_u *name, int len);
+int mch_get_user_name(char_u *s, int len);
+void mch_get_host_name(char_u *s, int len);
+long mch_get_pid(void);
+int mch_process_running(long pid);
+int mch_dirname(char_u *buf, int len);
+long mch_getperm(char_u *name);
+int mch_setperm(char_u *name, long perm);
+void mch_hide(char_u *name);
+int mch_ishidden(char_u *name);
+int mch_isdir(char_u *name);
+int mch_isrealdir(char_u *name);
+int mch_mkdir(char_u *name);
+int mch_rmdir(char_u *name);
+int mch_is_hard_link(char_u *fname);
+int mch_is_symbolic_link(char_u *name);
+int mch_is_linked(char_u *fname);
+int win32_fileinfo(char_u *fname, BY_HANDLE_FILE_INFORMATION *info);
+int mch_writable(char_u *name);
+int mch_can_exe(char_u *name, char_u **path, int use_path);
+int mch_nodetype(char_u *name);
+vim_acl_T mch_get_acl(char_u *fname);
+void mch_set_acl(char_u *fname, vim_acl_T acl);
+void mch_free_acl(vim_acl_T acl);
+void mch_settmode(tmode_T tmode);
+int mch_get_shellsize(void);
+void mch_set_shellsize(void);
+void mch_new_shellsize(void);
+void mch_set_winsize_now(void);
+int mch_call_shell(char_u *cmd, int options);
+void win32_build_env(dict_T *env, garray_T *gap, int is_terminal);
+void mch_job_start(char *cmd, job_T *job, jobopt_T *options);
+char *mch_job_status(job_T *job);
+job_T *mch_detect_ended_job(job_T *job_list);
+int mch_signal_job(job_T *job, char_u *how);
+void mch_clear_job(job_T *job);
+void mch_set_normal_colors(void);
+void mch_write(char_u *s, int len);
+void mch_delay(long msec, int flags);
+int mch_remove(char_u *name);
+void mch_breakcheck(int force);
+long_u mch_total_mem(int special);
+int mch_wrename(WCHAR *wold, WCHAR *wnew);
+int mch_rename(const char *pszOldFile, const char *pszNewFile);
+char *default_shell(void);
+int mch_access(char *n, int p);
+int mch_open(const char *name, int flags, int mode);
+FILE *mch_fopen(const char *name, const char *mode);
+int mch_copy_file_attribute(char_u *from, char_u *to);
+int get_cmd_argsW(char ***argvp);
+void free_cmd_argsW(void);
+void used_file_arg(char *name, int literal, int full_path, int diff_mode);
+void set_alist_count(void);
+void fix_arg_enc(void);
+int mch_setenv(char *var, char *value, int x);
+int vtp_printf(char *format, ...);
+void get_default_console_color(int *cterm_fg, int *cterm_bg, guicolor_T *gui_fg, guicolor_T *gui_bg);
+void control_console_color_rgb(void);
+int use_vtp(void);
+int is_term_win32(void);
+int has_vtp_working(void);
+int has_conpty_working(void);
+int get_conpty_type(void);
+int is_conpty_stable(void);
+int get_conpty_fix_type(void);
+void resize_console_buf(void);
+char *GetWin32Error(void);
+void stop_timeout(void);
+volatile sig_atomic_t *start_timeout(long msec);
+/* vim: set ft=c : */
diff --git a/src/proto/popupmenu.pro b/src/proto/popupmenu.pro
new file mode 100644
index 0000000..53ef843
--- /dev/null
+++ b/src/proto/popupmenu.pro
@@ -0,0 +1,20 @@
+/* popupmenu.c */
+void pum_display(pumitem_T *array, int size, int selected);
+void pum_call_update_screen(void);
+int pum_under_menu(int row, int col, int only_redrawing);
+void pum_redraw(void);
+void pum_position_info_popup(win_T *wp);
+void pum_undisplay(void);
+void pum_clear(void);
+int pum_visible(void);
+int pum_redraw_in_same_position(void);
+void pum_may_redraw(void);
+int pum_get_height(void);
+void pum_set_event_info(dict_T *dict);
+int split_message(char_u *mesg, pumitem_T **array);
+void ui_remove_balloon(void);
+void ui_post_balloon(char_u *mesg, list_T *list);
+void ui_may_remove_balloon(void);
+void pum_show_popupmenu(vimmenu_T *menu);
+void pum_make_popup(char_u *path_name, int use_mouse_pos);
+/* vim: set ft=c : */
diff --git a/src/proto/popupwin.pro b/src/proto/popupwin.pro
new file mode 100644
index 0000000..1ff9950
--- /dev/null
+++ b/src/proto/popupwin.pro
@@ -0,0 +1,76 @@
+/* popupwin.c */
+int popup_on_border(win_T *wp, int row, int col);
+int popup_close_if_on_X(win_T *wp, int row, int col);
+void popup_start_drag(win_T *wp, int row, int col);
+void popup_drag(win_T *wp);
+void popup_set_firstline(win_T *wp);
+int popup_is_in_scrollbar(win_T *wp, int row, int col);
+void popup_handle_scrollbar_click(win_T *wp, int row, int col);
+int popup_top_extra(win_T *wp);
+int popup_left_extra(win_T *wp);
+int popup_height(win_T *wp);
+int popup_width(win_T *wp);
+int popup_extra_width(win_T *wp);
+int parse_previewpopup(win_T *wp);
+int parse_completepopup(win_T *wp);
+void popup_set_wantpos_cursor(win_T *wp, int width, dict_T *d);
+void popup_set_wantpos_rowcol(win_T *wp, int row, int col);
+void popup_redraw_all(void);
+void f_popup_clear(typval_T *argvars, typval_T *rettv);
+void f_popup_create(typval_T *argvars, typval_T *rettv);
+void f_popup_atcursor(typval_T *argvars, typval_T *rettv);
+void f_popup_beval(typval_T *argvars, typval_T *rettv);
+void popup_close_with_retval(win_T *wp, int retval);
+void popup_close_for_mouse_click(win_T *wp);
+void popup_handle_mouse_moved(void);
+void f_popup_filter_menu(typval_T *argvars, typval_T *rettv);
+void f_popup_filter_yesno(typval_T *argvars, typval_T *rettv);
+void f_popup_dialog(typval_T *argvars, typval_T *rettv);
+void f_popup_menu(typval_T *argvars, typval_T *rettv);
+void f_popup_notification(typval_T *argvars, typval_T *rettv);
+void f_popup_close(typval_T *argvars, typval_T *rettv);
+void popup_hide(win_T *wp);
+void f_popup_hide(typval_T *argvars, typval_T *rettv);
+void popup_show(win_T *wp);
+void f_popup_show(typval_T *argvars, typval_T *rettv);
+void f_popup_settext(typval_T *argvars, typval_T *rettv);
+int error_if_popup_window(int also_with_term);
+int popup_close(int id, int force);
+int popup_close_tabpage(tabpage_T *tp, int id, int force);
+void close_all_popups(int force);
+void f_popup_move(typval_T *argvars, typval_T *rettv);
+void f_popup_setoptions(typval_T *argvars, typval_T *rettv);
+void f_popup_getpos(typval_T *argvars, typval_T *rettv);
+void f_popup_list(typval_T *argvars, typval_T *rettv);
+void f_popup_locate(typval_T *argvars, typval_T *rettv);
+void f_popup_getoptions(typval_T *argvars, typval_T *rettv);
+int error_if_term_popup_window(void);
+void popup_reset_handled(int handled_flag);
+win_T *find_next_popup(int lowest, int handled_flag);
+int popup_do_filter(int c);
+int popup_no_mapping(void);
+void popup_check_cursor_pos(void);
+void may_update_popup_mask(int type);
+void may_update_popup_position(void);
+void update_popups(void (*win_update)(win_T *wp));
+int set_ref_in_popups(int copyID);
+int popup_is_popup(win_T *wp);
+win_T *popup_find_preview_window(void);
+win_T *popup_find_info_window(void);
+void f_popup_findecho(typval_T *argvars, typval_T *rettv);
+void f_popup_findinfo(typval_T *argvars, typval_T *rettv);
+void f_popup_findpreview(typval_T *argvars, typval_T *rettv);
+int popup_create_preview_window(int info);
+void popup_close_preview(void);
+void popup_hide_info(void);
+void popup_close_info(void);
+win_T *popup_get_message_win(void);
+void popup_show_message_win(void);
+int popup_message_win_visible(void);
+void popup_hide_message_win(void);
+void start_echowindow(int time_sec);
+void end_echowindow(void);
+int popup_win_closed(win_T *win);
+void popup_set_title(win_T *wp);
+void popup_update_preview_title(void);
+/* vim: set ft=c : */
diff --git a/src/proto/profiler.pro b/src/proto/profiler.pro
new file mode 100644
index 0000000..a7d065e
--- /dev/null
+++ b/src/proto/profiler.pro
@@ -0,0 +1,35 @@
+/* profiler.c */
+void profile_start(proftime_T *tm);
+void profile_end(proftime_T *tm);
+void profile_sub(proftime_T *tm, proftime_T *tm2);
+char *profile_msg(proftime_T *tm);
+float_T profile_float(proftime_T *tm);
+void profile_setlimit(long msec, proftime_T *tm);
+int profile_passed_limit(proftime_T *tm);
+void profile_zero(proftime_T *tm);
+void profile_divide(proftime_T *tm, int count, proftime_T *tm2);
+void profile_add(proftime_T *tm, proftime_T *tm2);
+void profile_self(proftime_T *self, proftime_T *total, proftime_T *children);
+void profile_sub_wait(proftime_T *tm, proftime_T *tma);
+int profile_cmp(const proftime_T *tm1, const proftime_T *tm2);
+void ex_profile(exarg_T *eap);
+char_u *get_profile_name(expand_T *xp, int idx);
+void set_context_in_profile_cmd(expand_T *xp, char_u *arg);
+void prof_inchar_enter(void);
+void prof_inchar_exit(void);
+int prof_def_func(void);
+void func_do_profile(ufunc_T *fp);
+void profile_may_start_func(profinfo_T *info, ufunc_T *fp, ufunc_T *caller);
+void profile_may_end_func(profinfo_T *info, ufunc_T *fp, ufunc_T *caller);
+void prof_child_enter(proftime_T *tm);
+void prof_child_exit(proftime_T *tm);
+void func_line_start(void *cookie, long lnum);
+void func_line_exec(void *cookie);
+void func_line_end(void *cookie);
+void script_do_profile(scriptitem_T *si);
+void script_prof_restore(proftime_T *tm);
+void profile_dump(void);
+void script_line_start(void);
+void script_line_exec(void);
+void script_line_end(void);
+/* vim: set ft=c : */
diff --git a/src/proto/pty.pro b/src/proto/pty.pro
new file mode 100644
index 0000000..52e20ef
--- /dev/null
+++ b/src/proto/pty.pro
@@ -0,0 +1,5 @@
+/* pty.c */
+int setup_slavepty(int fd);
+int mch_openpty(char **ttyn);
+int mch_isatty(int fd);
+/* vim: set ft=c : */
diff --git a/src/proto/quickfix.pro b/src/proto/quickfix.pro
new file mode 100644
index 0000000..b708d6b
--- /dev/null
+++ b/src/proto/quickfix.pro
@@ -0,0 +1,43 @@
+/* quickfix.c */
+int qf_init(win_T *wp, char_u *efile, char_u *errorformat, int newlist, char_u *qf_title, char_u *enc);
+int qf_stack_get_bufnr(void);
+void qf_free_all(win_T *wp);
+void check_quickfix_busy(void);
+void copy_loclist_stack(win_T *from, win_T *to);
+void qf_jump(qf_info_T *qi, int dir, int errornr, int forceit);
+void qf_list(exarg_T *eap);
+void qf_age(exarg_T *eap);
+void qf_history(exarg_T *eap);
+void qf_mark_adjust(win_T *wp, linenr_T line1, linenr_T line2, long amount, long amount_after);
+void qf_view_result(int split);
+void ex_cwindow(exarg_T *eap);
+void ex_cclose(exarg_T *eap);
+void ex_copen(exarg_T *eap);
+void ex_cbottom(exarg_T *eap);
+linenr_T qf_current_entry(win_T *wp);
+char *did_set_quickfixtextfunc(optset_T *args);
+int grep_internal(cmdidx_T cmdidx);
+void ex_make(exarg_T *eap);
+int qf_get_size(exarg_T *eap);
+int qf_get_valid_size(exarg_T *eap);
+int qf_get_cur_idx(exarg_T *eap);
+int qf_get_cur_valid_idx(exarg_T *eap);
+void ex_cc(exarg_T *eap);
+void ex_cnext(exarg_T *eap);
+void ex_cbelow(exarg_T *eap);
+void ex_cfile(exarg_T *eap);
+void ex_vimgrep(exarg_T *eap);
+int set_errorlist(win_T *wp, list_T *list, int action, char_u *title, dict_T *what);
+int set_ref_in_quickfix(int copyID);
+void ex_cbuffer(exarg_T *eap);
+char_u *cexpr_get_auname(cmdidx_T cmdidx);
+int trigger_cexpr_autocmd(int cmdidx);
+int cexpr_core(exarg_T *eap, typval_T *tv);
+void ex_cexpr(exarg_T *eap);
+void ex_helpgrep(exarg_T *eap);
+void free_quickfix(void);
+void f_getloclist(typval_T *argvars, typval_T *rettv);
+void f_getqflist(typval_T *argvars, typval_T *rettv);
+void f_setloclist(typval_T *argvars, typval_T *rettv);
+void f_setqflist(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/regexp.pro b/src/proto/regexp.pro
new file mode 100644
index 0000000..ffd5a07
--- /dev/null
+++ b/src/proto/regexp.pro
@@ -0,0 +1,27 @@
+/* regexp.c */
+void init_regexp_timeout(long msec);
+void disable_regexp_timeout(void);
+void save_timeout_for_debugging(void);
+void restore_timeout_for_debugging(void);
+int re_multiline(regprog_T *prog);
+char_u *skip_regexp(char_u *startp, int delim, int magic);
+char_u *skip_regexp_err(char_u *startp, int delim, int magic);
+char_u *skip_regexp_ex(char_u *startp, int dirc, int magic, char_u **newp, int *dropped, magic_T *magic_val);
+reg_extmatch_T *ref_extmatch(reg_extmatch_T *em);
+void unref_extmatch(reg_extmatch_T *em);
+char_u *regtilde(char_u *source, int magic);
+int vim_regsub(regmatch_T *rmp, char_u *source, typval_T *expr, char_u *dest, int destlen, int flags);
+int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int destlen, int flags);
+void free_resub_eval_result(void);
+char_u *reg_submatch(int no);
+list_T *reg_submatch_list(int no);
+int vim_regcomp_had_eol(void);
+regprog_T *vim_regcomp(char_u *expr_arg, int re_flags);
+void vim_regfree(regprog_T *prog);
+void free_regexp_stuff(void);
+int regprog_in_use(regprog_T *prog);
+int vim_regexec_prog(regprog_T **prog, int ignore_case, char_u *line, colnr_T col);
+int vim_regexec(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(regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum, colnr_T col, int *timed_out);
+/* vim: set ft=c : */
diff --git a/src/proto/register.pro b/src/proto/register.pro
new file mode 100644
index 0000000..d9f1669
--- /dev/null
+++ b/src/proto/register.pro
@@ -0,0 +1,42 @@
+/* register.c */
+yankreg_T *get_y_regs(void);
+yankreg_T *get_y_register(int reg);
+yankreg_T *get_y_current(void);
+yankreg_T *get_y_previous(void);
+void set_y_current(yankreg_T *yreg);
+void set_y_previous(yankreg_T *yreg);
+void reset_y_append(void);
+int get_expr_register(void);
+void set_expr_line(char_u *new_line, exarg_T *eap);
+char_u *get_expr_line(void);
+int valid_yank_reg(int regname, int writing);
+int get_yank_register(int regname, int writing);
+void *get_register(int name, int copy);
+void put_register(int name, void *reg);
+void free_register(void *reg);
+int yank_register_mline(int regname);
+int do_record(int c);
+int get_execreg_lastc(void);
+void set_execreg_lastc(int lastc);
+int do_execreg(int regname, int colon, int addcr, int silent);
+int insert_reg(int regname, int literally_arg);
+int get_spec_reg(int regname, char_u **argp, int *allocated, int errmsg);
+int cmdline_paste_reg(int regname, int literally_arg, int remcr);
+void shift_delete_registers(void);
+void yank_do_autocmd(oparg_T *oap, yankreg_T *reg);
+void init_yank(void);
+void clear_registers(void);
+void free_yank_all(void);
+int op_yank(oparg_T *oap, int deleting, int mess);
+void do_put(int regname, char_u *expr_result, int dir, long count, int flags);
+int get_register_name(int num);
+int get_unname_register(void);
+void ex_display(exarg_T *eap);
+void dnd_yank_drag_data(char_u *str, long len);
+char_u get_reg_type(int regname, long *reglen);
+char_u *get_reg_contents(int regname, int flags);
+void write_reg_contents(int name, char_u *str, int maxlen, int must_append);
+void write_reg_contents_lst(int name, char_u **strings, int maxlen, int must_append, int yank_type, long block_len);
+void write_reg_contents_ex(int name, char_u *str, int maxlen, int must_append, int yank_type, long block_len);
+void str_to_reg(yankreg_T *y_ptr, int yank_type, char_u *str, long len, long blocklen, int str_list);
+/* vim: set ft=c : */
diff --git a/src/proto/screen.pro b/src/proto/screen.pro
new file mode 100644
index 0000000..84b404d
--- /dev/null
+++ b/src/proto/screen.pro
@@ -0,0 +1,61 @@
+/* screen.c */
+int conceal_cursor_line(win_T *wp);
+void conceal_check_cursor_line(int was_concealed);
+int get_wcr_attr(win_T *wp);
+void win_draw_end(win_T *wp, int c1, int c2, int draw_margin, int row, int endrow, hlf_T hl);
+int compute_foldcolumn(win_T *wp, int col);
+size_t fill_foldcolumn(char_u *p, win_T *wp, int closed, linenr_T lnum);
+int screen_get_current_line_off(void);
+void reset_screen_attr(void);
+void screen_line(win_T *wp, int row, int coloff, int endcol, int clear_width, int flags);
+void rl_mirror(char_u *str);
+void draw_vsep_win(win_T *wp, int row);
+int stl_connected(win_T *wp);
+int get_keymap_str(win_T *wp, char_u *fmt, char_u *buf, int len);
+void win_redr_custom(win_T *wp, int draw_ruler);
+void screen_putchar(int c, int row, int col, int attr);
+void screen_getbytes(int row, int col, char_u *bytes, int *attrp);
+void screen_puts(char_u *text, int row, int col, int attr);
+void screen_puts_len(char_u *text, int textlen, int row, int col, int attr_arg);
+void start_search_hl(void);
+void end_search_hl(void);
+void screen_stop_highlight(void);
+void reset_cterm_colors(void);
+void screen_char(unsigned off, int row, int col);
+void screen_draw_rectangle(int row, int col, int height, int width, int invert);
+void space_to_screenline(int off, int attr);
+void screen_fill(int start_row, int end_row, int start_col, int end_col, int c1, int c2, int attr);
+void check_for_delay(int check_msg_scroll);
+int screen_valid(int doclear);
+void screenalloc(int doclear);
+void free_screenlines(void);
+int screenclear(void);
+void redraw_as_cleared(void);
+void line_was_clobbered(int screen_lnum);
+int can_clear(char_u *p);
+void screen_start(void);
+void windgoto(int row, int col);
+void setcursor(void);
+void setcursor_mayforce(int force);
+int win_ins_lines(win_T *wp, int row, int line_count, int invalid, int mayclear);
+int win_del_lines(win_T *wp, int row, int line_count, int invalid, int mayclear, int clear_attr);
+int screen_ins_lines(int off, int row, int line_count, int end, int clear_attr, win_T *wp);
+int screen_del_lines(int off, int row, int line_count, int end, int force, int clear_attr, win_T *wp);
+int skip_showmode(void);
+int showmode(void);
+void unshowmode(int force);
+void clearmode(void);
+void draw_tabline(void);
+void get_trans_bufname(buf_T *buf);
+int fillchar_status(int *attr, win_T *wp);
+int fillchar_vsep(int *attr, win_T *wp);
+int redrawing(void);
+int messaging(void);
+void comp_col(void);
+int number_width(win_T *wp);
+int screen_screencol(void);
+int screen_screenrow(void);
+char *set_fillchars_option(win_T *wp, char_u *val, int apply);
+char *set_listchars_option(win_T *wp, char_u *val, int apply);
+char *check_chars_options(void);
+/* vim: set ft=c : */
diff --git a/src/proto/scriptfile.pro b/src/proto/scriptfile.pro
new file mode 100644
index 0000000..24e5389
--- /dev/null
+++ b/src/proto/scriptfile.pro
@@ -0,0 +1,50 @@
+/* scriptfile.c */
+void estack_init(void);
+estack_T *estack_push(etype_T type, char_u *name, long lnum);
+estack_T *estack_push_ufunc(ufunc_T *ufunc, long lnum);
+int estack_top_is_ufunc(ufunc_T *ufunc, long lnum);
+estack_T *estack_pop(void);
+char_u *estack_sfile(estack_arg_T which);
+void ex_runtime(exarg_T *eap);
+void set_context_in_runtime_cmd(expand_T *xp, char_u *arg);
+int find_script_by_name(char_u *name);
+int get_new_scriptitem_for_fname(int *error, char_u *fname);
+int do_in_path(char_u *path, char_u *name, int flags, void (*callback)(char_u *fname, void *ck), void *cookie);
+int do_in_runtimepath(char_u *name, int flags, void (*callback)(char_u *fname, void *ck), void *cookie);
+int source_runtime(char_u *name, int flags);
+int source_in_path(char_u *path, char_u *name, int flags, int *ret_sid);
+int find_script_in_rtp(char_u *name);
+void add_pack_start_dirs(void);
+void load_start_packages(void);
+void ex_packloadall(exarg_T *eap);
+void ex_packadd(exarg_T *eap);
+void remove_duplicates(garray_T *gap);
+int ExpandRTDir(char_u *pat, int flags, int *num_file, char_u ***file, char *dirnames[]);
+int expand_runtime_cmd(char_u *pat, int *numMatches, char_u ***matches);
+int ExpandPackAddDir(char_u *pat, int *num_file, char_u ***file);
+void ex_source(exarg_T *eap);
+void ex_options(exarg_T *eap);
+linenr_T *source_breakpoint(void *cookie);
+int *source_dbg_tick(void *cookie);
+int source_level(void *cookie);
+char_u *source_nextline(void *cookie);
+int do_source(char_u *fname, int check_other, int is_vimrc, int *ret_sid);
+void ex_scriptnames(exarg_T *eap);
+void scriptnames_slash_adjust(void);
+char_u *get_scriptname(scid_T id);
+void free_scriptnames(void);
+void free_autoload_scriptnames(void);
+linenr_T get_sourced_lnum(char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
+void f_getscriptinfo(typval_T *argvars, typval_T *rettv);
+char_u *getsourceline(int c, void *cookie, int indent, getline_opt_T options);
+int sourcing_a_script(exarg_T *eap);
+void ex_scriptencoding(exarg_T *eap);
+void ex_scriptversion(exarg_T *eap);
+void ex_finish(exarg_T *eap);
+void do_finish(exarg_T *eap, int reanimate);
+int source_finished(char_u *(*fgetline)(int, void *, int, getline_opt_T), void *cookie);
+char_u *get_autoload_prefix(scriptitem_T *si);
+char_u *may_prefix_autoload(char_u *name);
+char_u *autoload_name(char_u *name);
+int script_autoload(char_u *name, int reload);
+/* vim: set ft=c : */
diff --git a/src/proto/search.pro b/src/proto/search.pro
new file mode 100644
index 0000000..7a29ff3
--- /dev/null
+++ b/src/proto/search.pro
@@ -0,0 +1,46 @@
+/* search.c */
+int search_regcomp(char_u *pat, char_u **used_pat, int pat_save, int pat_use, int options, regmmatch_T *regmatch);
+char_u *get_search_pat(void);
+char_u *reverse_text(char_u *s);
+void save_re_pat(int idx, char_u *pat, int magic);
+void save_search_patterns(void);
+void restore_search_patterns(void);
+void free_search_patterns(void);
+void save_last_search_pattern(void);
+void restore_last_search_pattern(void);
+char_u *last_search_pattern(void);
+int ignorecase(char_u *pat);
+int ignorecase_opt(char_u *pat, int ic_in, int scs);
+int pat_has_uppercase(char_u *pat);
+char_u *last_csearch(void);
+int last_csearch_forward(void);
+int last_csearch_until(void);
+void set_last_csearch(int c, char_u *s, int len);
+void set_csearch_direction(int cdir);
+void set_csearch_until(int t_cmd);
+char_u *last_search_pat(void);
+void reset_search_dir(void);
+void set_last_search_pat(char_u *s, int idx, int magic, int setlast);
+void last_pat_prog(regmmatch_T *regmatch);
+int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, int dir, char_u *pat, long count, int options, int pat_use, searchit_arg_T *extra_arg);
+void set_search_direction(int cdir);
+int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count, int options, searchit_arg_T *sia);
+int search_for_exact_line(buf_T *buf, pos_T *pos, int dir, char_u *pat);
+int searchc(cmdarg_T *cap, int t_cmd);
+pos_T *findmatch(oparg_T *oap, int initc);
+pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int maxtravel);
+int check_linecomment(char_u *line);
+void showmatch(int c);
+int current_search(long count, int forward);
+int linewhite(linenr_T lnum);
+void find_pattern_in_path(char_u *ptr, int dir, int len, int whole, int skip_comments, int type, long count, int action, linenr_T start_lnum, linenr_T end_lnum);
+spat_T *get_spat(int idx);
+int get_spat_last_idx(void);
+void f_searchcount(typval_T *argvars, typval_T *rettv);
+int fuzzy_match(char_u *str, char_u *pat_arg, int matchseq, int *outScore, int_u *matches, int maxMatches);
+void f_matchfuzzy(typval_T *argvars, typval_T *rettv);
+void f_matchfuzzypos(typval_T *argvars, typval_T *rettv);
+int fuzzy_match_str(char_u *str, char_u *pat);
+void fuzmatch_str_free(fuzmatch_str_T *fuzmatch, int count);
+int fuzzymatches_to_strmatches(fuzmatch_str_T *fuzmatch, char_u ***matches, int count, int funcsort);
+/* vim: set ft=c : */
diff --git a/src/proto/session.pro b/src/proto/session.pro
new file mode 100644
index 0000000..3c5ee2c
--- /dev/null
+++ b/src/proto/session.pro
@@ -0,0 +1,8 @@
+/* session.c */
+void ex_loadview(exarg_T *eap);
+int write_session_file(char_u *filename);
+void ex_mkrc(exarg_T *eap);
+var_flavour_T var_flavour(char_u *varname);
+int put_eol(FILE *fd);
+int put_line(FILE *fd, char *s);
+/* vim: set ft=c : */
diff --git a/src/proto/sha256.pro b/src/proto/sha256.pro
new file mode 100644
index 0000000..157fa73
--- /dev/null
+++ b/src/proto/sha256.pro
@@ -0,0 +1,9 @@
+/* sha256.c */
+void sha256_start(context_sha256_T *ctx);
+void sha256_update(context_sha256_T *ctx, char_u *input, UINT32_T length);
+void sha256_finish(context_sha256_T *ctx, char_u digest[32]);
+char_u *sha256_bytes(char_u *buf, int buf_len, char_u *salt, int salt_len);
+char_u *sha256_key(char_u *buf, char_u *salt, int salt_len);
+int sha256_self_test(void);
+void sha2_seed(char_u *header, int header_len, char_u *salt, int salt_len);
+/* vim: set ft=c : */
diff --git a/src/proto/sign.pro b/src/proto/sign.pro
new file mode 100644
index 0000000..a042bad
--- /dev/null
+++ b/src/proto/sign.pro
@@ -0,0 +1,33 @@
+/* sign.c */
+void init_signs(void);
+int buf_get_signattrs(win_T *wp, linenr_T lnum, sign_attrs_T *sattr);
+linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char_u *group);
+int buf_findsign(buf_T *buf, int id, char_u *group);
+int buf_findsign_id(buf_T *buf, linenr_T lnum, char_u *groupname);
+int buf_findsigntype_id(buf_T *buf, linenr_T lnum, int typenr);
+int buf_signcount(buf_T *buf, linenr_T lnum);
+void buf_delete_signs(buf_T *buf, char_u *group);
+void sign_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
+int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_u *text, char_u *texthl, char_u *culhl, char_u *numhl);
+int sign_exists_by_name(char_u *name);
+int sign_undefine_by_name(char_u *name, int give_error);
+int sign_place(int *sign_id, char_u *sign_group, char_u *sign_name, buf_T *buf, linenr_T lnum, int prio);
+void ex_sign(exarg_T *eap);
+void get_buffer_signs(buf_T *buf, list_T *l);
+void sign_gui_started(void);
+void *sign_get_image(int typenr);
+void free_signs(void);
+char_u *get_sign_name(expand_T *xp, int idx);
+void set_context_in_sign_cmd(expand_T *xp, char_u *arg);
+void f_sign_define(typval_T *argvars, typval_T *rettv);
+void f_sign_getdefined(typval_T *argvars, typval_T *rettv);
+void f_sign_getplaced(typval_T *argvars, typval_T *rettv);
+void f_sign_jump(typval_T *argvars, typval_T *rettv);
+void f_sign_place(typval_T *argvars, typval_T *rettv);
+void f_sign_placelist(typval_T *argvars, typval_T *rettv);
+void f_sign_undefine(typval_T *argvars, typval_T *rettv);
+sign_entry_T *get_first_valid_sign(win_T *wp);
+int signcolumn_on(win_T *wp);
+void f_sign_unplace(typval_T *argvars, typval_T *rettv);
+void f_sign_unplacelist(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/sound.pro b/src/proto/sound.pro
new file mode 100644
index 0000000..c6d0541
--- /dev/null
+++ b/src/proto/sound.pro
@@ -0,0 +1,14 @@
+/* sound.c */
+typedef struct soundcb_S soundcb_T;
+
+int has_any_sound_callback(void);
+int has_sound_callback_in_queue(void);
+void call_sound_callback(soundcb_T *soundcb, long sound_id, int result);
+void delete_sound_callback(soundcb_T *soundcb);
+void invoke_sound_callback(void);
+void f_sound_playevent(typval_T *argvars, typval_T *rettv);
+void f_sound_playfile(typval_T *argvars, typval_T *rettv);
+void f_sound_stop(typval_T *argvars, typval_T *rettv);
+void f_sound_clear(typval_T *argvars, typval_T *rettv);
+void sound_free(void);
+/* vim: set ft=c : */
diff --git a/src/proto/spell.pro b/src/proto/spell.pro
new file mode 100644
index 0000000..f6bad56
--- /dev/null
+++ b/src/proto/spell.pro
@@ -0,0 +1,50 @@
+/* spell.c */
+int spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, int docount);
+int match_checkcompoundpattern(char_u *ptr, int wlen, garray_T *gap);
+int can_compound(slang_T *slang, char_u *word, char_u *flags);
+int match_compoundrule(slang_T *slang, char_u *compflags);
+int valid_word_prefix(int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang, int cond_req);
+int spell_valid_case(int wordflags, int treeflags);
+int spell_check_window(win_T *wp);
+int spell_move_to(win_T *wp, int dir, int allwords, int curline, hlf_T *attrp);
+void spell_cat_line(char_u *buf, char_u *line, int maxlen);
+char_u *spell_enc(void);
+slang_T *slang_alloc(char_u *lang);
+void slang_free(slang_T *lp);
+void slang_clear(slang_T *lp);
+void slang_clear_sug(slang_T *lp);
+void count_common_word(slang_T *lp, char_u *word, int len, int count);
+int byte_in_str(char_u *str, int n);
+int init_syl_tab(slang_T *slang);
+char *parse_spelllang(win_T *wp);
+int captype(char_u *word, char_u *end);
+void spell_delete_wordlist(void);
+void spell_free_all(void);
+void spell_reload(void);
+buf_T *open_spellbuf(void);
+void close_spellbuf(buf_T *buf);
+void clear_spell_chartab(spelltab_T *sp);
+void init_spell_chartab(void);
+int spell_iswordp(char_u *p, win_T *wp);
+int spell_iswordp_nmw(char_u *p, win_T *wp);
+int spell_casefold(win_T *wp, char_u *str, int len, char_u *buf, int buflen);
+int check_need_cap(linenr_T lnum, colnr_T col);
+void ex_spellrepall(exarg_T *eap);
+void onecap_copy(char_u *word, char_u *wcopy, int upper);
+void allcap_copy(char_u *word, char_u *wcopy);
+int nofold_len(char_u *fword, int flen, char_u *word);
+void make_case_word(char_u *fword, char_u *cword, int flags);
+char_u *eval_soundfold(char_u *word);
+void spell_soundfold(slang_T *slang, char_u *inword, int folded, char_u *res);
+void ex_spellinfo(exarg_T *eap);
+void ex_spelldump(exarg_T *eap);
+void spell_dump_compl(char_u *pat, int ic, int *dir, int dumpflags_arg);
+char_u *spell_to_word_end(char_u *start, win_T *win);
+int spell_word_start(int startcol);
+void spell_expand_check_cap(colnr_T col);
+int expand_spelling(linenr_T lnum, char_u *pat, char_u ***matchp);
+int valid_spelllang(char_u *val);
+int valid_spellfile(char_u *val);
+char *did_set_spell_option(int is_spellfile);
+char *compile_cap_prog(synblock_T *synblock);
+/* vim: set ft=c : */
diff --git a/src/proto/spellfile.pro b/src/proto/spellfile.pro
new file mode 100644
index 0000000..552582a
--- /dev/null
+++ b/src/proto/spellfile.pro
@@ -0,0 +1,9 @@
+/* spellfile.c */
+slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, int silent);
+void suggest_load_files(void);
+int spell_check_msm(void);
+void ex_mkspell(exarg_T *eap);
+void mkspell(int fcount, char_u **fnames, int ascii, int over_write, int added_word);
+void ex_spell(exarg_T *eap);
+void spell_add_word(char_u *word, int len, int what, int idx, int undo);
+/* vim: set ft=c : */
diff --git a/src/proto/spellsuggest.pro b/src/proto/spellsuggest.pro
new file mode 100644
index 0000000..745d407
--- /dev/null
+++ b/src/proto/spellsuggest.pro
@@ -0,0 +1,5 @@
+/* spellsuggest.c */
+int spell_check_sps(void);
+void spell_suggest(int count);
+void spell_suggest_list(garray_T *gap, char_u *word, int maxcount, int need_cap, int interactive);
+/* vim: set ft=c : */
diff --git a/src/proto/strings.pro b/src/proto/strings.pro
new file mode 100644
index 0000000..6022088
--- /dev/null
+++ b/src/proto/strings.pro
@@ -0,0 +1,49 @@
+/* strings.c */
+char_u *vim_strsave(char_u *string);
+char_u *vim_strnsave(char_u *string, size_t len);
+char_u *vim_strsave_escaped(char_u *string, char_u *esc_chars);
+char_u *vim_strsave_escaped_ext(char_u *string, char_u *esc_chars, int cc, int bsl);
+int csh_like_shell(void);
+char_u *vim_strsave_shellescape(char_u *string, int do_special, int do_newline);
+char_u *vim_strsave_up(char_u *string);
+char_u *vim_strnsave_up(char_u *string, size_t len);
+void vim_strup(char_u *p);
+char_u *strlow_save(char_u *orig);
+void del_trailing_spaces(char_u *ptr);
+void vim_strncpy(char_u *to, char_u *from, size_t len);
+void vim_strcat(char_u *to, char_u *from, size_t tosize);
+size_t vim_strlen_maxlen(char *s, size_t maxlen);
+int vim_stricmp(char *s1, char *s2);
+int vim_strnicmp(char *s1, char *s2, size_t len);
+char_u *vim_strchr(char_u *string, int c);
+char_u *vim_strbyte(char_u *string, int c);
+char_u *vim_strrchr(char_u *string, int c);
+void sort_strings(char_u **files, int count);
+int has_non_ascii(char_u *s);
+char_u *concat_str(char_u *str1, char_u *str2);
+char_u *string_quote(char_u *str, int function);
+long string_count(char_u *haystack, char_u *needle, int ic);
+void string_filter_map(char_u *str, filtermap_T filtermap, typval_T *expr, typval_T *rettv);
+void string_reduce(typval_T *argvars, typval_T *expr, typval_T *rettv);
+void f_byteidx(typval_T *argvars, typval_T *rettv);
+void f_byteidxcomp(typval_T *argvars, typval_T *rettv);
+void f_charidx(typval_T *argvars, typval_T *rettv);
+void f_str2list(typval_T *argvars, typval_T *rettv);
+void f_str2nr(typval_T *argvars, typval_T *rettv);
+void f_strgetchar(typval_T *argvars, typval_T *rettv);
+void f_stridx(typval_T *argvars, typval_T *rettv);
+void f_string(typval_T *argvars, typval_T *rettv);
+void f_strlen(typval_T *argvars, typval_T *rettv);
+void f_strcharlen(typval_T *argvars, typval_T *rettv);
+void f_strchars(typval_T *argvars, typval_T *rettv);
+void f_strdisplaywidth(typval_T *argvars, typval_T *rettv);
+void f_strwidth(typval_T *argvars, typval_T *rettv);
+void f_strcharpart(typval_T *argvars, typval_T *rettv);
+void f_strpart(typval_T *argvars, typval_T *rettv);
+void f_strridx(typval_T *argvars, typval_T *rettv);
+void f_strtrans(typval_T *argvars, typval_T *rettv);
+void f_tolower(typval_T *argvars, typval_T *rettv);
+void f_toupper(typval_T *argvars, typval_T *rettv);
+void f_tr(typval_T *argvars, typval_T *rettv);
+void f_trim(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/syntax.pro b/src/proto/syntax.pro
new file mode 100644
index 0000000..c51da7a
--- /dev/null
+++ b/src/proto/syntax.pro
@@ -0,0 +1,24 @@
+/* syntax.c */
+void syntax_start(win_T *wp, linenr_T lnum);
+void syn_stack_free_all(synblock_T *block);
+void syn_stack_apply_changes(buf_T *buf);
+void syntax_end_parsing(win_T *wp, linenr_T lnum);
+int syntax_check_changed(linenr_T lnum);
+int get_syntax_attr(colnr_T col, int *can_spell, int keep_state);
+void syntax_clear(synblock_T *block);
+void reset_synblock(win_T *wp);
+void ex_syntax(exarg_T *eap);
+void ex_ownsyntax(exarg_T *eap);
+int syntax_present(win_T *win);
+void reset_expand_highlight(void);
+void set_context_in_echohl_cmd(expand_T *xp, char_u *arg);
+void set_context_in_syntax_cmd(expand_T *xp, char_u *arg);
+char_u *get_syntax_name(expand_T *xp, int idx);
+int syn_get_id(win_T *wp, long lnum, colnr_T col, int trans, int *spellp, int keep_state);
+int get_syntax_info(int *seqnrp);
+int syn_get_sub_char(void);
+int syn_get_stack_item(int i);
+int syn_get_foldlevel(win_T *wp, long lnum);
+void ex_syntime(exarg_T *eap);
+char_u *get_syntime_arg(expand_T *xp, int idx);
+/* vim: set ft=c : */
diff --git a/src/proto/tag.pro b/src/proto/tag.pro
new file mode 100644
index 0000000..6de463e
--- /dev/null
+++ b/src/proto/tag.pro
@@ -0,0 +1,17 @@
+/* tag.c */
+char *did_set_tagfunc(optset_T *args);
+void free_tagfunc_option(void);
+int set_ref_in_tagfunc(int copyID);
+void set_buflocal_tfu_callback(buf_T *buf);
+int do_tag(char_u *tag, int type, int count, int forceit, int verbose);
+void tag_freematch(void);
+void do_tags(exarg_T *eap);
+int find_tags(char_u *pat, int *num_matches, char_u ***matchesp, int flags, int mincount, char_u *buf_ffname);
+void free_tag_stuff(void);
+int get_tagfname(tagname_T *tnp, int first, char_u *buf);
+void tagname_free(tagname_T *tnp);
+int expand_tags(int tagnames, char_u *pat, int *num_file, char_u ***file);
+int get_tags(list_T *list, char_u *pat, char_u *buf_fname);
+void get_tagstack(win_T *wp, dict_T *retdict);
+int set_tagstack(win_T *wp, dict_T *d, int action);
+/* vim: set ft=c : */
diff --git a/src/proto/term.pro b/src/proto/term.pro
new file mode 100644
index 0000000..4c93a81
--- /dev/null
+++ b/src/proto/term.pro
@@ -0,0 +1,96 @@
+/* term.c */
+guicolor_T termgui_get_color(char_u *name);
+guicolor_T termgui_mch_get_rgb(guicolor_T color);
+void init_term_props(int all);
+void f_terminalprops(typval_T *argvars, typval_T *rettv);
+void set_color_count(int nr);
+keyprot_T match_keyprotocol(char_u *term);
+int set_termname(char_u *term);
+void free_cur_term(void);
+void getlinecol(long *cp, long *rp);
+int add_termcap_entry(char_u *name, int force);
+int term_is_8bit(char_u *name);
+int term_is_gui(char_u *name);
+char_u *tltoa(unsigned long i);
+void termcapinit(char_u *name);
+void out_flush(void);
+void out_flush_cursor(int force, int clear_selection);
+void out_flush_check(void);
+void out_trash(void);
+void out_char(unsigned c);
+void out_str_nf(char_u *s);
+void out_str_cf(char_u *s);
+void out_str(char_u *s);
+void term_windgoto(int row, int col);
+void term_cursor_right(int i);
+void term_append_lines(int line_count);
+void term_delete_lines(int line_count);
+void term_enable_mouse(int enable);
+void term_set_winpos(int x, int y);
+int term_get_winpos(int *x, int *y, varnumber_T timeout);
+void term_set_winsize(int height, int width);
+void term_fg_color(int n);
+void term_bg_color(int n);
+void term_ul_color(int n);
+char_u *term_bg_default(void);
+void term_fg_rgb_color(guicolor_T rgb);
+void term_bg_rgb_color(guicolor_T rgb);
+void term_ul_rgb_color(guicolor_T rgb);
+void term_settitle(char_u *title);
+void term_push_title(int which);
+void term_pop_title(int which);
+void ttest(int pairs);
+void add_long_to_buf(long_u val, char_u *dst);
+int get_bytes_from_buf(char_u *buf, char_u *bytes, int num_bytes);
+void check_shellsize(void);
+void limit_screen_size(void);
+void win_new_shellsize(void);
+void shell_resized(void);
+void shell_resized_check(void);
+void set_shellsize(int width, int height, int mustset);
+void out_str_t_TE(void);
+void out_str_t_TI(void);
+void out_str_t_BE(void);
+void may_send_t_RK(void);
+void settmode(tmode_T tmode);
+void starttermcap(void);
+void stoptermcap(void);
+void may_req_termresponse(void);
+void check_terminal_behavior(void);
+void may_req_bg_color(void);
+int swapping_screen(void);
+void scroll_start(void);
+void cursor_on_force(void);
+void cursor_on(void);
+void cursor_off(void);
+int cursor_is_sleeping(void);
+void cursor_sleep(void);
+void cursor_unsleep(void);
+void term_cursor_mode(int forced);
+void term_cursor_color(char_u *color);
+int blink_state_is_inverted(void);
+void term_cursor_shape(int shape, int blink);
+void scroll_region_set(win_T *wp, int off);
+void scroll_region_reset(void);
+void clear_termcodes(void);
+void add_termcode(char_u *name, char_u *string, int flags);
+char_u *find_termcode(char_u *name);
+char_u *get_termcode(int i);
+int get_termcode_len(int idx);
+void del_termcode(char_u *name);
+void set_mouse_topline(win_T *wp);
+int is_mouse_topline(win_T *wp);
+int put_string_in_typebuf(int offset, int slen, char_u *string, int new_slen, char_u *buf, int bufsize, int *buflen);
+int decode_modifiers(int n);
+int check_termcode(int max_offset, char_u *buf, int bufsize, int *buflen);
+void term_get_fg_color(char_u *r, char_u *g, char_u *b);
+void term_get_bg_color(char_u *r, char_u *g, char_u *b);
+char_u *replace_termcodes(char_u *from, char_u **bufp, int flags, int *did_simplify);
+void show_termcodes(int flags);
+int show_one_termcode(char_u *name, char_u *code, int printit);
+void update_tcap(int attr);
+void swap_tcap(void);
+void ansi_color2rgb(int nr, char_u *r, char_u *g, char_u *b, char_u *ansi_idx);
+void cterm_color2rgb(int nr, char_u *r, char_u *g, char_u *b, char_u *ansi_idx);
+int term_replace_keycodes(char_u *ta_buf, int ta_len, int len_arg);
+/* vim: set ft=c : */
diff --git a/src/proto/terminal.pro b/src/proto/terminal.pro
new file mode 100644
index 0000000..f7ba72b
--- /dev/null
+++ b/src/proto/terminal.pro
@@ -0,0 +1,74 @@
+/* terminal.c */
+void init_job_options(jobopt_T *opt);
+buf_T *term_start(typval_T *argvar, char **argv, jobopt_T *opt, int flags);
+void ex_terminal(exarg_T *eap);
+int term_write_session(FILE *fd, win_T *wp, hashtab_T *terminal_bufs);
+int term_should_restore(buf_T *buf);
+void free_terminal(buf_T *buf);
+void free_unused_terminals(void);
+void write_to_term(buf_T *buffer, char_u *msg, channel_T *channel);
+int term_job_running(term_T *term);
+int term_job_running_not_none(term_T *term);
+int term_none_open(term_T *term);
+int term_confirm_stop(buf_T *buf);
+int term_try_stop_job(buf_T *buf);
+int term_check_timers(int next_due_arg, proftime_T *now);
+int term_in_normal_mode(void);
+void term_enter_job_mode(void);
+void check_no_reduce_keys(void);
+int send_keys_to_term(term_T *term, int c, int modmask, int typed);
+int terminal_is_active(void);
+cursorentry_T *term_get_cursor_shape(guicolor_T *fg, guicolor_T *bg);
+int term_use_loop(void);
+void term_win_entered(void);
+void term_focus_change(int in_focus);
+int terminal_loop(int blocking);
+int may_close_term_popup(void);
+void term_channel_closing(channel_T *ch);
+void term_channel_closed(channel_T *ch);
+void term_check_channel_closed_recently(void);
+int term_do_update_window(win_T *wp);
+void term_update_window(win_T *wp);
+void term_did_update_window(win_T *wp);
+int term_is_finished(buf_T *buf);
+int term_show_buffer(buf_T *buf);
+void term_change_in_curbuf(void);
+int term_get_attr(win_T *wp, linenr_T lnum, int col);
+void term_reset_wincolor(win_T *wp);
+void term_update_wincolor(win_T *wp);
+void term_update_wincolor_all(void);
+void term_update_palette_all(void);
+void term_update_colors_all(void);
+char_u *term_get_status_text(term_T *term);
+void term_clear_status_text(term_T *term);
+int set_ref_in_term(int copyID);
+void f_term_dumpwrite(typval_T *argvars, typval_T *rettv);
+int term_swap_diff(void);
+void f_term_dumpdiff(typval_T *argvars, typval_T *rettv);
+void f_term_dumpload(typval_T *argvars, typval_T *rettv);
+void f_term_getaltscreen(typval_T *argvars, typval_T *rettv);
+void f_term_getattr(typval_T *argvars, typval_T *rettv);
+void f_term_getcursor(typval_T *argvars, typval_T *rettv);
+void f_term_getjob(typval_T *argvars, typval_T *rettv);
+void f_term_getline(typval_T *argvars, typval_T *rettv);
+void f_term_getscrolled(typval_T *argvars, typval_T *rettv);
+void f_term_getsize(typval_T *argvars, typval_T *rettv);
+void f_term_setsize(typval_T *argvars, typval_T *rettv);
+void f_term_getstatus(typval_T *argvars, typval_T *rettv);
+void f_term_gettitle(typval_T *argvars, typval_T *rettv);
+void f_term_gettty(typval_T *argvars, typval_T *rettv);
+void f_term_list(typval_T *argvars, typval_T *rettv);
+void f_term_scrape(typval_T *argvars, typval_T *rettv);
+void f_term_sendkeys(typval_T *argvars, typval_T *rettv);
+void f_term_getansicolors(typval_T *argvars, typval_T *rettv);
+void f_term_setansicolors(typval_T *argvars, typval_T *rettv);
+void f_term_setapi(typval_T *argvars, typval_T *rettv);
+void f_term_setrestore(typval_T *argvars, typval_T *rettv);
+void f_term_setkill(typval_T *argvars, typval_T *rettv);
+void f_term_start(typval_T *argvars, typval_T *rettv);
+void f_term_wait(typval_T *argvars, typval_T *rettv);
+void term_send_eof(channel_T *ch);
+job_T *term_getjob(term_T *term);
+int use_conpty(void);
+int terminal_enabled(void);
+/* vim: set ft=c : */
diff --git a/src/proto/termlib.pro b/src/proto/termlib.pro
new file mode 100644
index 0000000..3dd120f
--- /dev/null
+++ b/src/proto/termlib.pro
@@ -0,0 +1,8 @@
+/* termlib.c */
+int tgetent(char *tbuf, char *term);
+int tgetflag(char *id);
+int tgetnum(char *id);
+char *tgetstr(char *id, char **buf);
+char *tgoto(char *cm, int col, int line);
+int tputs(char *cp, int affcnt, void (*outc)(unsigned int));
+/* vim: set ft=c : */
diff --git a/src/proto/testing.pro b/src/proto/testing.pro
new file mode 100644
index 0000000..dea4f75
--- /dev/null
+++ b/src/proto/testing.pro
@@ -0,0 +1,39 @@
+/* testing.c */
+void f_assert_beeps(typval_T *argvars, typval_T *rettv);
+void f_assert_nobeep(typval_T *argvars, typval_T *rettv);
+void f_assert_equal(typval_T *argvars, typval_T *rettv);
+void f_assert_equalfile(typval_T *argvars, typval_T *rettv);
+void f_assert_notequal(typval_T *argvars, typval_T *rettv);
+void f_assert_exception(typval_T *argvars, typval_T *rettv);
+void f_assert_fails(typval_T *argvars, typval_T *rettv);
+void f_assert_false(typval_T *argvars, typval_T *rettv);
+void f_assert_inrange(typval_T *argvars, typval_T *rettv);
+void f_assert_match(typval_T *argvars, typval_T *rettv);
+void f_assert_notmatch(typval_T *argvars, typval_T *rettv);
+void f_assert_report(typval_T *argvars, typval_T *rettv);
+void f_assert_true(typval_T *argvars, typval_T *rettv);
+void f_test_alloc_fail(typval_T *argvars, typval_T *rettv);
+void f_test_autochdir(typval_T *argvars, typval_T *rettv);
+void f_test_feedinput(typval_T *argvars, typval_T *rettv);
+void f_test_getvalue(typval_T *argvars, typval_T *rettv);
+void f_test_option_not_set(typval_T *argvars, typval_T *rettv);
+void f_test_override(typval_T *argvars, typval_T *rettv);
+void f_test_refcount(typval_T *argvars, typval_T *rettv);
+void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv);
+void f_test_garbagecollect_soon(typval_T *argvars, typval_T *rettv);
+void f_test_ignore_error(typval_T *argvars, typval_T *rettv);
+void f_test_null_blob(typval_T *argvars, typval_T *rettv);
+void f_test_null_channel(typval_T *argvars, typval_T *rettv);
+void f_test_null_dict(typval_T *argvars, typval_T *rettv);
+void f_test_null_job(typval_T *argvars, typval_T *rettv);
+void f_test_null_list(typval_T *argvars, typval_T *rettv);
+void f_test_null_function(typval_T *argvars, typval_T *rettv);
+void f_test_null_partial(typval_T *argvars, typval_T *rettv);
+void f_test_null_string(typval_T *argvars, typval_T *rettv);
+void f_test_unknown(typval_T *argvars, typval_T *rettv);
+void f_test_void(typval_T *argvars, typval_T *rettv);
+void f_test_setmouse(typval_T *argvars, typval_T *rettv);
+void f_test_mswin_event(typval_T *argvars, typval_T *rettv);
+void f_test_gui_event(typval_T *argvars, typval_T *rettv);
+void f_test_settime(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/textformat.pro b/src/proto/textformat.pro
new file mode 100644
index 0000000..6f358fa
--- /dev/null
+++ b/src/proto/textformat.pro
@@ -0,0 +1,11 @@
+/* textformat.c */
+int has_format_option(int x);
+void internal_format(int textwidth, int second_indent, int flags, int format_only, int c);
+void auto_format(int trailblank, int prev_line);
+void check_auto_format(int end_insert);
+int comp_textwidth(int ff);
+void op_format(oparg_T *oap, int keep_cursor);
+void op_formatexpr(oparg_T *oap);
+int fex_format(linenr_T lnum, long count, int c);
+void format_lines(linenr_T line_count, int avoid_fex);
+/* vim: set ft=c : */
diff --git a/src/proto/textobject.pro b/src/proto/textobject.pro
new file mode 100644
index 0000000..5911635
--- /dev/null
+++ b/src/proto/textobject.pro
@@ -0,0 +1,15 @@
+/* textobject.c */
+int findsent(int dir, long count);
+int findpar(int *pincl, int dir, long count, int what, int both);
+int startPS(linenr_T lnum, int para, int both);
+int fwd_word(long count, int bigword, int eol);
+int bck_word(long count, int bigword, int stop);
+int end_word(long count, int bigword, int stop, int empty);
+int bckend_word(long count, int bigword, int eol);
+int current_word(oparg_T *oap, long count, int include, int bigword);
+int current_sent(oparg_T *oap, long count, int include);
+int current_block(oparg_T *oap, long count, int include, int what, int other);
+int current_tagblock(oparg_T *oap, long count_arg, int include);
+int current_par(oparg_T *oap, long count, int include, int type);
+int current_quote(oparg_T *oap, long count, int include, int quotechar);
+/* vim: set ft=c : */
diff --git a/src/proto/textprop.pro b/src/proto/textprop.pro
new file mode 100644
index 0000000..4b9a7a4
--- /dev/null
+++ b/src/proto/textprop.pro
@@ -0,0 +1,28 @@
+/* textprop.c */
+int find_prop_type_id(char_u *name, buf_T *buf);
+void f_prop_add(typval_T *argvars, typval_T *rettv);
+void f_prop_add_list(typval_T *argvars, typval_T *rettv);
+int prop_add_common(linenr_T start_lnum, colnr_T start_col, dict_T *dict, buf_T *default_buf, typval_T *dict_arg);
+int get_text_props(buf_T *buf, linenr_T lnum, char_u **props, int will_change);
+int prop_count_above_below(buf_T *buf, linenr_T lnum);
+int count_props(linenr_T lnum, int only_starting, int last_line);
+void sort_text_props(buf_T *buf, textprop_T *props, int *idxs, int count);
+int find_visible_prop(win_T *wp, int type_id, int id, textprop_T *prop, linenr_T *found_lnum);
+void add_text_props(linenr_T lnum, textprop_T *text_props, int text_prop_count);
+proptype_T *text_prop_type_by_id(buf_T *buf, int id);
+int text_prop_type_valid(buf_T *buf, textprop_T *prop);
+void f_prop_clear(typval_T *argvars, typval_T *rettv);
+void f_prop_find(typval_T *argvars, typval_T *rettv);
+void f_prop_list(typval_T *argvars, typval_T *rettv);
+void f_prop_remove(typval_T *argvars, typval_T *rettv);
+void f_prop_type_add(typval_T *argvars, typval_T *rettv);
+void f_prop_type_change(typval_T *argvars, typval_T *rettv);
+void f_prop_type_delete(typval_T *argvars, typval_T *rettv);
+void f_prop_type_get(typval_T *argvars, typval_T *rettv);
+void f_prop_type_list(typval_T *argvars, typval_T *rettv);
+void clear_global_prop_types(void);
+void clear_buf_prop_types(buf_T *buf);
+int adjust_prop_columns(linenr_T lnum, colnr_T col, int bytes_added, int flags);
+void adjust_props_for_split(linenr_T lnum_props, linenr_T lnum_top, int kept, int deleted, int at_eol);
+void prepend_joined_props(char_u *new_props, int propcount, int *props_remaining, linenr_T lnum, int last_line, long col, int removed);
+/* vim: set ft=c : */
diff --git a/src/proto/time.pro b/src/proto/time.pro
new file mode 100644
index 0000000..7e44bca
--- /dev/null
+++ b/src/proto/time.pro
@@ -0,0 +1,30 @@
+/* time.c */
+time_T vim_time(void);
+char *get_ctime(time_t thetime, int add_newline);
+void f_localtime(typval_T *argvars, typval_T *rettv);
+void f_reltime(typval_T *argvars, typval_T *rettv);
+void f_reltimefloat(typval_T *argvars, typval_T *rettv);
+void f_reltimestr(typval_T *argvars, typval_T *rettv);
+void f_strftime(typval_T *argvars, typval_T *rettv);
+void f_strptime(typval_T *argvars, typval_T *rettv);
+long proftime_time_left(proftime_T *due, proftime_T *now);
+timer_T *create_timer(long msec, int repeat);
+void timer_start(timer_T *timer);
+long check_due_timer(void);
+void stop_timer(timer_T *timer);
+int set_ref_in_timer(int copyID);
+int timer_valid(timer_T *timer);
+void timer_free_all(void);
+void f_timer_info(typval_T *argvars, typval_T *rettv);
+void f_timer_pause(typval_T *argvars, typval_T *rettv);
+void f_timer_start(typval_T *argvars, typval_T *rettv);
+void f_timer_stop(typval_T *argvars, typval_T *rettv);
+void f_timer_stopall(typval_T *argvars, typval_T *rettv);
+void time_push(void *tv_rel, void *tv_start);
+void time_pop(void *tp);
+void time_msg(char *mesg, void *tv_start);
+time_T get8ctime(FILE *fd);
+int put_time(FILE *fd, time_T the_time);
+void time_to_bytes(time_T the_time, char_u *buf);
+void add_time(char_u *buf, size_t buflen, time_t tt);
+/* vim: set ft=c : */
diff --git a/src/proto/typval.pro b/src/proto/typval.pro
new file mode 100644
index 0000000..f3184d0
--- /dev/null
+++ b/src/proto/typval.pro
@@ -0,0 +1,85 @@
+/* typval.c */
+typval_T *alloc_tv(void);
+typval_T *alloc_string_tv(char_u *s);
+void free_tv(typval_T *varp);
+void clear_tv(typval_T *varp);
+void init_tv(typval_T *varp);
+varnumber_T tv_get_number(typval_T *varp);
+varnumber_T tv_get_number_chk(typval_T *varp, int *denote);
+varnumber_T tv_get_bool(typval_T *varp);
+varnumber_T tv_get_bool_chk(typval_T *varp, int *denote);
+float_T tv_get_float(typval_T *varp);
+int check_for_unknown_arg(typval_T *args, int idx);
+int check_for_string_arg(typval_T *args, int idx);
+int check_for_nonempty_string_arg(typval_T *args, int idx);
+int check_for_opt_string_arg(typval_T *args, int idx);
+int check_for_number_arg(typval_T *args, int idx);
+int check_for_opt_number_arg(typval_T *args, int idx);
+int check_for_float_or_nr_arg(typval_T *args, int idx);
+int check_for_bool_arg(typval_T *args, int idx);
+int check_for_opt_bool_arg(typval_T *args, int idx);
+int check_for_blob_arg(typval_T *args, int idx);
+int check_for_list_arg(typval_T *args, int idx);
+int check_for_nonnull_list_arg(typval_T *args, int idx);
+int check_for_opt_list_arg(typval_T *args, int idx);
+int check_for_dict_arg(typval_T *args, int idx);
+int check_for_nonnull_dict_arg(typval_T *args, int idx);
+int check_for_opt_dict_arg(typval_T *args, int idx);
+int check_for_chan_or_job_arg(typval_T *args, int idx);
+int check_for_opt_chan_or_job_arg(typval_T *args, int idx);
+int check_for_job_arg(typval_T *args, int idx);
+int check_for_opt_job_arg(typval_T *args, int idx);
+int check_for_string_or_number_arg(typval_T *args, int idx);
+int check_for_opt_string_or_number_arg(typval_T *args, int idx);
+int check_for_buffer_arg(typval_T *args, int idx);
+int check_for_opt_buffer_arg(typval_T *args, int idx);
+int check_for_lnum_arg(typval_T *args, int idx);
+int check_for_opt_lnum_arg(typval_T *args, int idx);
+int check_for_string_or_blob_arg(typval_T *args, int idx);
+int check_for_string_or_list_arg(typval_T *args, int idx);
+int check_for_string_or_list_or_blob_arg(typval_T *args, int idx);
+int check_for_opt_string_or_list_arg(typval_T *args, int idx);
+int check_for_string_or_dict_arg(typval_T *args, int idx);
+int check_for_string_or_number_or_list_arg(typval_T *args, int idx);
+int check_for_opt_string_or_number_or_list_arg(typval_T *args, int idx);
+int check_for_string_or_number_or_list_or_blob_arg(typval_T *args, int idx);
+int check_for_string_or_list_or_dict_arg(typval_T *args, int idx);
+int check_for_string_or_func_arg(typval_T *args, int idx);
+int check_for_list_or_blob_arg(typval_T *args, int idx);
+int check_for_list_or_dict_arg(typval_T *args, int idx);
+int check_for_list_or_dict_or_blob_arg(typval_T *args, int idx);
+int check_for_list_or_dict_or_blob_or_string_arg(typval_T *args, int idx);
+int check_for_opt_buffer_or_dict_arg(typval_T *args, int idx);
+char_u *tv_get_string(typval_T *varp);
+char_u *tv_get_string_strict(typval_T *varp);
+char_u *tv_get_string_buf(typval_T *varp, char_u *buf);
+char_u *tv_get_string_chk(typval_T *varp);
+char_u *tv_get_string_buf_chk(typval_T *varp, char_u *buf);
+char_u *tv_get_string_buf_chk_strict(typval_T *varp, char_u *buf, int strict);
+char_u *tv_stringify(typval_T *varp, char_u *buf);
+int tv_check_lock(typval_T *tv, char_u *name, int use_gettext);
+void copy_tv(typval_T *from, typval_T *to);
+int typval_compare(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic);
+int typval_compare_list(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+int typval_compare_null(typval_T *tv1, typval_T *tv2);
+int typval_compare_blob(typval_T *tv1, typval_T *tv2, exprtype_T type, int *res);
+int typval_compare_class(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+int typval_compare_object(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+int typval_compare_dict(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+int typval_compare_func(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+int typval_compare_string(typval_T *tv1, typval_T *tv2, exprtype_T type, int ic, int *res);
+char_u *typval_tostring(typval_T *arg, int quotes);
+int tv_islocked(typval_T *tv);
+int tv_equal(typval_T *tv1, typval_T *tv2, int ic, int recursive);
+int eval_option(char_u **arg, typval_T *rettv, int evaluate);
+int eval_number(char_u **arg, typval_T *rettv, int evaluate, int want_string);
+int eval_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate);
+int eval_lit_string(char_u **arg, typval_T *rettv, int evaluate, int interpolate);
+int eval_interp_string(char_u **arg, typval_T *rettv, int evaluate);
+char_u *tv2string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);
+int eval_env_var(char_u **arg, typval_T *rettv, int evaluate);
+linenr_T tv_get_lnum(typval_T *argvars);
+linenr_T tv_get_lnum_buf(typval_T *argvars, buf_T *buf);
+buf_T *tv_get_buf(typval_T *tv, int curtab_only);
+buf_T *tv_get_buf_from_arg(typval_T *tv);
+/* vim: set ft=c : */
diff --git a/src/proto/ui.pro b/src/proto/ui.pro
new file mode 100644
index 0000000..7ad7c75
--- /dev/null
+++ b/src/proto/ui.pro
@@ -0,0 +1,37 @@
+/* ui.c */
+void ui_write(char_u *s, int len, int console);
+void ui_inchar_undo(char_u *s, int len);
+int ui_inchar(char_u *buf, int maxlen, long wtime, int tb_change_cnt);
+int inchar_loop(char_u *buf, int maxlen, long wtime, int tb_change_cnt, int (*wait_func)(long wtime, int *interrupted, int ignore_input), int (*resize_func)(int check_only));
+int ui_wait_for_chars_or_timer(long wtime, int (*wait_func)(long wtime, int *interrupted, int ignore_input), int *interrupted, int ignore_input);
+int ui_char_avail(void);
+void ui_delay(long msec_arg, int ignoreinput);
+void ui_suspend(void);
+void suspend_shell(void);
+int ui_get_shellsize(void);
+void ui_set_shellsize(int mustset);
+void ui_new_shellsize(void);
+int ui_get_winpos(int *x, int *y, varnumber_T timeout);
+void ui_breakcheck(void);
+void ui_breakcheck_force(int force);
+int vim_is_input_buf_full(void);
+int vim_is_input_buf_empty(void);
+int vim_free_in_input_buf(void);
+int vim_used_in_input_buf(void);
+char_u *get_input_buf(void);
+void set_input_buf(char_u *p, int overwrite);
+void add_to_input_buf(char_u *s, int len);
+void add_to_input_buf_csi(char_u *str, int len);
+void trash_input_buf(void);
+int read_from_input_buf(char_u *buf, long maxlen);
+void fill_input_buf(int exit_on_error);
+void read_error_exit(void);
+void ui_cursor_shape_forced(int forced);
+void ui_cursor_shape(void);
+int check_col(int col);
+int check_row(int row);
+long scroll_line_len(linenr_T lnum);
+linenr_T ui_find_longest_lnum(void);
+void ui_focus_change(int in_focus);
+void im_save_status(long *psave);
+/* vim: set ft=c : */
diff --git a/src/proto/undo.pro b/src/proto/undo.pro
new file mode 100644
index 0000000..851d281
--- /dev/null
+++ b/src/proto/undo.pro
@@ -0,0 +1,32 @@
+/* undo.c */
+int u_save_cursor(void);
+int u_save(linenr_T top, linenr_T bot);
+int u_savesub(linenr_T lnum);
+int u_inssub(linenr_T lnum);
+int u_savedel(linenr_T lnum, long nlines);
+int undo_allowed(void);
+int u_savecommon(linenr_T top, linenr_T bot, linenr_T newbot, int reload);
+void u_compute_hash(char_u *hash);
+void u_write_undo(char_u *name, int forceit, buf_T *buf, char_u *hash);
+void u_read_undo(char_u *name, char_u *hash, char_u *orig_name);
+void u_undo(int count);
+void u_redo(int count);
+void undo_time(long step, int sec, int file, int absolute);
+void u_sync(int force);
+void ex_undolist(exarg_T *eap);
+void ex_undojoin(exarg_T *eap);
+void u_unchanged(buf_T *buf);
+void u_find_first_changed(void);
+void u_update_save_nr(buf_T *buf);
+void u_clearall(buf_T *buf);
+void u_clearline(void);
+void u_undoline(void);
+void u_blockfree(buf_T *buf);
+int bufIsChanged(buf_T *buf);
+int anyBufIsChanged(void);
+int bufIsChangedNotTerm(buf_T *buf);
+int curbufIsChanged(void);
+void f_undofile(typval_T *argvars, typval_T *rettv);
+void u_undofile_reset_and_delete(buf_T *buf);
+void f_undotree(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/usercmd.pro b/src/proto/usercmd.pro
new file mode 100644
index 0000000..d0cd2a3
--- /dev/null
+++ b/src/proto/usercmd.pro
@@ -0,0 +1,24 @@
+/* usercmd.c */
+char_u *find_ucmd(exarg_T *eap, char_u *p, int *full, expand_T *xp, int *complp);
+char_u *set_context_in_user_cmd(expand_T *xp, char_u *arg_in);
+char_u *set_context_in_user_cmdarg(char_u *cmd, char_u *arg, long argt, int context, expand_T *xp, int forceit);
+char_u *expand_user_command_name(int idx);
+char_u *get_user_commands(expand_T *xp, int idx);
+char_u *get_user_command_name(int idx, int cmdidx);
+char_u *get_user_cmd_addr_type(expand_T *xp, int idx);
+char_u *get_user_cmd_flags(expand_T *xp, int idx);
+char_u *get_user_cmd_nargs(expand_T *xp, int idx);
+char_u *get_user_cmd_complete(expand_T *xp, int idx);
+char_u *cmdcomplete_type_to_str(int expand);
+int cmdcomplete_str_to_type(char_u *complete_str);
+char *uc_fun_cmd(void);
+int parse_compl_arg(char_u *value, int vallen, int *complp, long *argt, char_u **compl_arg);
+char_u *may_get_cmd_block(exarg_T *eap, char_u *p, char_u **tofree, int *flags);
+void ex_command(exarg_T *eap);
+void ex_comclear(exarg_T *eap);
+void uc_clear(garray_T *gap);
+void ex_delcommand(exarg_T *eap);
+size_t add_win_cmd_modifiers(char_u *buf, cmdmod_T *cmod, int *multi_mods);
+size_t produce_cmdmods(char_u *buf, cmdmod_T *cmod, int quote);
+void do_ucmd(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/userfunc.pro b/src/proto/userfunc.pro
new file mode 100644
index 0000000..e5d78b6
--- /dev/null
+++ b/src/proto/userfunc.pro
@@ -0,0 +1,97 @@
+/* userfunc.c */
+void func_init(void);
+hashtab_T *func_tbl_get(void);
+char_u *make_ufunc_name_readable(char_u *name, char_u *buf, size_t bufsize);
+char_u *get_lambda_name(void);
+char_u *register_cfunc(cfunc_T cb, cfunc_free_T cb_free, void *state);
+int get_lambda_tv(char_u **arg, typval_T *rettv, int types_optional, evalarg_T *evalarg);
+char_u *deref_func_name(char_u *name, int *lenp, partial_T **partialp, type_T **type, int no_autoload, int new_function, int *found_var);
+void emsg_funcname(char *ermsg, char_u *name);
+int get_func_arguments(char_u **arg, evalarg_T *evalarg, int partial_argc, typval_T *argvars, int *argcount);
+int get_func_tv(char_u *name, int len, typval_T *rettv, char_u **arg, evalarg_T *evalarg, funcexe_T *funcexe);
+char_u *fname_trans_sid(char_u *name, char_u *fname_buf, char_u **tofree, funcerror_T *error);
+void func_name_with_sid(char_u *name, int sid, char_u *buffer);
+ufunc_T *find_func_even_dead(char_u *name, int flags);
+ufunc_T *find_func(char_u *name, int is_global);
+int func_is_global(ufunc_T *ufunc);
+int func_requires_g_prefix(ufunc_T *ufunc);
+int func_name_refcount(char_u *name);
+void func_clear_free(ufunc_T *fp, int force);
+int copy_lambda_to_global_func(char_u *lambda, char_u *global, loopvarinfo_T *loopvarinfo, ectx_T *ectx);
+int funcdepth_increment(void);
+void funcdepth_decrement(void);
+int funcdepth_get(void);
+void funcdepth_restore(int depth);
+funccall_T *create_funccal(ufunc_T *fp, typval_T *rettv);
+void remove_funccal(void);
+funcerror_T check_user_func_argcount(ufunc_T *fp, int argcount);
+funcerror_T call_user_func_check(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rettv, funcexe_T *funcexe, dict_T *selfdict);
+void save_funccal(funccal_entry_T *entry);
+void restore_funccal(void);
+funccall_T *get_current_funccal(void);
+int at_script_level(void);
+void delete_script_functions(int sid);
+void free_all_functions(void);
+int builtin_function(char_u *name, int len);
+int func_call(char_u *name, typval_T *args, partial_T *partial, dict_T *selfdict, typval_T *rettv);
+int get_callback_depth(void);
+int call_callback(callback_T *callback, int len, typval_T *rettv, int argcount, typval_T *argvars);
+varnumber_T call_callback_retnr(callback_T *callback, int argcount, typval_T *argvars);
+void user_func_error(funcerror_T error, char_u *name, int found_var);
+int call_func(char_u *funcname, int len, typval_T *rettv, int argcount_in, typval_T *argvars_in, funcexe_T *funcexe);
+int call_simple_func(char_u *funcname, int len, typval_T *rettv);
+char_u *printable_func_name(ufunc_T *fp);
+char_u *trans_function_name(char_u **pp, int *is_global, int skip, int flags);
+char_u *trans_function_name_ext(char_u **pp, int *is_global, int skip, int flags, funcdict_T *fdp, partial_T **partial, type_T **type, ufunc_T **ufunc);
+char_u *get_scriptlocal_funcname(char_u *funcname);
+char_u *alloc_printable_func_name(char_u *fname);
+char_u *save_function_name(char_u **name, int *is_global, int skip, int flags, funcdict_T *fudi);
+void list_functions(regmatch_T *regmatch);
+ufunc_T *define_function(exarg_T *eap, char_u *name_arg, garray_T *lines_to_free, int class_flags);
+void ex_function(exarg_T *eap);
+ufunc_T *find_func_by_name(char_u *name, compiletype_T *compile_type);
+void ex_defcompile(exarg_T *eap);
+int eval_fname_script(char_u *p);
+int translated_function_exists(char_u *name, int is_global);
+int has_varargs(ufunc_T *ufunc);
+int function_exists(char_u *name, int no_deref);
+char_u *get_expanded_name(char_u *name, int check);
+char_u *get_user_func_name(expand_T *xp, int idx);
+ufunc_T *copy_function(ufunc_T *fp);
+void ex_delfunction(exarg_T *eap);
+void func_unref(char_u *name);
+void func_ptr_unref(ufunc_T *fp);
+void func_ref(char_u *name);
+void func_ptr_ref(ufunc_T *fp);
+void ex_return(exarg_T *eap);
+int can_add_defer(void);
+int add_defer(char_u *name, int argcount_arg, typval_T *argvars);
+void invoke_all_defer(void);
+void ex_call(exarg_T *eap);
+int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv);
+void discard_pending_return(void *rettv);
+char_u *get_return_cmd(void *rettv);
+char_u *get_func_line(int c, void *cookie, int indent, getline_opt_T options);
+int func_has_ended(void *cookie);
+int func_has_abort(void *cookie);
+dict_T *make_partial(dict_T *selfdict_in, typval_T *rettv);
+char_u *func_name(void *cookie);
+linenr_T *func_breakpoint(void *cookie);
+int *func_dbg_tick(void *cookie);
+int func_level(void *cookie);
+int current_func_returned(void);
+int free_unref_funccal(int copyID, int testing);
+hashtab_T *get_funccal_local_ht(void);
+dictitem_T *get_funccal_local_var(void);
+hashtab_T *get_funccal_args_ht(void);
+dictitem_T *get_funccal_args_var(void);
+void list_func_vars(int *first);
+dict_T *get_current_funccal_dict(hashtab_T *ht);
+hashitem_T *find_hi_in_scoped_ht(char_u *name, hashtab_T **pht);
+dictitem_T *find_var_in_scoped_ht(char_u *name, int no_autoload);
+int set_ref_in_previous_funccal(int copyID);
+int set_ref_in_call_stack(int copyID);
+int set_ref_in_functions(int copyID);
+int set_ref_in_func_args(int copyID);
+int set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID);
+/* vim: set ft=c : */
diff --git a/src/proto/version.pro b/src/proto/version.pro
new file mode 100644
index 0000000..417000c
--- /dev/null
+++ b/src/proto/version.pro
@@ -0,0 +1,10 @@
+/* version.c */
+void init_longVersion(void);
+int highest_patch(void);
+int has_patch(int n);
+void ex_version(exarg_T *eap);
+void list_in_columns(char_u **items, int size, int current);
+void list_version(void);
+void maybe_intro_message(void);
+void ex_intro(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9class.pro b/src/proto/vim9class.pro
new file mode 100644
index 0000000..707f4ec
--- /dev/null
+++ b/src/proto/vim9class.pro
@@ -0,0 +1,18 @@
+/* vim9class.c */
+int object_index_from_itf_index(class_T *itf, int is_method, int idx, class_T *cl);
+void ex_class(exarg_T *eap);
+type_T *class_member_type(class_T *cl, char_u *name, char_u *name_end, int *member_idx);
+void ex_enum(exarg_T *eap);
+void ex_type(exarg_T *eap);
+int class_object_index(char_u **arg, typval_T *rettv, evalarg_T *evalarg, int verbose);
+ufunc_T *find_class_func(char_u **arg);
+int class_member_index(char_u *name, size_t len, class_T **cl_ret, cctx_T *cctx);
+int inside_class(cctx_T *cctx_arg, class_T *cl);
+void copy_object(typval_T *from, typval_T *to);
+void object_unref(object_T *obj);
+void copy_class(typval_T *from, typval_T *to);
+void class_unref(class_T *cl);
+void object_created(object_T *obj);
+void object_cleared(object_T *obj);
+int object_free_nonref(int copyID);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9cmds.pro b/src/proto/vim9cmds.pro
new file mode 100644
index 0000000..bd2b5c2
--- /dev/null
+++ b/src/proto/vim9cmds.pro
@@ -0,0 +1,37 @@
+/* vim9cmds.c */
+void free_locals(cctx_T *cctx);
+int check_vim9_unlet(char_u *name);
+char_u *compile_unletlock(char_u *arg, exarg_T *eap, cctx_T *cctx);
+void drop_scope(cctx_T *cctx);
+char_u *compile_if(char_u *arg, cctx_T *cctx);
+char_u *compile_elseif(char_u *arg, cctx_T *cctx);
+char_u *compile_else(char_u *arg, cctx_T *cctx);
+char_u *compile_endif(char_u *arg, cctx_T *cctx);
+char_u *compile_for(char_u *arg_start, cctx_T *cctx);
+char_u *compile_endfor(char_u *arg, cctx_T *cctx);
+char_u *compile_while(char_u *arg, cctx_T *cctx);
+char_u *compile_endwhile(char_u *arg, cctx_T *cctx);
+int get_loop_var_info(cctx_T *cctx, loopvarinfo_T *lvi);
+void get_loop_var_idx(cctx_T *cctx, int idx, lvar_T *lvar);
+char_u *compile_continue(char_u *arg, cctx_T *cctx);
+char_u *compile_break(char_u *arg, cctx_T *cctx);
+char_u *compile_block(char_u *arg, cctx_T *cctx);
+void compile_endblock(cctx_T *cctx);
+char_u *compile_try(char_u *arg, cctx_T *cctx);
+char_u *compile_catch(char_u *arg, cctx_T *cctx);
+char_u *compile_finally(char_u *arg, cctx_T *cctx);
+char_u *compile_endtry(char_u *arg, cctx_T *cctx);
+char_u *compile_throw(char_u *arg, cctx_T *cctx);
+char_u *compile_eval(char_u *arg, cctx_T *cctx);
+int get_defer_var_idx(cctx_T *cctx);
+char_u *compile_defer(char_u *arg_start, cctx_T *cctx);
+char_u *compile_mult_expr(char_u *arg, int cmdidx, long cmd_count, cctx_T *cctx);
+char_u *compile_put(char_u *arg, exarg_T *eap, cctx_T *cctx);
+char_u *compile_exec(char_u *line_arg, exarg_T *eap, cctx_T *cctx);
+char_u *compile_script(char_u *line, cctx_T *cctx);
+char_u *compile_substitute(char_u *arg, exarg_T *eap, cctx_T *cctx);
+char_u *compile_redir(char_u *line, exarg_T *eap, cctx_T *cctx);
+char_u *compile_cexpr(char_u *line, exarg_T *eap, cctx_T *cctx);
+char_u *compile_return(char_u *arg, int check_return_type, int legacy, cctx_T *cctx);
+int check_global_and_subst(char_u *cmd, char_u *arg);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9compile.pro b/src/proto/vim9compile.pro
new file mode 100644
index 0000000..9f2263a
--- /dev/null
+++ b/src/proto/vim9compile.pro
@@ -0,0 +1,35 @@
+/* vim9compile.c */
+int lookup_local(char_u *name, size_t len, lvar_T *lvar, cctx_T *cctx);
+int arg_exists(char_u *name, size_t len, int *idxp, type_T **type, int *gen_load_outer, cctx_T *cctx);
+void update_script_var_block_id(char_u *name, int block_id);
+int script_is_vim9(void);
+int script_var_exists(char_u *name, size_t len, cctx_T *cctx, cstack_T *cstack);
+int check_defined(char_u *p, size_t len, cctx_T *cctx, cstack_T *cstack, int is_arg);
+int need_type_where(type_T *actual, type_T *expected, int number_ok, int offset, where_T where, cctx_T *cctx, int silent, int actual_is_const);
+int need_type(type_T *actual, type_T *expected, int number_ok, int offset, int arg_idx, cctx_T *cctx, int silent, int actual_is_const);
+lvar_T *reserve_local(cctx_T *cctx, char_u *name, size_t len, int assign, type_T *type);
+int get_script_item_idx(int sid, char_u *name, int check_writable, cctx_T *cctx, cstack_T *cstack);
+imported_T *find_imported(char_u *name, size_t len, int load);
+char_u *may_peek_next_line(cctx_T *cctx, char_u *arg, char_u **nextp);
+char_u *peek_next_line_from_context(cctx_T *cctx);
+char_u *next_line_from_context(cctx_T *cctx, int skip_comment);
+int may_get_next_line(char_u *whitep, char_u **arg, cctx_T *cctx);
+int may_get_next_line_error(char_u *whitep, char_u **arg, cctx_T *cctx);
+void fill_exarg_from_cctx(exarg_T *eap, cctx_T *cctx);
+int func_needs_compiling(ufunc_T *ufunc, compiletype_T compile_type);
+char_u *compile_one_expr_in_str(char_u *p, cctx_T *cctx);
+int compile_all_expr_in_str(char_u *str, int evalstr, cctx_T *cctx);
+int assignment_len(char_u *p, int *heredoc);
+void vim9_declare_error(char_u *name);
+int get_var_dest(char_u *name, assign_dest_T *dest, cmdidx_T cmdidx, int *option_scope, int *vimvaridx, type_T **type, cctx_T *cctx);
+int compile_lhs(char_u *var_start, lhs_T *lhs, cmdidx_T cmdidx, int heredoc, int has_cmd, int oplen, cctx_T *cctx);
+int compile_assign_lhs(char_u *var_start, lhs_T *lhs, cmdidx_T cmdidx, int is_decl, int heredoc, int has_cmd, int oplen, cctx_T *cctx);
+int compile_load_lhs_with_index(lhs_T *lhs, char_u *var_start, cctx_T *cctx);
+int compile_assign_unlet(char_u *var_start, lhs_T *lhs, int is_assign, type_T *rhs_type, cctx_T *cctx);
+compiletype_T get_compile_type(ufunc_T *ufunc);
+int compile_def_function(ufunc_T *ufunc, int check_return_type, compiletype_T compile_type, cctx_T *outer_cctx);
+void set_function_type(ufunc_T *ufunc);
+void unlink_def_function(ufunc_T *ufunc);
+void link_def_function(ufunc_T *ufunc);
+void free_def_functions(void);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9execute.pro b/src/proto/vim9execute.pro
new file mode 100644
index 0000000..7f8e5fd
--- /dev/null
+++ b/src/proto/vim9execute.pro
@@ -0,0 +1,29 @@
+/* vim9execute.c */
+void to_string_error(vartype_T vartype);
+void update_has_breakpoint(ufunc_T *ufunc);
+int funcstack_check_refcount(funcstack_T *funcstack);
+int set_ref_in_funcstacks(int copyID);
+int in_def_function(void);
+ectx_T *clear_current_ectx(void);
+void restore_current_ectx(ectx_T *ectx);
+int add_defer_function(char_u *name, int argcount, typval_T *argvars);
+char_u *char_from_string(char_u *str, varnumber_T index);
+char_u *string_slice(char_u *str, varnumber_T first, varnumber_T last, int exclusive);
+int fill_partial_and_closure(partial_T *pt, ufunc_T *ufunc, loopvarinfo_T *lvi, ectx_T *ectx);
+int may_load_script(int sid, int *loaded);
+typval_T *lookup_debug_var(char_u *name);
+int may_break_in_function(ufunc_T *ufunc);
+int loopvars_check_refcount(loopvars_T *loopvars);
+int set_ref_in_loopvars(int copyID);
+int exe_typval_instr(typval_T *tv, typval_T *rettv);
+char_u *exe_substitute_instr(void);
+int call_def_function(ufunc_T *ufunc, int argc_arg, typval_T *argv, int flags, partial_T *partial, object_T *object, funccall_T *funccal, typval_T *rettv);
+void unwind_def_callstack(ectx_T *ectx);
+void may_invoke_defer_funcs(ectx_T *ectx);
+void set_context_in_disassemble_cmd(expand_T *xp, char_u *arg);
+char_u *get_disassemble_argument(expand_T *xp, int idx);
+void ex_disassemble(exarg_T *eap);
+int tv2bool(typval_T *tv);
+void emsg_using_string_as(typval_T *tv, int as_number);
+int check_not_string(typval_T *tv);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9expr.pro b/src/proto/vim9expr.pro
new file mode 100644
index 0000000..f58e346
--- /dev/null
+++ b/src/proto/vim9expr.pro
@@ -0,0 +1,18 @@
+/* vim9expr.c */
+int generate_ppconst(cctx_T *cctx, ppconst_T *ppconst);
+void clear_ppconst(ppconst_T *ppconst);
+int compile_member(int is_slice, int *keeping_dict, cctx_T *cctx);
+int compile_load_scriptvar(cctx_T *cctx, char_u *name, char_u *start, char_u **end);
+int compile_load(char_u **arg, char_u *end_arg, cctx_T *cctx, int is_expr, int error);
+int compile_arguments(char_u **arg, cctx_T *cctx, int *argcount, ca_special_T special_fn);
+char_u *to_name_end(char_u *arg, int use_namespace);
+char_u *to_name_const_end(char_u *arg);
+int get_lambda_tv_and_compile(char_u **arg, typval_T *rettv, int types_optional, evalarg_T *evalarg);
+exprtype_T get_compare_type(char_u *p, int *len, int *type_is);
+void skip_expr_cctx(char_u **arg, cctx_T *cctx);
+int bool_on_stack(cctx_T *cctx);
+void error_white_both(char_u *op, int len);
+int compile_expr1(char_u **arg, cctx_T *cctx, ppconst_T *ppconst);
+int compile_expr0_ext(char_u **arg, cctx_T *cctx, int *is_const);
+int compile_expr0(char_u **arg, cctx_T *cctx);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9instr.pro b/src/proto/vim9instr.pro
new file mode 100644
index 0000000..9372b1f
--- /dev/null
+++ b/src/proto/vim9instr.pro
@@ -0,0 +1,85 @@
+/* vim9instr.c */
+isn_T *generate_instr(cctx_T *cctx, isntype_T isn_type);
+isn_T *generate_instr_drop(cctx_T *cctx, isntype_T isn_type, int drop);
+isn_T *generate_instr_type(cctx_T *cctx, isntype_T isn_type, type_T *type);
+isn_T *generate_instr_debug(cctx_T *cctx);
+int generate_CONSTRUCT(cctx_T *cctx, class_T *cl);
+int generate_GET_OBJ_MEMBER(cctx_T *cctx, int idx, type_T *type);
+int generate_GET_ITF_MEMBER(cctx_T *cctx, class_T *itf, int idx, type_T *type);
+int generate_STORE_THIS(cctx_T *cctx, int idx);
+int may_generate_2STRING(int offset, int tolerant, cctx_T *cctx);
+int generate_add_instr(cctx_T *cctx, vartype_T vartype, type_T *type1, type_T *type2, exprtype_T expr_type);
+vartype_T operator_type(type_T *type1, type_T *type2);
+int generate_two_op(cctx_T *cctx, char_u *op);
+int check_compare_types(exprtype_T type, typval_T *tv1, typval_T *tv2);
+int generate_COMPARE(cctx_T *cctx, exprtype_T exprtype, int ic);
+int generate_CONCAT(cctx_T *cctx, int count);
+int generate_2BOOL(cctx_T *cctx, int invert, int offset);
+int generate_COND2BOOL(cctx_T *cctx);
+int generate_TYPECHECK(cctx_T *cctx, type_T *expected, int number_ok, int offset, int is_var, int argidx);
+int generate_SETTYPE(cctx_T *cctx, type_T *expected);
+int generate_tv_PUSH(cctx_T *cctx, typval_T *tv);
+int generate_PUSHNR(cctx_T *cctx, varnumber_T number);
+int generate_PUSHBOOL(cctx_T *cctx, varnumber_T number);
+int generate_PUSHSPEC(cctx_T *cctx, varnumber_T number);
+int generate_PUSHF(cctx_T *cctx, float_T fnumber);
+int generate_PUSHS(cctx_T *cctx, char_u **str);
+int generate_PUSHCHANNEL(cctx_T *cctx);
+int generate_PUSHJOB(cctx_T *cctx);
+int generate_PUSHBLOB(cctx_T *cctx, blob_T *blob);
+int generate_PUSHFUNC(cctx_T *cctx, char_u *name, type_T *type, int may_prefix);
+int generate_AUTOLOAD(cctx_T *cctx, char_u *name, type_T *type);
+int generate_GETITEM(cctx_T *cctx, int index, int with_op);
+int generate_SLICE(cctx_T *cctx, int count);
+int generate_CHECKLEN(cctx_T *cctx, int min_len, int more_OK);
+int generate_STORE(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name);
+int generate_CLASSMEMBER(cctx_T *cctx, int load, class_T *cl, int idx);
+int generate_STORENR(cctx_T *cctx, int idx, varnumber_T value);
+int generate_LOAD(cctx_T *cctx, isntype_T isn_type, int idx, char_u *name, type_T *type);
+int generate_LOADOUTER(cctx_T *cctx, int idx, int nesting, int loop_depth, int loop_idx, type_T *type);
+int generate_LOADV(cctx_T *cctx, char_u *name);
+int generate_UNLET(cctx_T *cctx, isntype_T isn_type, char_u *name, int forceit);
+int generate_LOCKCONST(cctx_T *cctx);
+int generate_OLDSCRIPT(cctx_T *cctx, isntype_T isn_type, char_u *name, int sid, type_T *type);
+int generate_VIM9SCRIPT(cctx_T *cctx, isntype_T isn_type, int sid, int idx, type_T *type);
+int generate_NEWLIST(cctx_T *cctx, int count, int use_null);
+int generate_NEWDICT(cctx_T *cctx, int count, int use_null);
+int generate_FUNCREF(cctx_T *cctx, ufunc_T *ufunc, class_T *cl, int fi, isn_T **isnp);
+int generate_NEWFUNC(cctx_T *cctx, char_u *lambda_name, char_u *func_name);
+int generate_DEF(cctx_T *cctx, char_u *name, size_t len);
+int generate_JUMP(cctx_T *cctx, jumpwhen_T when, int where);
+int generate_WHILE(cctx_T *cctx, int funcref_idx);
+int generate_JUMP_IF_ARG(cctx_T *cctx, isntype_T isn_type, int arg_off);
+int generate_FOR(cctx_T *cctx, int loop_idx);
+int generate_ENDLOOP(cctx_T *cctx, loop_info_T *loop_info);
+int generate_TRYCONT(cctx_T *cctx, int levels, int where);
+int check_internal_func_args(cctx_T *cctx, int func_idx, int argcount, int method_call, type2_T **argtypes, type2_T *shuffled_argtypes);
+int generate_BCALL(cctx_T *cctx, int func_idx, int argcount, int method_call);
+int generate_LISTAPPEND(cctx_T *cctx);
+int generate_BLOBAPPEND(cctx_T *cctx);
+int generate_CALL(cctx_T *cctx, ufunc_T *ufunc, class_T *cl, int mi, int pushed_argcount);
+int generate_UCALL(cctx_T *cctx, char_u *name, int argcount);
+int check_func_args_from_type(cctx_T *cctx, type_T *type, int argcount, int at_top, char_u *name);
+int generate_PCALL(cctx_T *cctx, int argcount, char_u *name, type_T *type, int at_top);
+int generate_DEFER(cctx_T *cctx, int var_idx, int obj_method, int argcount);
+int generate_STRINGMEMBER(cctx_T *cctx, char_u *name, size_t len);
+int generate_ECHO(cctx_T *cctx, int with_white, int count);
+int generate_MULT_EXPR(cctx_T *cctx, isntype_T isn_type, int count);
+int generate_ECHOWINDOW(cctx_T *cctx, int count, long time);
+int generate_SOURCE(cctx_T *cctx, int sid);
+int generate_PUT(cctx_T *cctx, int regname, linenr_T lnum);
+int generate_EXEC_copy(cctx_T *cctx, isntype_T isntype, char_u *line);
+int generate_EXEC(cctx_T *cctx, isntype_T isntype, char_u *str);
+int generate_LEGACY_EVAL(cctx_T *cctx, char_u *line);
+int generate_EXECCONCAT(cctx_T *cctx, int count);
+int generate_RANGE(cctx_T *cctx, char_u *range);
+int generate_UNPACK(cctx_T *cctx, int var_count, int semicolon);
+int generate_cmdmods(cctx_T *cctx, cmdmod_T *cmod);
+int generate_undo_cmdmods(cctx_T *cctx);
+int generate_store_var(cctx_T *cctx, assign_dest_T dest, int opt_flags, int vimvaridx, type_T *type, char_u *name, lhs_T *lhs);
+int inside_loop_scope(cctx_T *cctx);
+int generate_store_lhs(cctx_T *cctx, lhs_T *lhs, int instr_count, int is_decl);
+void may_generate_prof_end(cctx_T *cctx, int prof_lnum);
+void delete_instr(isn_T *isn);
+void clear_instr_ga(garray_T *gap);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9script.pro b/src/proto/vim9script.pro
new file mode 100644
index 0000000..9a0bcdf
--- /dev/null
+++ b/src/proto/vim9script.pro
@@ -0,0 +1,23 @@
+/* vim9script.c */
+int in_vim9script(void);
+int in_old_script(int max_version);
+int current_script_is_vim9(void);
+void clear_vim9_scriptlocal_vars(int sid);
+void ex_vim9script(exarg_T *eap);
+int not_in_vim9(exarg_T *eap);
+int vim9_bad_comment(char_u *p);
+int vim9_comment_start(char_u *p);
+void ex_incdec(exarg_T *eap);
+void ex_export(exarg_T *eap);
+void free_imports_and_script_vars(int sid);
+void mark_imports_for_reload(int sid);
+void ex_import(exarg_T *eap);
+void import_check_sourced_sid(int *sid);
+int find_exported(int sid, char_u *name, ufunc_T **ufunc, type_T **type, cctx_T *cctx, cstack_T *cstack, int verbose);
+char_u *vim9_declare_scriptvar(exarg_T *eap, char_u *arg);
+void update_vim9_script_var(int create, dictitem_T *di, char_u *name, int flags, typval_T *tv, type_T **type, int do_member);
+void hide_script_var(scriptitem_T *si, int idx, int func_defined);
+svar_T *find_typval_in_script(typval_T *dest, scid_T sid, int must_find);
+int check_script_var_type(svar_T *sv, typval_T *value, char_u *name, where_T where);
+int check_reserved_name(char_u *name, cctx_T *cctx);
+/* vim: set ft=c : */
diff --git a/src/proto/vim9type.pro b/src/proto/vim9type.pro
new file mode 100644
index 0000000..d5e4d48
--- /dev/null
+++ b/src/proto/vim9type.pro
@@ -0,0 +1,38 @@
+/* vim9type.c */
+type_T *get_type_ptr(garray_T *type_gap);
+type_T *copy_type(type_T *type, garray_T *type_gap);
+void clear_type_list(garray_T *gap);
+type_T *alloc_type(type_T *type);
+void free_type(type_T *type);
+void set_tv_type(typval_T *tv, type_T *type);
+type_T *get_list_type(type_T *member_type, garray_T *type_gap);
+type_T *get_dict_type(type_T *member_type, garray_T *type_gap);
+type_T *alloc_func_type(type_T *ret_type, int argcount, garray_T *type_gap);
+type_T *get_func_type(type_T *ret_type, int argcount, garray_T *type_gap);
+int func_type_add_arg_types(type_T *functype, int argcount, garray_T *type_gap);
+int type_any_or_unknown(type_T *type);
+int need_convert_to_bool(type_T *type, typval_T *tv);
+type_T *typval2type(typval_T *tv, int copyID, garray_T *type_gap, int flags);
+int valid_declaration_type(type_T *type);
+type_T *typval2type_vimvar(typval_T *tv, garray_T *type_gap);
+int check_typval_arg_type(type_T *expected, typval_T *actual_tv, char *func_name, int arg_idx);
+int check_typval_type(type_T *expected, typval_T *actual_tv, where_T where);
+void arg_type_mismatch(type_T *expected, type_T *actual, int arg_idx);
+void type_mismatch_where(type_T *expected, type_T *actual, where_T where);
+int check_type(type_T *expected, type_T *actual, int give_msg, where_T where);
+int check_type_maybe(type_T *expected, type_T *actual, int give_msg, where_T where);
+int check_argument_types(type_T *type, typval_T *argvars, int argcount, typval_T *base_tv, char_u *name);
+char_u *skip_type(char_u *start, int optional);
+type_T *parse_type(char_u **arg, garray_T *type_gap, int give_error);
+int equal_type(type_T *type1, type_T *type2, int flags);
+void common_type(type_T *type1, type_T *type2, type_T **dest, garray_T *type_gap);
+int push_type_stack(cctx_T *cctx, type_T *type);
+int push_type_stack2(cctx_T *cctx, type_T *type, type_T *decl_type);
+void set_type_on_stack(cctx_T *cctx, type_T *type, int offset);
+type_T *get_type_on_stack(cctx_T *cctx, int offset);
+type_T *get_decl_type_on_stack(cctx_T *cctx, int offset);
+type_T *get_member_type_from_stack(int count, int skip, cctx_T *cctx);
+char *vartype_name(vartype_T type);
+char *type_name(type_T *type, char **tofree);
+void f_typename(typval_T *argvars, typval_T *rettv);
+/* vim: set ft=c : */
diff --git a/src/proto/viminfo.pro b/src/proto/viminfo.pro
new file mode 100644
index 0000000..c33af5f
--- /dev/null
+++ b/src/proto/viminfo.pro
@@ -0,0 +1,8 @@
+/* viminfo.c */
+int get_viminfo_parameter(int type);
+int buf_compare(const void *s1, const void *s2);
+void check_marks_read(void);
+int read_viminfo(char_u *file, int flags);
+void write_viminfo(char_u *file, int forceit);
+void ex_viminfo(exarg_T *eap);
+/* vim: set ft=c : */
diff --git a/src/proto/winclip.pro b/src/proto/winclip.pro
new file mode 100644
index 0000000..c7cba71
--- /dev/null
+++ b/src/proto/winclip.pro
@@ -0,0 +1,15 @@
+/* winclip.c */
+int utf8_to_utf16(char_u *instr, int inlen, short_u *outstr, int *unconvlenp);
+int utf16_to_utf8(short_u *instr, int inlen, char_u *outstr);
+void MultiByteToWideChar_alloc(UINT cp, DWORD flags, LPCSTR in, int inlen, LPWSTR *out, int *outlen);
+void WideCharToMultiByte_alloc(UINT cp, DWORD flags, LPCWSTR in, int inlen, LPSTR *out, int *outlen, LPCSTR def, LPBOOL useddef);
+void win_clip_init(void);
+int clip_mch_own_selection(Clipboard_T *cbd);
+void clip_mch_lose_selection(Clipboard_T *cbd);
+void clip_mch_request_selection(Clipboard_T *cbd);
+void clip_mch_set_selection(Clipboard_T *cbd);
+short_u *enc_to_utf16(char_u *str, int *lenp);
+char_u *utf16_to_enc(short_u *str, int *lenp);
+void acp_to_enc(char_u *str, int str_size, char_u **out, int *outlen);
+void enc_to_acp(char_u *str, int str_size, char_u **out, int *outlen);
+/* vim: set ft=c : */
diff --git a/src/proto/window.pro b/src/proto/window.pro
new file mode 100644
index 0000000..6522466
--- /dev/null
+++ b/src/proto/window.pro
@@ -0,0 +1,93 @@
+/* window.c */
+int window_layout_locked(enum CMD_index cmd);
+win_T *prevwin_curwin(void);
+void do_window(int nchar, long Prenum, int xchar);
+void get_wincmd_addr_type(char_u *arg, exarg_T *eap);
+int win_split(int size, int flags);
+int win_split_ins(int size, int flags, win_T *new_wp, int dir);
+int win_valid_popup(win_T *win);
+int win_valid(win_T *win);
+win_T *win_find_by_id(int id);
+int win_valid_any_tab(win_T *win);
+int win_count(void);
+int make_windows(int count, int vertical);
+void win_move_after(win_T *win1, win_T *win2);
+void win_equal(win_T *next_curwin, int current, int dir);
+void entering_window(win_T *win);
+void curwin_init(void);
+void close_windows(buf_T *buf, int keep_curwin);
+int one_window(void);
+int win_close(win_T *win, int free_buf);
+void snapshot_windows_scroll_size(void);
+void may_make_initial_scroll_size_snapshot(void);
+void may_trigger_win_scrolled_resized(void);
+void win_close_othertab(win_T *win, int free_buf, tabpage_T *tp);
+void win_free_all(void);
+win_T *winframe_remove(win_T *win, int *dirp, tabpage_T *tp);
+void close_others(int message, int forceit);
+void unuse_tabpage(tabpage_T *tp);
+void use_tabpage(tabpage_T *tp);
+int win_alloc_first(void);
+win_T *win_alloc_popup_win(void);
+void win_init_popup_win(win_T *wp, buf_T *buf);
+void win_init_size(void);
+void free_tabpage(tabpage_T *tp);
+int win_new_tabpage(int after);
+int make_tabpages(int maxcount);
+int valid_tabpage(tabpage_T *tpc);
+int valid_tabpage_win(tabpage_T *tpc);
+void close_tabpage(tabpage_T *tab);
+tabpage_T *find_tabpage(int n);
+int tabpage_index(tabpage_T *ftp);
+void goto_tabpage(int n);
+void goto_tabpage_tp(tabpage_T *tp, int trigger_enter_autocmds, int trigger_leave_autocmds);
+int goto_tabpage_lastused(void);
+void goto_tabpage_win(tabpage_T *tp, win_T *wp);
+void tabpage_move(int nr);
+void win_goto(win_T *wp);
+win_T *win_find_nr(int winnr);
+tabpage_T *win_find_tabpage(win_T *win);
+win_T *win_vert_neighbor(tabpage_T *tp, win_T *wp, int up, long count);
+win_T *win_horz_neighbor(tabpage_T *tp, win_T *wp, int left, long count);
+void win_enter(win_T *wp, int undo_sync);
+win_T *buf_jump_open_win(buf_T *buf);
+win_T *buf_jump_open_tab(buf_T *buf);
+int win_unlisted(win_T *wp);
+void win_free_popup(win_T *win);
+void win_remove(win_T *wp, tabpage_T *tp);
+int win_alloc_lines(win_T *wp);
+void win_free_lsize(win_T *wp);
+void shell_new_rows(void);
+void shell_new_columns(void);
+void win_size_save(garray_T *gap);
+void win_size_restore(garray_T *gap);
+int win_comp_pos(void);
+void win_ensure_size(void);
+void win_setheight(int height);
+void win_setheight_win(int height, win_T *win);
+void win_setwidth(int width);
+void win_setwidth_win(int width, win_T *wp);
+void win_setminheight(void);
+void win_setminwidth(void);
+void win_drag_status_line(win_T *dragwin, int offset);
+void win_drag_vsep_line(win_T *dragwin, int offset);
+void set_fraction(win_T *wp);
+void win_new_height(win_T *wp, int height);
+void scroll_to_fraction(win_T *wp, int prev_height);
+void win_new_width(win_T *wp, int width);
+void win_comp_scroll(win_T *wp);
+void command_height(void);
+void last_status(int morewin);
+int tabline_height(void);
+int min_rows(void);
+int only_one_window(void);
+void check_lnums(int do_curwin);
+void check_lnums_nested(int do_curwin);
+void reset_lnums(void);
+void make_snapshot(int idx);
+void restore_snapshot(int idx, int close_curwin);
+int win_hasvertsplit(void);
+int get_win_number(win_T *wp, win_T *first_win);
+int get_tab_number(tabpage_T *tp);
+char *check_colorcolumn(win_T *wp);
+/* vim: set ft=c : */