diff options
Diffstat (limited to 'src/proto')
98 files changed, 3881 insertions, 0 deletions
diff --git a/src/proto/arabic.pro b/src/proto/arabic.pro new file mode 100644 index 0000000..a004ef9 --- /dev/null +++ b/src/proto/arabic.pro @@ -0,0 +1,3 @@ +/* arabic.c */ +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/autocmd.pro b/src/proto/autocmd.pro new file mode 100644 index 0000000..8c6d18f --- /dev/null +++ b/src/proto/autocmd.pro @@ -0,0 +1,39 @@ +/* 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 free_all_autocmds(void); +int check_ei(void); +char_u *au_event_disable(char *what); +void au_event_restore(char_u *old_ei); +void do_autocmd(char_u *arg_in, int forceit); +int do_doautocmd(char_u *arg, 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 has_cursorhold(void); +int trigger_cursorhold(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_funcundefined(void); +int has_textyankpost(void); +void block_autocmds(void); +void unblock_autocmds(void); +int is_autocmd_blocked(void); +char_u *getnextac(int c, void *cookie, int indent); +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); +/* vim: set ft=c : */ diff --git a/src/proto/beval.pro b/src/proto/beval.pro new file mode 100644 index 0000000..2be64a0 --- /dev/null +++ b/src/proto/beval.pro @@ -0,0 +1,6 @@ +/* beval.c */ +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..019692d --- /dev/null +++ b/src/proto/blob.pro @@ -0,0 +1,16 @@ +/* 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(typval_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 *b, int idx, char_u c); +int blob_equal(blob_T *b1, blob_T *b2); +int read_blob(FILE *fd, blob_T *blob); +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); +/* vim: set ft=c : */ diff --git a/src/proto/blowfish.pro b/src/proto/blowfish.pro new file mode 100644 index 0000000..d959846 --- /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); +void crypt_blowfish_decode(cryptstate_T *state, char_u *from, size_t len, char_u *to); +void 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..5e1aa7a --- /dev/null +++ b/src/proto/buffer.pro @@ -0,0 +1,75 @@ +/* buffer.c */ +int open_buffer(int read_stdin, exarg_T *eap, int flags); +void set_bufref(bufref_T *bufref, buf_T *buf); +int bufref_valid(bufref_T *bufref); +int buf_valid(buf_T *buf); +void close_buffer(win_T *win, buf_T *buf, int action, int abort_if_last); +void buf_clear_file(buf_T *buf); +void buf_freeall(buf_T *buf, int flags); +void goto_buffer(exarg_T *eap, int start, int dir, int count); +void handle_swap_exists(bufref_T *old_curbuf); +char *do_bufdel(int command, char_u *arg, int addr_count, int start_bnr, int end_bnr, int forceit); +int do_buffer(int action, int start, int dir, int count, int forceit); +void set_curbuf(buf_T *buf, int action); +void enter_buffer(buf_T *buf); +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); +void buflist_getfpos(void); +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 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, int use_sandbox, int fillchar, int maxwidth, struct stl_hlrec *hltab, struct stl_hlrec *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); +char_u *alist_name(aentry_T *aep); +void do_arg_all(int count, int forceit, int keep_tabs); +void ex_buffer_all(exarg_T *eap); +void do_modelines(int flags); +int read_viminfo_bufferlist(vir_T *virp, int writing); +void write_viminfo_bufferlist(FILE *fp); +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_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); +void switch_to_win_for_buf(buf_T *buf, win_T **save_curwinp, tabpage_T **save_curtabp, bufref_T *save_curbuf); +void restore_win_for_buf(win_T *save_curwin, tabpage_T *save_curtab, bufref_T *save_curbuf); +int find_win_for_buf(buf_T *buf, win_T **wp, tabpage_T **tp); +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/channel.pro b/src/proto/channel.pro new file mode 100644 index 0000000..0f5b655 --- /dev/null +++ b/src/proto/channel.pro @@ -0,0 +1,76 @@ +/* channel.c */ +void ch_logfile(char_u *fname, char_u *opt); +int ch_log_active(void); +channel_T *add_channel(void); +int has_any_channel(void); +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(char *hostname, int port_in, int waittime, void (*nb_close_cb)(void)); +channel_T *channel_open_func(typval_T *argvars); +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_set_options(channel_T *channel, jobopt_T *opt); +void channel_set_req_callback(channel_T *channel, ch_part_T part, char_u *callback, partial_T *partial, int id); +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); +int channel_has_readahead(channel_T *channel, ch_part_T part); +char *channel_status(channel_T *channel, int req_part); +void channel_info(channel_T *channel, dict_T *dict); +void channel_close(channel_T *channel, int invoke_close_cb); +void channel_close_in(channel_T *channel); +void channel_clear(channel_T *channel); +void channel_free_all(void); +void common_channel_read(typval_T *argvars, typval_T *rettv, int raw, int blob); +channel_T *channel_fd2channel(sock_T fd, ch_part_T *partp); +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); +void ch_expr_common(typval_T *argvars, typval_T *rettv, int eval); +void ch_raw_common(typval_T *argvars, typval_T *rettv, int eval); +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); +ch_part_T channel_part_send(channel_T *channel); +ch_part_T channel_part_read(channel_T *channel); +ch_mode_T channel_get_mode(channel_T *channel, ch_part_T part); +int channel_get_timeout(channel_T *channel, ch_part_T part); +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); +channel_T *get_channel_arg(typval_T *tv, int check_open, int reading, ch_part_T part); +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, int is_terminal); +char *job_status(job_T *job); +void job_info(job_T *job, dict_T *dict); +void job_info_all(list_T *l); +int job_stop(job_T *job, typval_T *argvars, char *type); +void invoke_prompt_callback(void); +int invoke_prompt_interrupt(void); +/* vim: set ft=c : */ diff --git a/src/proto/charset.pro b/src/proto/charset.pro new file mode 100644 index 0000000..bb4132f --- /dev/null +++ b/src/proto/charset.pro @@ -0,0 +1,64 @@ +/* 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_byte(int c); +void transchar_nonprint(char_u *buf, 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(char_u *s); +int linetabsize_col(int startcol, char_u *s); +int win_linetabsize(win_T *wp, char_u *line, colnr_T len); +int vim_isIDc(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_isfilec_or_wc(int c); +int vim_isprintc(int c); +int vim_isprintc_strict(int c); +int lbr_chartabsize(char_u *line, unsigned char *s, colnr_T col); +int lbr_chartabsize_adv(char_u *line, char_u **s, colnr_T col); +int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *headp); +int in_win_border(win_T *wp, colnr_T vcol); +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); +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_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); +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 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); +void ebcdic2ascii(char_u *buffer, int len); +/* vim: set ft=c : */ diff --git a/src/proto/crypt.pro b/src/proto/crypt.pro new file mode 100644 index 0000000..e8ba188 --- /dev/null +++ b/src/proto/crypt.pro @@ -0,0 +1,22 @@ +/* crypt.c */ +int crypt_method_nr_from_name(char_u *name); +int crypt_method_nr_from_magic(char *ptr, int len); +int crypt_get_method_nr(buf_T *buf); +int crypt_whole_undofile(int method_nr); +int crypt_get_header_len(int method_nr); +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); +void crypt_encode(cryptstate_T *state, char_u *from, size_t len, char_u *to); +void crypt_encode_inplace(cryptstate_T *state, char_u *buf, size_t len); +void crypt_decode_inplace(cryptstate_T *state, char_u *buf, size_t len); +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); +/* vim: set ft=c : */ diff --git a/src/proto/crypt_zip.pro b/src/proto/crypt_zip.pro new file mode 100644 index 0000000..74784e1 --- /dev/null +++ b/src/proto/crypt_zip.pro @@ -0,0 +1,5 @@ +/* crypt_zip.c */ +void 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); +void crypt_zip_decode(cryptstate_T *state, char_u *from, size_t len, char_u *to); +/* vim: set ft=c : */ diff --git a/src/proto/dict.pro b/src/proto/dict.pro new file mode 100644 index 0000000..b09a647 --- /dev/null +++ b/src/proto/dict.pro @@ -0,0 +1,32 @@ +/* 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 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); +void dictitem_free(dictitem_T *item); +dict_T *dict_copy(dict_T *orig, int deep, int copyID); +int dict_add(dict_T *d, dictitem_T *item); +int dict_add_number(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_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); +char_u *dict_get_string(dict_T *d, char_u *key, int save); +varnumber_T dict_get_number(dict_T *d, char_u *key); +char_u *dict2string(typval_T *tv, int copyID, int restore_copyID); +int dict_get_tv(char_u **arg, typval_T *rettv, int evaluate); +void dict_extend(dict_T *d1, dict_T *d2, char_u *action); +dictitem_T *dict_lookup(hashitem_T *hi); +int dict_equal(dict_T *d1, dict_T *d2, int ic, int recursive); +void dict_list(typval_T *argvars, typval_T *rettv, int what); +void dict_set_items_ro(dict_T *di); +/* vim: set ft=c : */ diff --git a/src/proto/diff.pro b/src/proto/diff.pro new file mode 100644 index 0000000..d6ab221 --- /dev/null +++ b/src/proto/diff.pro @@ -0,0 +1,29 @@ +/* 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); +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 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); +/* vim: set ft=c : */ diff --git a/src/proto/digraph.pro b/src/proto/digraph.pro new file mode 100644 index 0000000..06b3341 --- /dev/null +++ b/src/proto/digraph.pro @@ -0,0 +1,11 @@ +/* digraph.c */ +int do_digraph(int c); +char_u *get_digraph_for_char(int val_arg); +int get_digraph(int cmdline); +int getdigraph(int char1, int char2, int meta_char); +void putdigraph(char_u *str); +void listdigraphs(int use_headers); +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/edit.pro b/src/proto/edit.pro new file mode 100644 index 0000000..3a1573f --- /dev/null +++ b/src/proto/edit.pro @@ -0,0 +1,47 @@ +/* edit.c */ +int edit(int cmdchar, int startln, long count); +void edit_putchar(int c, int highlight); +char_u *prompt_text(void); +int prompt_curpos_editable(void); +void edit_unputchar(void); +void display_dollar(colnr_T col); +void change_indent(int type, int amount, int round, int replaced, int call_changed_bytes); +void truncate_spaces(char_u *line); +void backspace_until_column(int col); +int ctrl_x_mode_not_default(void); +int ctrl_x_mode_not_defined_yet(void); +int vim_is_ctrl_x_key(int c); +int ins_compl_add_infercase(char_u *str, int len, int icase, char_u *fname, int dir, int flags); +void completeopt_was_set(void); +void set_completion(colnr_T startcol, list_T *list); +void ins_compl_show_pum(void); +char_u *find_word_start(char_u *ptr); +char_u *find_word_end(char_u *ptr); +int ins_compl_active(void); +int ins_compl_add_tv(typval_T *tv, int dir); +void ins_compl_check_keys(int frequency, int in_compl_func); +int get_literal(void); +void insertchar(int c, int flags, int second_indent); +void auto_format(int trailblank, int prev_line); +int comp_textwidth(int ff); +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); +int cursor_up(long n, int upd_topline); +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); +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_copychar(linenr_T lnum); +colnr_T get_nolist_virtcol(void); +/* vim: set ft=c : */ diff --git a/src/proto/eval.pro b/src/proto/eval.pro new file mode 100644 index 0000000..1e673e3 --- /dev/null +++ b/src/proto/eval.pro @@ -0,0 +1,144 @@ +/* eval.c */ +void eval_init(void); +void eval_clear(void); +void set_internal_string_var(char_u *name, char_u *value); +int var_redir_start(char_u *name, int append); +void var_redir_str(char_u *value, int value_len); +void var_redir_stop(void); +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); +int eval_to_bool(char_u *arg, int *error, char_u **nextcmd, int skip); +int eval_expr_to_bool(typval_T *expr, int *error); +char_u *eval_to_string_skip(char_u *arg, char_u **nextcmd, int skip); +int skip_expr(char_u **pp); +char_u *eval_to_string(char_u *arg, char_u **nextcmd, int convert); +char_u *eval_to_string_safe(char_u *arg, char_u **nextcmd, int use_sandbox); +varnumber_T eval_to_number(char_u *expr); +list_T *eval_spell_expr(char_u *badword, char_u *expr); +int get_spellword(list_T *list, char_u **pp); +typval_T *eval_expr(char_u *arg, char_u **nextcmd); +int call_vim_function(char_u *func, int argc, typval_T *argv, typval_T *rettv); +varnumber_T call_func_retnr(char_u *func, int argc, typval_T *argv); +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(char_u *arg, int *cp); +void ex_let(exarg_T *eap); +void list_hashtable_vars(hashtab_T *ht, char *prefix, int empty, int *first); +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 *eval_for_line(char_u *arg, int *errp, char_u **nextcmdp, int skip); +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); +void ex_unlet(exarg_T *eap); +void ex_lockvar(exarg_T *eap); +int do_unlet(char_u *name, int forceit); +void del_menutrans_vars(void); +char_u *get_user_var_name(expand_T *xp, int idx); +int eval0(char_u *arg, typval_T *rettv, char_u **nextcmd, int evaluate); +int eval1(char_u **arg, typval_T *rettv, int evaluate); +int get_option_tv(char_u **arg, typval_T *rettv, int evaluate); +char_u *partial_name(partial_T *pt); +void partial_unref(partial_T *pt); +int tv_equal(typval_T *tv1, typval_T *tv2, int ic, int recursive); +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_list(list_T *l, int copyID, ht_stack_T **ht_stack); +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); +char_u *tv2string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID); +char_u *string_quote(char_u *str, int function); +int string2float(char_u *text, float_T *value); +pos_T *var2fpos(typval_T *varp, int dollar_lnum, int *fnum); +int list2fpos(typval_T *arg, pos_T *posp, int *fnump, colnr_T *curswantp); +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); +void set_vim_var_nr(int idx, varnumber_T val); +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_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 get_var_tv(char_u *name, int len, typval_T *rettv, dictitem_T **dip, int verbose, int no_autoload); +int handle_subscript(char_u **arg, typval_T *rettv, int evaluate, int verbose); +typval_T *alloc_tv(void); +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); +float_T tv_get_float(typval_T *varp); +char_u *tv_get_string(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_stringify(typval_T *varp, char_u *buf); +dictitem_T *find_var(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 *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 set_var(char_u *name, typval_T *tv, int copy); +int var_check_ro(int flags, char_u *name, int use_gettext); +int var_check_fixed(int flags, char_u *name, int use_gettext); +int var_check_func_name(char_u *name, int new_var); +int valid_varname(char_u *varname); +int tv_check_lock(int lock, char_u *name, int use_gettext); +void copy_tv(typval_T *from, typval_T *to); +int item_copy(typval_T *from, typval_T *to, int deep, int copyID); +void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog, int secret); +void ex_echo(exarg_T *eap); +void ex_echohl(exarg_T *eap); +void ex_execute(exarg_T *eap); +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); +void getwinvar(typval_T *argvars, typval_T *rettv, int off); +void setwinvar(typval_T *argvars, typval_T *rettv, int off); +char_u *autoload_name(char_u *name); +int script_autoload(char_u *name, int reload); +int read_viminfo_varlist(vir_T *virp, int writing); +void write_viminfo_varlist(FILE *fp); +int store_session_globals(FILE *fd); +void last_set_msg(sctx_T script_ctx); +void reset_v_option_vars(void); +void prepare_assert_error(garray_T *gap); +void assert_error(garray_T *gap); +int assert_equal_common(typval_T *argvars, assert_type_T atype); +int assert_equalfile(typval_T *argvars); +int assert_match_common(typval_T *argvars, assert_type_T atype); +int assert_inrange(typval_T *argvars); +int assert_bool(typval_T *argvars, int isTrue); +int assert_report(typval_T *argvars); +int assert_exception(typval_T *argvars); +int assert_beeps(typval_T *argvars); +int assert_fails(typval_T *argvars); +void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char_u *exp_str, typval_T *exp_tv, typval_T *got_tv, assert_type_T atype); +int typval_compare(typval_T *typ1, typval_T *typ2, exptype_T type, int type_is, int ic); +char_u *typval_tostring(typval_T *arg); +int var_exists(char_u *var); +int modify_fname(char_u *src, int tilde_file, int *usedlen, char_u **fnamep, char_u **bufp, int *fnamelen); +char_u *do_string_sub(char_u *str, char_u *pat, char_u *sub, typval_T *expr, char_u *flags); +void filter_map(typval_T *argvars, typval_T *rettv, int map); +/* vim: set ft=c : */ diff --git a/src/proto/evalfunc.pro b/src/proto/evalfunc.pro new file mode 100644 index 0000000..c0ada9d --- /dev/null +++ b/src/proto/evalfunc.pro @@ -0,0 +1,15 @@ +/* evalfunc.c */ +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 call_internal_func(char_u *name, int argcount, typval_T *argvars, typval_T *rettv); +buf_T *buflist_find_by_name(char_u *name, int curtab_only); +buf_T *tv_get_buf(typval_T *tv, int curtab_only); +void execute_redir_str(char_u *value, int value_len); +void mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv); +float_T vim_round(float_T f); +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); +void f_string(typval_T *argvars, typval_T *rettv); +char_u *get_callback(typval_T *arg, partial_T **pp); +void free_callback(char_u *callback, partial_T *partial); +/* vim: set ft=c : */ diff --git a/src/proto/ex_cmds.pro b/src/proto/ex_cmds.pro new file mode 100644 index 0000000..c769b4b --- /dev/null +++ b/src/proto/ex_cmds.pro @@ -0,0 +1,61 @@ +/* ex_cmds.c */ +void do_ascii(exarg_T *eap); +void ex_align(exarg_T *eap); +void ex_sort(exarg_T *eap); +void ex_retab(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); +int viminfo_error(char *errnum, char *message, char_u *line); +int read_viminfo(char_u *file, int flags); +void write_viminfo(char_u *file, int forceit); +int viminfo_readline(vir_T *virp); +char_u *viminfo_readstring(vir_T *virp, int off, int convert); +void viminfo_writestring(FILE *fd, char_u *p); +int barline_writestring(FILE *fd, char_u *s, int remaining_start); +time_T vim_time(void); +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 not_writing(void); +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); +void do_sub(exarg_T *eap); +int do_sub_msg(int count_only); +void ex_global(exarg_T *eap); +void global_exe(char_u *cmd); +int read_viminfo_sub_string(vir_T *virp, int force); +void write_viminfo_sub_string(FILE *fp); +void free_old_sub(void); +int prepare_tagpreview(int undo_sync); +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 fix_help_buffer(void); +void ex_exusage(exarg_T *eap); +void ex_viusage(exarg_T *eap); +void ex_helptags(exarg_T *eap); +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); +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..ac9b291 --- /dev/null +++ b/src/proto/ex_cmds2.pro @@ -0,0 +1,112 @@ +/* ex_cmds2.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); +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); +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); +long proftime_time_left(proftime_T *due, proftime_T *now); +timer_T *create_timer(long msec, int repeat); +long check_due_timer(void); +timer_T *find_timer(long id); +void stop_timer(timer_T *timer); +void stop_all_timers(void); +void add_timer_info(typval_T *rettv, timer_T *timer); +void add_timer_info_all(typval_T *rettv); +int set_ref_in_timer(int copyID); +void timer_free_all(void); +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_get_wait(proftime_T *tm); +void profile_sub_wait(proftime_T *tm, proftime_T *tma); +int profile_equal(proftime_T *tm1, proftime_T *tm2); +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 profile_dump(void); +void script_prof_save(proftime_T *tm); +void script_prof_restore(proftime_T *tm); +void prof_inchar_enter(void); +void prof_inchar_exit(void); +int prof_def_func(void); +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); +int get_arglist_exp(char_u *str, int *fcountp, char_u ***fnamesp, int wig); +void set_arglist(char_u *str); +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_argedit(exarg_T *eap); +void ex_argadd(exarg_T *eap); +void ex_argdelete(exarg_T *eap); +void ex_listdo(exarg_T *eap); +char_u *get_arglist_name(expand_T *xp, int idx); +void ex_compiler(exarg_T *eap); +void ex_runtime(exarg_T *eap); +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); +void add_pack_start_dirs(void); +void load_start_packages(void); +void ex_packloadall(exarg_T *eap); +void ex_packadd(exarg_T *eap); +void ex_options(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_source(exarg_T *eap); +linenr_T *source_breakpoint(void *cookie); +int *source_dbg_tick(void *cookie); +int source_level(void *cookie); +int do_source(char_u *fname, int check_other, int is_vimrc); +void ex_scriptnames(exarg_T *eap); +void scriptnames_slash_adjust(void); +char_u *get_scriptname(scid_T id); +void free_scriptnames(void); +char *fgets_cr(char *s, int n, FILE *stream); +char_u *getsourceline(int c, void *cookie, int indent); +void script_line_start(void); +void script_line_exec(void); +void script_line_end(void); +void ex_scriptencoding(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), void *cookie); +void ex_checktime(exarg_T *eap); +char_u *get_mess_lang(void); +void set_lang_var(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/ex_docmd.pro b/src/proto/ex_docmd.pro new file mode 100644 index 0000000..8f3852a --- /dev/null +++ b/src/proto/ex_docmd.pro @@ -0,0 +1,76 @@ +/* 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), void *cookie, int flags); +int getline_equal(char_u *(*fgetline)(int, void *, int), void *cookie, char_u *(*func)(int, void *, int)); +void *getline_cookie(char_u *(*fgetline)(int, void *, int), void *cookie); +int parse_command_modifiers(exarg_T *eap, char **errormsg, int skip_only); +int parse_cmd_address(exarg_T *eap, char **errormsg, int silent); +int checkforcmd(char_u **pp, char *cmd, int len); +int modifier_len(char_u *cmd); +int cmd_exists(char_u *name); +char_u *set_one_cmd_context(expand_T *xp, char_u *buff); +char_u *skip_range(char_u *cmd, 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 get_bad_opt(char_u *p, exarg_T *eap); +int ends_excmd(int c); +char_u *find_nextcmd(char_u *p); +char_u *check_nextcmd(char_u *p); +char_u *get_command_name(expand_T *xp, int idx); +void ex_comclear(exarg_T *eap); +void uc_clear(garray_T *gap); +char_u *get_user_commands(expand_T *xp, int idx); +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); +int parse_addr_type_arg(char_u *value, int vallen, long *argt, int *addr_type_arg); +int parse_compl_arg(char_u *value, int vallen, int *complp, long *argt, char_u **compl_arg); +int cmdcomplete_str_to_type(char_u *complete_str); +void not_exiting(void); +void tabpage_close(int forceit); +void tabpage_close_other(tabpage_T *tp, int forceit); +void ex_all(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 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); +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(int local); +void ex_cd(exarg_T *eap); +void do_sleep(long msec); +void ex_may_print(exarg_T *eap); +void ex_redraw(exarg_T *eap); +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); +char_u *expand_sfile(char_u *arg); +int put_eol(FILE *fd); +int put_line(FILE *fd, char *s); +void dialog_msg(char_u *buff, char *format, char_u *fname); +char_u *get_behave_arg(expand_T *xp, int idx); +char_u *get_messages_arg(expand_T *xp, int idx); +char_u *get_mapclear_arg(expand_T *xp, int idx); +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..34301e2 --- /dev/null +++ b/src/proto/ex_eval.pro @@ -0,0 +1,34 @@ +/* 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(struct condstack *cstack, char_u *cmdname); +int do_intthrow(struct condstack *cstack); +char *get_exception_string(void *value, except_type_T type, char_u *cmdname, int *should_free); +void discard_current_exception(void); +void report_make_pending(int pending, void *value); +void report_resume_pending(int pending, void *value); +void report_discard_pending(int pending, void *value); +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_throw(exarg_T *eap); +void do_throw(struct condstack *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(struct condstack *cstack, int searched_cond, int inclusive); +void rewind_conditionals(struct condstack *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..298c630 --- /dev/null +++ b/src/proto/ex_getln.pro @@ -0,0 +1,60 @@ +/* ex_getln.c */ +void cmdline_init(void); +char_u *getcmdline(int firstc, long count, int indent); +char_u *getcmdline_prompt(int firstc, char_u *prompt, int attr, int xp_context, char_u *xp_arg); +int text_locked(void); +void text_locked_msg(void); +char *get_text_locked_msg(void); +int curbuf_locked(void); +int allbuf_locked(void); +char_u *getexline(int c, void *cookie, int indent); +char_u *getexmodeline(int promptc, void *cookie, int indent); +int cmdline_overstrike(void); +int cmdline_at_end(void); +colnr_T cmdline_getvcol_cursor(void); +void free_cmdline_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 gotocmdline(int clr); +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); +void ExpandEscape(expand_T *xp, char_u *str, int numfiles, char_u **files, int options); +char_u *vim_strsave_fnameescape(char_u *fname, int shell); +void tilde_replace(char_u *orig_pat, int num_files, char_u **files); +char_u *sm_gettail(char_u *s); +char_u *addstar(char_u *fname, int len, int context); +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); +int ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, char_u ***file, char_u *((*func)(expand_T *, int)), int escaped); +void globpath(char_u *path, char_u *file, garray_T *ga, int expand_options); +void init_history(void); +int get_histtype(char_u *name); +void add_to_history(int histype, char_u *new_entry, int in_map, int sep); +int get_history_idx(int histype); +char_u *get_history_entry(int histype, int idx); +int clr_history(int histype); +int del_history_entry(int histype, char_u *str); +int del_history_idx(int histype, int idx); +void remove_key_from_history(void); +char_u *get_cmdline_str(void); +int get_cmdline_pos(void); +int set_cmdline_pos(int pos); +int get_cmdline_type(void); +int get_list_range(char_u **str, int *num1, int *num2); +void ex_history(exarg_T *eap); +void prepare_viminfo_history(int asklen, int writing); +int read_viminfo_history(vir_T *virp, int writing); +void handle_viminfo_history(garray_T *values, int writing); +void finish_viminfo_history(vir_T *virp); +void write_viminfo_history(FILE *fp, int merge); +void cmd_pchar(int c, int offset); +int cmd_gchar(int offset); +char_u *script_get(exarg_T *eap, char_u *cmd); +/* vim: set ft=c : */ diff --git a/src/proto/farsi.pro b/src/proto/farsi.pro new file mode 100644 index 0000000..b6e1836 --- /dev/null +++ b/src/proto/farsi.pro @@ -0,0 +1,12 @@ +/* farsi.c */ +int fkmap(int c); +char_u *lrswap(char_u *ibuf); +char_u *lrFswap(char_u *cmdbuf, int len); +char_u *lrF_sub(char_u *ibuf); +int cmdl_fkmap(int c); +int F_isalpha(int c); +int F_isdigit(int c); +int F_ischar(int c); +void farsi_f8(cmdarg_T *cap); +void farsi_f9(cmdarg_T *cap); +/* vim: set ft=c : */ diff --git a/src/proto/fileio.pro b/src/proto/fileio.pro new file mode 100644 index 0000000..21ac55c --- /dev/null +++ b/src/proto/fileio.pro @@ -0,0 +1,36 @@ +/* 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 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); +void msg_add_fname(buf_T *buf, char_u *fname); +void msg_add_lines(int insert_space, long lnum, off_T nchars); +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 tag_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); +void buf_store_time(buf_T *buf, stat_T *st, char_u *fname); +void write_lnum_adjust(linenr_T offset); +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/fold.pro b/src/proto/fold.pro new file mode 100644 index 0000000..d8e3494 --- /dev/null +++ b/src/proto/fold.pro @@ -0,0 +1,42 @@ +/* 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 foldLevel(linenr_T lnum); +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 foldtext_cleanup(char_u *str); +void foldMoveRange(garray_T *gap, linenr_T line1, linenr_T line2, linenr_T dest); +int put_folds(FILE *fd, win_T *wp); +/* vim: set ft=c : */ diff --git a/src/proto/getchar.pro b/src/proto/getchar.pro new file mode 100644 index 0000000..0733662 --- /dev/null +++ b/src/proto/getchar.pro @@ -0,0 +1,70 @@ +/* getchar.c */ +void free_buff(buffheader_T *buf); +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 stuffReadbuffLen(char_u *s, long len); +void stuffReadbuffSpec(char_u *s); +void stuffcharReadbuff(int c); +void stuffnumReadbuff(long n); +int start_redo(long count, int old_redo); +int start_redo_ins(void); +void stop_redo_ins(void); +int ins_typebuf(char_u *str, int noremap, int offset, int nottyped, int silent); +void ins_char_typebuf(int c); +int typebuf_changed(int tb_change_cnt); +int typebuf_typed(void); +int typebuf_maplen(void); +void del_typebuf(int len, int offset); +int alloc_typebuf(void); +void free_typebuf(void); +int save_typebuf(void); +void save_typeahead(tasave_T *tp); +void restore_typeahead(tasave_T *tp); +void openscript(char_u *name, int directly); +void close_all_scripts(void); +int using_script(void); +void before_blocking(void); +void updatescript(int c); +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 vungetc(int c); +int fix_input_buffer(char_u *buf, int len); +int input_available(void); +int do_map(int maptype, char_u *arg, int mode, int abbrev); +int get_map_mode(char_u **cmdp, int forceit); +void map_clear(char_u *cmdp, char_u *arg, int forceit, int abbr); +void map_clear_int(buf_T *buf, int mode, int local, int abbr); +char_u *map_mode_to_chars(int mode); +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(regmatch_T *regmatch, int *num_file, char_u ***file); +int check_abbr(int c, char_u *ptr, int col, int mincol); +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 init_mappings(void); +void add_map(char_u *map, int mode); +/* vim: set ft=c : */ diff --git a/src/proto/gui.pro b/src/proto/gui.pro new file mode 100644 index 0000000..4004bc7 --- /dev/null +++ b/src/proto/gui.pro @@ -0,0 +1,70 @@ +/* gui.c */ +void gui_start(void); +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_cursor(int row, int col); +void gui_update_cursor(int force, int clear_selection); +void gui_position_menu(void); +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_reset_scroll_region(void); +void gui_start_highlight(int mask); +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); +int gui_outstr_nowrap(char_u *s, int len, int flags, guicolor_T fg, guicolor_T bg, int back); +void gui_undraw_cursor(void); +void gui_redraw(int x, int y, int w, int h); +int 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); +int gui_xy2colrow(int x, int y, int *colp); +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); +int gui_do_horiz_scroll(long_u leftcol, int compute_longest_lnum); +void gui_check_colors(void); +guicolor_T gui_get_color(char_u *name); +int gui_get_lightness(guicolor_T pixel); +void gui_new_scrollbar_colors(void); +void gui_focus_change(int in_focus); +void gui_mouse_moved(int x, int y); +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); +/* vim: set ft=c : */ diff --git a/src/proto/gui_athena.pro b/src/proto/gui_athena.pro new file mode 100644 index 0000000..a834dac --- /dev/null +++ b/src/proto/gui_athena.pro @@ -0,0 +1,31 @@ +/* gui_athena.c */ +void gui_x11_create_widgets(void); +void gui_x11_destroy_widgets(void); +void gui_mch_set_toolbar_pos(int x, int y, int w, int h); +void gui_mch_set_text_area_pos(int x, int y, int w, int h); +void gui_x11_set_back_color(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_add_menu(vimmenu_T *menu, int idx); +void gui_mch_new_menu_font(void); +void gui_mch_new_tooltip_font(void); +void gui_mch_new_tooltip_colors(void); +void gui_mch_add_menu_item(vimmenu_T *menu, int idx); +void gui_mch_show_toolbar(int showit); +int gui_mch_compute_toolbar_height(void); +void gui_mch_get_toolbar_colors(Pixel *bgp, Pixel *fgp, Pixel *bsp, Pixel *tsp, Pixel *hsp); +void gui_mch_toggle_tearoffs(int enable); +void gui_mch_new_menu_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); +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 *buttons, int dfltbutton, char_u *textfield, int ex_cmd); +/* 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..319e27d --- /dev/null +++ b/src/proto/gui_gtk.pro @@ -0,0 +1,22 @@ +/* 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); +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..111cac7 --- /dev/null +++ b/src/proto/gui_gtk_x11.pro @@ -0,0 +1,79 @@ +/* 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_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); +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_gtk_get_screen_geom_of_win(GtkWidget *wid, int *screen_x, int *screen_y, int *width, int *height); +void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h); +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_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(VimClipboard *cbd); +void clip_mch_lose_selection(VimClipboard *cbd); +int clip_mch_own_selection(VimClipboard *cbd); +void clip_mch_set_selection(VimClipboard *cbd); +int clip_gtk_owner_exists(VimClipboard *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_mac.pro b/src/proto/gui_mac.pro new file mode 100644 index 0000000..011ef28 --- /dev/null +++ b/src/proto/gui_mac.pro @@ -0,0 +1,151 @@ +/* gui_mac.c */ + +/* + * Mac specific prototypes + */ + +pascal Boolean WaitNextEventWrp(EventMask eventMask, EventRecord *theEvent, UInt32 sleep, RgnHandle mouseRgn); +pascal void gui_mac_scroll_action(ControlHandle theControl, short partCode); +pascal void gui_mac_drag_thumb (ControlHandle theControl, short partCode); +void gui_mac_handle_event(EventRecord *event); +void gui_mac_doMouseDown(EventRecord *theEvent); +void gui_mac_do_key(EventRecord *theEvent); +void gui_mac_handle_menu(long menuChoice); +void gui_mac_focus_change(EventRecord *event); +void gui_mac_update(EventRecord *event); +short gui_mch_get_mac_menu_item_index(vimmenu_T *menu, vimmenu_T *parent); +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_getmouse(int *x, int *y); +void gui_mch_setmouse(int x, int y); +void gui_mch_prepare(int *argc, char **argv); +int gui_mch_init_check(void); +int gui_mch_init(void); +void gui_mch_new_colors(void); +int gui_mch_open(void); +void gui_mch_exit(int); +void gui_mch_set_winsize(int width, int height, int min_width, int min_height, int base_width, int base_height); +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_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(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); +void gui_mch_create_scrollbar(scrollbar_T *sb, int orient); +void gui_mch_destroy_scrollbar(scrollbar_T *sb); +int gui_mch_adjust_charheight(void); +int gui_mch_init_font(char_u *font_name, int fontset); +GuiFont gui_mch_get_font(char_u *name, int giveErrorIfMissing); +char_u *gui_mch_get_fontname(GuiFont font, char_u *name); +GuiFont gui_mac_find_font(char_u *font_name); +void gui_mch_set_font(GuiFont font); +int gui_mch_same_font(GuiFont f1, GuiFont f2); +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); +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_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_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 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, vimmenu_T *parent, int idx);*/ +void gui_mch_add_menu(vimmenu_T *menu, int pos); +/*void gui_mch_add_menu_item(vimmenu_T *menu, vimmenu_T *parent, int idx);*/ +void gui_mch_add_menu_item(vimmenu_T *menu, int idx); +void gui_mch_show_popupmenu(vimmenu_T *menu); +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); +int gui_mch_get_lightness(guicolor_T pixel); +guicolor_T gui_mch_get_rgb(guicolor_T pixel); +int gui_mch_get_mouse_x(void); +int gui_mch_get_mouse_y(void); +void gui_mch_setmouse(int x, int y); +void gui_mch_show_popupmenu(vimmenu_T *menu); +int gui_mch_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton, char_u *textfield, int ex_cmd); +char_u *gui_mch_browse(int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter); +void gui_mch_set_foreground(void); +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); + +char_u *C2Pascal_save(char_u *Cstring); +char_u *C2Pascal_save_and_remove_backslash(char_u *Cstring); +int_u EventModifiers2VimMouseModifiers(EventModifiers macModifiers); +char_u **new_fnames_from_AEDesc(AEDesc *theList, long *numFiles, OSErr *error); + + +void gui_request_selection(void); +void gui_mch_lose_selection(void); +int gui_mch_own_selection(void); +void gui_mch_clear_selection(void); + +void gui_win_new_height(win_T *wp); +void gui_win_comp_pos(void); +void gui_win_free(win_T *wp); +void gui_win_alloc(win_T *wp); +void mch_post_buffer_write (buf_T *buf); + +void mch_errmsg(char *str); +void mch_display_error(void); +void clip_mch_lose_selection(VimClipboard *cbd); +void clip_mch_request_selection(VimClipboard *cbd); +void clip_mch_set_selection(VimClipboard *cbd); +int clip_mch_own_selection(VimClipboard *cbd); + +pascal OSErr FindProcessBySignature( const OSType targetType, + const OSType targetCreator, ProcessSerialNumberPtr psnPtr ); +OSErr InstallAEHandlers (void); +pascal OSErr HandleODocAE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_aevt_oapp_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_aevt_quit_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_aevt_pdoc_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_unknown_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +/* Shoulde we return MenuItemIndex? IMO yes, I did that for 5.7 ak*/ +short gui_mac_get_menu_item_index (vimmenu_T *pMenu); + +pascal OSErr Handle_KAHL_SRCH_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_KAHL_MOD_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +pascal OSErr Handle_KAHL_GTTX_AE (const AppleEvent *theAEvent, AppleEvent *theReply, long refCon); +void Send_KAHL_MOD_AE (buf_T *buf); + +void gui_mac_doInContentClick(EventRecord *theEvent, WindowPtr whichWindow); +void gui_mac_doInDragClick(Point where, WindowPtr whichWindow); +void gui_mac_doInGrowClick(Point where, WindowPtr whichWindow); +void gui_mac_doUpdateEvent(EventRecord *event); +void gui_mac_doActivateEvent(EventRecord *event); +void gui_mac_doSuspendEvent(EventRecord *event); +void gui_mac_doKeyEvent(EventRecord *theEvent); +void gui_mac_doMouseDownEvent(EventRecord *theEvent); +void gui_mac_doMouseMovedEvent(EventRecord *event); +void gui_mac_doMouseUpEvent(EventRecord *theEvent); +void gui_mch_mousehide(int hide); + +int C2PascalString (char_u *CString, Str255 *PascalString); +int GetFSSpecFromPath ( char_u *file, FSSpec *fileFSSpec); +char_u *FullPathFromFSSpec_save (FSSpec file); + +/* vim: set ft=c : */ diff --git a/src/proto/gui_motif.pro b/src/proto/gui_motif.pro new file mode 100644 index 0000000..493f5e7 --- /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); +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_enable_footer(int showit); +void gui_mch_set_footer(char_u *s); +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..9fcc512 --- /dev/null +++ b/src/proto/gui_photon.pro @@ -0,0 +1,70 @@ +/* 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); +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..75edd4b --- /dev/null +++ b/src/proto/gui_w32.pro @@ -0,0 +1,99 @@ +/* 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); +LRESULT WINAPI vim_WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam); +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); +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); +int get_cmd_args(char *prog, char *cmdline, char ***argvp, char **tofree); +void gui_mch_set_parent(char *title); +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(LOGFONT *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); +int multiline_balloon_available(void); +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); +/* vim: set ft=c : */ diff --git a/src/proto/gui_x11.pro b/src/proto/gui_x11.pro new file mode 100644 index 0000000..955f374 --- /dev/null +++ b/src/proto/gui_x11.pro @@ -0,0 +1,73 @@ +/* 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); +int fontset_height2(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(VimClipboard *cbd); +int clip_mch_own_selection(VimClipboard *cbd); +void clip_mch_request_selection(VimClipboard *cbd); +void clip_mch_set_selection(VimClipboard *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_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/hangulin.pro b/src/proto/hangulin.pro new file mode 100644 index 0000000..3aef39d --- /dev/null +++ b/src/proto/hangulin.pro @@ -0,0 +1,11 @@ +/* hangulin.c */ +int hangul_input_state_get(void); +void hangul_input_state_set(int state); +int im_get_status(void); +void hangul_input_state_toggle(void); +void hangul_keyboard_set(void); +int hangul_input_process(char_u *s, int len); +void hangul_input_clear(void); +char_u *hangul_string_convert(char_u *buf, int *p_len); +char_u *hangul_composing_buffer_get(int *p_len); +/* vim: set ft=c : */ diff --git a/src/proto/hardcopy.pro b/src/proto/hardcopy.pro new file mode 100644 index 0000000..615f088 --- /dev/null +++ b/src/proto/hardcopy.pro @@ -0,0 +1,20 @@ +/* hardcopy.c */ +char *parse_printoptions(void); +char *parse_printmbfont(void); +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..9690714 --- /dev/null +++ b/src/proto/hashtab.pro @@ -0,0 +1,14 @@ +/* hashtab.c */ +void hash_init(hashtab_T *ht); +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); +int hash_add_item(hashtab_T *ht, hashitem_T *hi, char_u *key, hash_T hash); +void hash_remove(hashtab_T *ht, hashitem_T *hi); +void hash_lock(hashtab_T *ht); +void hash_unlock(hashtab_T *ht); +hash_T hash_hash(char_u *key); +/* vim: set ft=c : */ diff --git a/src/proto/if_cscope.pro b/src/proto/if_cscope.pro new file mode 100644 index 0000000..f9919c4 --- /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); +int cs_connection(int num, char_u *dbpath, char_u *ppath); +void cs_end(void); +/* vim: set ft=c : */ diff --git a/src/proto/if_lua.pro b/src/proto/if_lua.pro new file mode 100644 index 0000000..c33678e --- /dev/null +++ b/src/proto/if_lua.pro @@ -0,0 +1,11 @@ +/* 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); +/* vim: set ft=c : */ diff --git a/src/proto/if_mzsch.pro b/src/proto/if_mzsch.pro new file mode 100644 index 0000000..bab82ce --- /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); +void mzvim_reset_timer(void); +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..496859c --- /dev/null +++ b/src/proto/if_ruby.pro @@ -0,0 +1,10 @@ +/* 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); +/* vim: set ft=c : */ diff --git a/src/proto/if_tcl.pro b/src/proto/if_tcl.pro new file mode 100644 index 0000000..b572fb8 --- /dev/null +++ b/src/proto/if_tcl.pro @@ -0,0 +1,10 @@ +/* if_tcl.c */ +void vim_tcl_init(char *arg); +int tcl_enabled(int verbose); +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..277953e --- /dev/null +++ b/src/proto/indent.pro @@ -0,0 +1,16 @@ +/* indent.c */ +int cin_is_cinword(char_u *line); +pos_T *find_start_comment(int ind_maxcomment); +int cindent_on(void); +int cin_islabel(void); +int cin_iscase(char_u *s, int strict); +int cin_isscopedecl(char_u *s); +void parse_cino(buf_T *buf); +int get_c_indent(void); +int get_expr_indent(void); +int in_cinkeys(int keytyped, int when, int line_is_empty); +int get_lisp_indent(void); +void do_c_expr_indent(void); +void fixthisline(int (*get_the_indent)(void)); +void fix_indent(void); +/* vim: set ft=c : */ diff --git a/src/proto/json.pro b/src/proto/json.pro new file mode 100644 index 0000000..b98c2c9 --- /dev/null +++ b/src/proto/json.pro @@ -0,0 +1,7 @@ +/* json.c */ +char_u *json_encode(typval_T *val, int options); +char_u *json_encode_nr_expr(int nr, typval_T *val, int options); +int json_decode_all(js_read_T *reader, typval_T *res, int options); +int json_decode(js_read_T *reader, typval_T *res, int options); +int json_find_end(js_read_T *reader, int options); +/* vim: set ft=c : */ diff --git a/src/proto/list.pro b/src/proto/list.pro new file mode 100644 index 0000000..88d9028 --- /dev/null +++ b/src/proto/list.pro @@ -0,0 +1,40 @@ +/* list.c */ +void list_add_watch(list_T *l, listwatch_T *lw); +void list_rem_watch(list_T *l, listwatch_T *lwrem); +void list_fix_watch(list_T *l, listitem_T *item); +list_T *list_alloc(void); +list_T *list_alloc_id(alloc_id_T id); +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(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); +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); +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_copy(list_T *orig, int deep, 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); +int get_list_tv(char_u **arg, typval_T *rettv, int evaluate); +int write_list(FILE *fd, list_T *list, int binary); +void init_static_list(staticList10_T *sl); +/* vim: set ft=c : */ diff --git a/src/proto/main.pro b/src/proto/main.pro new file mode 100644 index 0000000..278d1ad --- /dev/null +++ b/src/proto/main.pro @@ -0,0 +1,17 @@ +/* main.c */ +int vim_main2(void); +void common_init(mparm_T *paramp); +int is_not_a_term(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); +void time_push(void *tv_rel, void *tv_start); +void time_pop(void *tp); +void time_msg(char *mesg, void *tv_start); +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); +/* vim: set ft=c : */ diff --git a/src/proto/mark.pro b/src/proto/mark.pro new file mode 100644 index 0000000..150e986 --- /dev/null +++ b/src/proto/mark.pro @@ -0,0 +1,38 @@ +/* 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 fname2fnum(xfmark_T *fm); +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 do_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); +int read_viminfo_filemark(vir_T *virp, int force); +void prepare_viminfo_marks(void); +void finish_viminfo_marks(void); +void handle_viminfo_mark(garray_T *values, int force); +void write_viminfo_filemarks(FILE *fp); +int removable(char_u *name); +void write_viminfo_marks(FILE *fp_out, garray_T *buflist); +void copy_viminfo_marks(vir_T *virp, FILE *fp_out, garray_T *buflist, int eof, int flags); +/* vim: set ft=c : */ diff --git a/src/proto/mbyte.pro b/src/proto/mbyte.pro new file mode 100644 index 0000000..5b97d55 --- /dev/null +++ b/src/proto/mbyte.pro @@ -0,0 +1,101 @@ +/* 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 arabic_combine(int one, int two); +int arabic_maycombine(int two); +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_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); +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 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); +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); +/* 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..04254b0 --- /dev/null +++ b/src/proto/memline.pro @@ -0,0 +1,40 @@ +/* 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(void); +int recover_names(char_u *fname, int 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_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 message); +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..411c040 --- /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); +char_u *menu_name_skip(char_u *name); +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); +/* vim: set ft=c : */ diff --git a/src/proto/message.pro b/src/proto/message.pro new file mode 100644 index 0000000..792ac5d --- /dev/null +++ b/src/proto/message.pro @@ -0,0 +1,83 @@ +/* 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); +int emsg_not_now(void); +void ignore_error_for_testing(char_u *error); +void do_perror(char *msg); +int emsg(char *s); +int semsg(const char *s, ...); +void iemsg(char *s); +void siemsg(const char *s, ...); +void internal_error(char *where); +void emsg_invreg(int name); +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); +char_u *str2special_save(char_u *str, int is_lhs); +char_u *str2special(char_u **sp, int from); +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_outtrans_long_len_attr(char_u *longstr, int len, 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_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 msg_moremsg(int full); +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_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); +void display_confirm_msg(void); +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); +char_u *do_browse(int flags, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter, buf_T *buf); +/* vim: set ft=c : */ diff --git a/src/proto/misc1.pro b/src/proto/misc1.pro new file mode 100644 index 0000000..1e50f8a --- /dev/null +++ b/src/proto/misc1.pro @@ -0,0 +1,102 @@ +/* misc1.c */ +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 get_breakindent_win(win_T *wp, char_u *line); +int open_line(int dir, int flags, int second_line_indent); +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); +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 truncate_line(int fixpos); +void del_lines(long nlines, int undo); +int gchar_pos(pos_T *pos); +int gchar_cursor(void); +void pchar_cursor(int c); +int inindent(int extra); +char_u *skip_to_option_part(char_u *p); +void changed(void); +void changed_int(void); +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(linenr_T lnum, colnr_T col, linenr_T lnume, long xtra); +void unchanged(buf_T *buf, int ff); +void check_status(buf_T *buf); +void change_warning(int col); +int ask_yesno(char_u *str, int direct); +int is_mouse_key(int c); +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); +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_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 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); +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 vim_ispathlistsep(int c); +void shorten_dir(char_u *str); +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); +char_u *concat_str(char_u *str1, char_u *str2); +void add_pathsep(char_u *p); +char_u *FullName_save(char_u *fname, int force); +void prepare_to_exit(void); +void preserve_exit(void); +int vim_fexists(char_u *fname); +void line_breakcheck(void); +void fast_breakcheck(void); +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); +void remove_duplicates(garray_T *gap); +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); +char_u *get_cmd_output(char_u *cmd, char_u *infile, int flags, int *ret_len); +void FreeWild(int count, char_u **files); +int goto_im(void); +char_u *get_isolated_shell_name(void); +/* vim: set ft=c : */ diff --git a/src/proto/misc2.pro b/src/proto/misc2.pro new file mode 100644 index 0000000..7d33de8 --- /dev/null +++ b/src/proto/misc2.pro @@ -0,0 +1,119 @@ +/* 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 wcol); +int getvpos(pos_T *pos, colnr_T wcol); +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 adjust_cursor_col(void); +int leftcol_changed(void); +void vim_mem_profile_dump(void); +int alloc_does_fail(long_u size); +char_u *alloc(unsigned size); +char_u *alloc_id(unsigned size, alloc_id_T id); +char_u *alloc_clear(unsigned size); +char_u *alloc_clear_id(unsigned size, alloc_id_T id); +char_u *alloc_check(unsigned size); +char_u *lalloc_clear(long_u size, int message); +char_u *lalloc(long_u size, int message); +char_u *lalloc_id(long_u size, int message, alloc_id_T id); +void *mem_realloc(void *ptr, size_t size); +void do_outofmem_msg(long_u size); +void free_all_mem(void); +char_u *vim_strsave(char_u *string); +char_u *vim_strnsave(char_u *string, int len); +char_u *vim_memsave(char_u *p, int 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, int len); +void vim_strup(char_u *p); +char_u *strup_save(char_u *orig); +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); +int copy_option_part(char_u **option, char_u *buf, int maxlen, char *sep_chars); +void vim_free(void *x); +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); +int vim_isspace(int x); +void ga_clear(garray_T *gap); +void ga_clear_strings(garray_T *gap); +void ga_init(garray_T *gap); +void ga_init2(garray_T *gap, int itemsize, int growsize); +int ga_grow(garray_T *gap, int n); +char_u *ga_concat_strings(garray_T *gap, char *sep); +void ga_add_string(garray_T *gap, char_u *p); +void ga_concat(garray_T *gap, char_u *s); +void ga_append(garray_T *gap, int c); +void append_ga_line(garray_T *gap); +int name_to_mod_mask(int c); +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 keycode, int in_string); +int find_special_key(char_u **srcp, int *modp, int keycode, int keep_x_key, int in_string); +int extract_modifiers(int key, int *modp); +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_mouse_button(int code, int *is_click, int *is_drag); +int get_pseudo_mouse_code(int button, int is_click, int is_drag); +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 *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); +void vim_findfile_free_visited(void *search_ctx_arg); +char_u *find_file_in_path(char_u *ptr, int len, int options, int first, char_u *rel_fname); +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); +int vim_chdir(char_u *new_dir); +int get_user_name(char_u *buf, int len); +void sort_strings(char_u **files, int count); +int pathcmp(const char *p, const char *q, int maxlen); +int filewritable(char_u *fname); +int get2c(FILE *fd); +int get3c(FILE *fd); +int get4c(FILE *fd); +time_T get8ctime(FILE *fd); +char_u *read_string(FILE *fd, int cnt); +int put_bytes(FILE *fd, long_u nr, int len); +int put_time(FILE *fd, time_T the_time); +void time_to_bytes(time_T the_time, char_u *buf); +int has_non_ascii(char_u *s); +void parse_queued_messages(void); +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); +/* vim: set ft=c : */ diff --git a/src/proto/move.pro b/src/proto/move.pro new file mode 100644 index 0000000..ed45c4d --- /dev/null +++ b/src/proto/move.pro @@ -0,0 +1,43 @@ +/* move.c */ +void reset_cursorline(void); +void redraw_for_cursorline(win_T *wp); +void update_topline_redraw(void); +void update_topline(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 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 validate_botline(void); +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_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 scrolldown(long line_count, int byfold); +void scrollup(long line_count, int byfold); +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); +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..55d12bb --- /dev/null +++ b/src/proto/normal.pro @@ -0,0 +1,26 @@ +/* normal.c */ +void init_normal_cmds(void); +void normal_cmd(oparg_T *oap, int toplevel); +void do_pending_operator(cmdarg_T *cap, int old_col, int gui_yank); +int do_mouse(oparg_T *oap, int c, int dir, long count, int fixindent); +void check_visual_highlight(void); +void end_visual_mode(void); +void reset_VIsual_and_resel(void); +void reset_VIsual(void); +int find_ident_under_cursor(char_u **string, int find_type); +int find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char_u **string, int find_type); +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 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); +/* vim: set ft=c : */ diff --git a/src/proto/ops.pro b/src/proto/ops.pro new file mode 100644 index 0000000..01df56f --- /dev/null +++ b/src/proto/ops.pro @@ -0,0 +1,68 @@ +/* ops.c */ +int get_op_type(int char1, int char2); +int op_on_lines(int op); +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); +void op_reindent(oparg_T *oap, int (*how)(void)); +int get_expr_register(void); +void set_expr_line(char_u *new_line); +char_u *get_expr_line(void); +char_u *get_expr_line_src(void); +int valid_yank_reg(int regname, int writing); +int get_yank_register(int regname, int writing); +int may_get_selection(int regname); +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 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 adjust_clip_reg(int *rp); +void shift_delete_registers(void); +int op_delete(oparg_T *oap); +int op_replace(oparg_T *oap, int c); +void op_tilde(oparg_T *oap); +int swapchar(int op_type, pos_T *pos); +void op_insert(oparg_T *oap, long count1); +int op_change(oparg_T *oap); +void init_yank(void); +void clear_registers(void); +int op_yank(oparg_T *oap, int deleting, int mess); +void do_put(int regname, int dir, long count, int flags); +void adjust_cursor_eol(void); +int preprocs_left(void); +int get_register_name(int num); +void ex_display(exarg_T *eap); +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 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); +int paragraph_start(linenr_T lnum); +void op_addsub(oparg_T *oap, linenr_T Prenum1, int g_cmd); +void prepare_viminfo_registers(void); +void finish_viminfo_registers(void); +int read_viminfo_register(vir_T *virp, int force); +void handle_viminfo_register(garray_T *values, int force); +void write_viminfo_registers(FILE *fp); +void x11_export_final_selection(void); +void clip_free_selection(VimClipboard *cbd); +void clip_get_selection(VimClipboard *cbd); +void clip_yank_selection(int type, char_u *str, long len, VimClipboard *cbd); +int clip_convert_selection(char_u **str, long_u *len, VimClipboard *cbd); +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 clear_oparg(oparg_T *oap); +void cursor_pos_info(dict_T *dict); +/* vim: set ft=c : */ diff --git a/src/proto/option.pro b/src/proto/option.pro new file mode 100644 index 0000000..1027edf --- /dev/null +++ b/src/proto/option.pro @@ -0,0 +1,85 @@ +/* option.c */ +void set_init_1(int clean_arg); +void set_string_default(char *name, char_u *val); +void set_number_default(char *name, long val); +void free_all_options(void); +void set_init_2(void); +void set_init_3(void); +void set_helplang_default(char_u *lang); +void init_gui_options(void); +void set_title_defaults(void); +int do_set(char_u *arg, int opt_flags); +int string_to_key(char_u *arg, int multi_byte); +void set_options_bin(int oldval, int newval, int opt_flags); +int get_viminfo_parameter(int type); +char_u *find_viminfo_parameter(int type); +void check_options(void); +void check_buf_options(buf_T *buf); +void free_string_option(char_u *p); +void clear_string_option(char_u **pp); +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 set_string_option_direct(char_u *name, int opt_idx, char_u *val, int opt_flags, int set_sid); +char *check_colorcolumn(win_T *wp); +char *check_stl_option(char_u *s); +void set_term_option_sctx_idx(char *name, int opt_idx); +int get_option_value(char_u *name, long *numval, char_u **stringval, int opt_flags); +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); +char *set_option_value(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 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); +void comp_col(void); +void unset_global_local_option(char_u *name, void *from); +char_u *get_equalprg(void); +void win_copy_options(win_T *wp_from, win_T *wp_to); +void copy_winopt(winopt_T *from, winopt_T *to); +void check_win_options(win_T *win); +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, int *num_file, char_u ***file); +int ExpandOldSetting(int *num_file, char_u ***file); +int langmap_adjust_mb(int c); +int has_format_option(int x); +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); +int can_bs(int what); +void save_file_ff(buf_T *buf); +int file_ff_differs(buf_T *buf, int ignore_empty); +int check_ff_value(char_u *p); +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_eq(int *ts1, int *ts2); +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_pos(buf_T *buf, pos_T *pos); +long get_sw_value_col(buf_T *buf, colnr_T col); +long get_sts_value(void); +long get_scrolloff_value(void); +long get_sidescrolloff_value(void); +void find_mps_values(int *initc, int *findc, int *backwards, int switchit); +unsigned int get_bkc_value(buf_T *buf); +int signcolumn_on(win_T *wp); +dict_T *get_winbuf_options(int bufopt); +/* vim: set ft=c : */ diff --git a/src/proto/os_amiga.pro b/src/proto/os_amiga.pro new file mode 100644 index 0000000..b781680 --- /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 ignoreinput); +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); +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(int tmode); +int mch_screenmode(char_u *arg); +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_beos.pro b/src/proto/os_beos.pro new file mode 100644 index 0000000..bccf45d --- /dev/null +++ b/src/proto/os_beos.pro @@ -0,0 +1,4 @@ +/* os_beos.c */ +void beos_cleanup_read_thread(void); +int beos_select(int nbits, struct fd_set *rbits, struct fd_set *wbits, struct fd_set *ebits, struct timeval *timeout); +/* 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_mswin.pro b/src/proto/os_mswin.pro new file mode 100644 index 0000000..cc660a6 --- /dev/null +++ b/src/proto/os_mswin.pro @@ -0,0 +1,54 @@ +/* os_mswin.c */ +void mch_exit(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); +int vim_stat(const char *name, stat_T *stp); +void mch_settmode(int 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_screenmode(char_u *arg); +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_shortcut(char_u *fname); +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(LOGFONT *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..89a250f --- /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(VimClipboard *cbd); +void clip_mch_lose_selection(VimClipboard *cbd); +void clip_mch_request_selection(VimClipboard *cbd); +void clip_mch_set_selection(VimClipboard *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..224fe98 --- /dev/null +++ b/src/proto/os_unix.pro @@ -0,0 +1,86 @@ +/* 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 ignoreinput); +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); +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 vim_is_fastterm(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_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(int 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_screenmode(char_u *arg); +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); +void may_send_sigint(int c, pid_t pid, pid_t wpid); +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 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(VimClipboard *cbd); +void clip_xterm_lose_selection(VimClipboard *cbd); +void clip_xterm_request_selection(VimClipboard *cbd); +void clip_xterm_set_selection(VimClipboard *cbd); +int xsmp_handle_requests(void); +void xsmp_init(void); +void xsmp_close(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..c1cfd44 --- /dev/null +++ b/src/proto/os_vms.pro @@ -0,0 +1,16 @@ +/* os_vms.c */ +void mch_settmode(int 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..7f45c5c --- /dev/null +++ b/src/proto/os_win32.pro @@ -0,0 +1,76 @@ +/* os_win32.c */ +HINSTANCE vimLoadLib(char *name); +HINSTANCE find_imported_module_by_funcname(HINSTANCE hInst, const char *funcname); +void *get_dll_import_func(HINSTANCE hInst, const char *funcname); +int dyn_libintl_init(void); +void dyn_libintl_end(void); +void PlatformId(void); +void mch_setmouse(int on); +void mch_bevalterm_changed(void); +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_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(int 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 ignoreinput); +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 myresetstkoflw(void); +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); +void control_console_color_rgb(void); +int has_vtp_working(void); +int use_vtp(void); +int is_term_win32(void); +/* vim: set ft=c : */ diff --git a/src/proto/popupmnu.pro b/src/proto/popupmnu.pro new file mode 100644 index 0000000..e2ae92a --- /dev/null +++ b/src/proto/popupmnu.pro @@ -0,0 +1,17 @@ +/* popupmnu.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); +void pum_redraw(void); +void pum_undisplay(void); +void pum_clear(void); +int pum_visible(void); +void pum_may_redraw(void); +int pum_get_height(void); +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/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..a71f343 --- /dev/null +++ b/src/proto/quickfix.pro @@ -0,0 +1,34 @@ +/* quickfix.c */ +int qf_init(win_T *wp, char_u *efile, char_u *errorformat, int newlist, char_u *qf_title, char_u *enc); +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_jump_newwin(qf_info_T *qi, int dir, int errornr, int forceit, int newwin); +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); +int grep_internal(cmdidx_T cmdidx); +void ex_make(exarg_T *eap); +int qf_get_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_cfile(exarg_T *eap); +void ex_vimgrep(exarg_T *eap); +int get_errorlist(qf_info_T *qi_arg, win_T *wp, int qf_idx, list_T *list); +int qf_get_properties(win_T *wp, dict_T *what, dict_T *retdict); +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); +void ex_cexpr(exarg_T *eap); +void ex_helpgrep(exarg_T *eap); +/* vim: set ft=c : */ diff --git a/src/proto/regexp.pro b/src/proto/regexp.pro new file mode 100644 index 0000000..490bda4 --- /dev/null +++ b/src/proto/regexp.pro @@ -0,0 +1,20 @@ +/* regexp.c */ +int re_multiline(regprog_T *prog); +char_u *skip_regexp(char_u *startp, int dirc, int magic, char_u **newp); +int vim_regcomp_had_eol(void); +void free_regexp_stuff(void); +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 copy, int magic, int backslash); +int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *dest, int copy, int magic, int backslash); +char_u *reg_submatch(int no); +list_T *reg_submatch_list(int no); +regprog_T *vim_regcomp(char_u *expr_arg, int re_flags); +void vim_regfree(regprog_T *prog); +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, proftime_T *tm, int *timed_out); +/* vim: set ft=c : */ diff --git a/src/proto/screen.pro b/src/proto/screen.pro new file mode 100644 index 0000000..0657831 --- /dev/null +++ b/src/proto/screen.pro @@ -0,0 +1,64 @@ +/* screen.c */ +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 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); +int redraw_asap(int type); +void redraw_after_callback(int call_update_screen); +void redrawWinline(win_T *wp, linenr_T lnum); +void reset_updating_screen(int may_resize_shell); +void update_curbuf(int type); +int update_screen(int type_arg); +int conceal_cursor_line(win_T *wp); +void conceal_check_cursor_line(void); +void update_debug_sign(buf_T *buf, linenr_T lnum); +void updateWindow(win_T *wp); +int screen_get_current_line_off(void); +void screen_line(int row, int coloff, int endcol, int clear_width, int rlflag); +void rl_mirror(char_u *str); +void status_redraw_all(void); +void status_redraw_curbuf(void); +void redraw_statuslines(void); +void win_redraw_last_status(frame_T *frp); +void win_redr_status_matches(expand_T *xp, int num_matches, char_u **matches, int match, int showtail); +int stl_connected(win_T *wp); +int get_keymap_str(win_T *wp, char_u *fmt, char_u *buf, int len); +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); +void screen_stop_highlight(void); +void reset_cterm_colors(void); +void screen_draw_rectangle(int row, int col, int height, int width, int invert); +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); +void screenclear(void); +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 redrawing(void); +int messaging(void); +void showruler(int always); +int number_width(win_T *wp); +int screen_screencol(void); +int screen_screenrow(void); +/* vim: set ft=c : */ diff --git a/src/proto/search.pro b/src/proto/search.pro new file mode 100644 index 0000000..eb614a1 --- /dev/null +++ b/src/proto/search.pro @@ -0,0 +1,51 @@ +/* search.c */ +int search_regcomp(char_u *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, linenr_T stop_lnum, proftime_T *tm, int *timed_out); +void set_search_direction(int cdir); +int do_search(oparg_T *oap, int dirc, char_u *pat, long count, int options, proftime_T *tm, int *timed_out); +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); +void showmatch(int 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); +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); +int read_viminfo_search_pattern(vir_T *virp, int force); +void write_viminfo_search_pattern(FILE *fp); +/* 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..d087c01 --- /dev/null +++ b/src/proto/sign.pro @@ -0,0 +1,27 @@ +/* sign.c */ +void init_signs(void); +int buf_getsigntype(buf_T *buf, linenr_T lnum, int type); +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); +int sign_undefine_by_name(char_u *name); +int sign_place(int *sign_id, char_u *sign_group, char_u *sign_name, buf_T *buf, linenr_T lnum, int prio); +int sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T atlnum); +linenr_T sign_jump(int sign_id, char_u *sign_group, buf_T *buf); +void ex_sign(exarg_T *eap); +void sign_getlist(char_u *name, list_T *retlist); +void get_buffer_signs(buf_T *buf, list_T *l); +void sign_get_placed(buf_T *buf, linenr_T lnum, int sign_id, char_u *sign_group, list_T *retlist); +void sign_gui_started(void); +int sign_get_attr(int typenr, int line); +char_u *sign_get_text(int typenr); +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); +/* vim: set ft=c : */ diff --git a/src/proto/spell.pro b/src/proto/spell.pro new file mode 100644 index 0000000..485d7d1 --- /dev/null +++ b/src/proto/spell.pro @@ -0,0 +1,38 @@ +/* spell.c */ +int spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, int docount); +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 *did_set_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_nmw(char_u *p, win_T *wp); +int spell_casefold(char_u *str, int len, char_u *buf, int buflen); +int spell_check_sps(void); +void spell_suggest(int count); +void ex_spellrepall(exarg_T *eap); +void spell_suggest_list(garray_T *gap, char_u *word, int maxcount, int need_cap, int interactive); +void onecap_copy(char_u *word, char_u *wcopy, int upper); +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); +/* vim: set ft=c : */ diff --git a/src/proto/spellfile.pro b/src/proto/spellfile.pro new file mode 100644 index 0000000..70e993a --- /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 bad, int idx, int undo); +/* vim: set ft=c : */ diff --git a/src/proto/syntax.pro b/src/proto/syntax.pro new file mode 100644 index 0000000..966a5cb --- /dev/null +++ b/src/proto/syntax.pro @@ -0,0 +1,65 @@ +/* syntax.c */ +void syn_set_timeout(proftime_T *tm); +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(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); +void init_highlight(int both, int reset); +int load_colors(char_u *name); +int lookup_color(int idx, int foreground, int *boldp); +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); +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_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); +/* vim: set ft=c : */ diff --git a/src/proto/tag.pro b/src/proto/tag.pro new file mode 100644 index 0000000..c9bcb38 --- /dev/null +++ b/src/proto/tag.pro @@ -0,0 +1,14 @@ +/* tag.c */ +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); +void simplify_filename(char_u *filename); +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..1b8ab5f --- /dev/null +++ b/src/proto/term.pro @@ -0,0 +1,83 @@ +/* term.c */ +guicolor_T termgui_mch_get_color(char_u *name); +guicolor_T termgui_get_color(char_u *name); +guicolor_T termgui_mch_get_rgb(guicolor_T color); +int set_termname(char_u *term); +void set_mouse_termcode(int n, char_u *s); +void del_mouse_termcode(int n); +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_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_fg_rgb_color(guicolor_T rgb); +void term_bg_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); +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 settmode(int tmode); +void starttermcap(void); +void stoptermcap(void); +void may_req_termresponse(void); +void may_req_ambiguous_char_width(void); +void may_req_bg_color(void); +int swapping_screen(void); +void setmouse(void); +int mouse_has(int c); +int mouse_model_popup(void); +void scroll_start(void); +void cursor_on_force(void); +void cursor_on(void); +void cursor_off(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); +void del_termcode(char_u *name); +void set_mouse_topline(win_T *wp); +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 from_part, int do_lt, int special); +int find_term_bykeys(char_u *src); +void show_termcodes(void); +int show_one_termcode(char_u *name, char_u *code, int printit); +char_u *translate_mapping(char_u *str, int expmap); +void update_tcap(int attr); +void swap_tcap(void); +guicolor_T gui_get_color_cmn(char_u *name); +guicolor_T gui_get_rgb_color_cmn(int r, int g, int b); +void cterm_color2rgb(int nr, char_u *r, char_u *g, char_u *b, char_u *ansi_idx); +/* vim: set ft=c : */ diff --git a/src/proto/terminal.pro b/src/proto/terminal.pro new file mode 100644 index 0000000..0fa62b7 --- /dev/null +++ b/src/proto/terminal.pro @@ -0,0 +1,62 @@ +/* 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); +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_none_open(term_T *term); +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); +int send_keys_to_term(term_T *term, int c, 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); +int terminal_loop(int blocking); +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); +int term_is_finished(buf_T *buf); +int term_show_buffer(buf_T *buf); +void term_change_in_curbuf(void); +int term_get_attr(buf_T *buf, linenr_T lnum, int col); +char_u *term_get_status_text(term_T *term); +int set_ref_in_term(int copyID); +void set_terminal_default_colors(int cterm_fg, int cterm_bg); +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_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 terminal_enabled(void); +void term_free_conpty(term_T *term); +int use_conpty(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/textprop.pro b/src/proto/textprop.pro new file mode 100644 index 0000000..0eac557 --- /dev/null +++ b/src/proto/textprop.pro @@ -0,0 +1,18 @@ +/* textprop.c */ +void f_prop_add(typval_T *argvars, typval_T *rettv); +int get_text_props(buf_T *buf, linenr_T lnum, char_u **props, int will_change); +proptype_T *text_prop_type_by_id(buf_T *buf, int id); +void f_prop_clear(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 prop_type_set(typval_T *argvars, int add); +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); +void adjust_prop_columns(linenr_T lnum, colnr_T col, int bytes_added); +void adjust_props_for_split(linenr_T lnum, int kept, int deleted); +/* vim: set ft=c : */ diff --git a/src/proto/ui.pro b/src/proto/ui.pro new file mode 100644 index 0000000..774a308 --- /dev/null +++ b/src/proto/ui.pro @@ -0,0 +1,72 @@ +/* ui.c */ +void ui_write(char_u *s, int len); +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, 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); +void ui_breakcheck(void); +void ui_breakcheck_force(int force); +void clip_init(int can_use); +void clip_update_selection(VimClipboard *clip); +void clip_own_selection(VimClipboard *cbd); +void clip_lose_selection(VimClipboard *cbd); +void start_global_changes(void); +int is_clipboard_needs_update(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(VimClipboard *cbd); +void clip_may_clear_selection(int row1, int row2); +void clip_scroll_selection(int rows); +void clip_copy_modeless_selection(int both); +int clip_gen_own_selection(VimClipboard *cbd); +void clip_gen_lose_selection(VimClipboard *cbd); +void clip_gen_set_selection(VimClipboard *cbd); +void clip_gen_request_selection(VimClipboard *cbd); +int clip_gen_owner_exists(VimClipboard *cbd); +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); +void add_to_input_buf(char_u *s, int len); +void add_to_input_buf_csi(char_u *str, int len); +void push_raw_key(char_u *s, 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); +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, VimClipboard *cbd); +void clip_x11_lose_selection(Widget myShell, VimClipboard *cbd); +int clip_x11_own_selection(Widget myShell, VimClipboard *cbd); +void clip_x11_set_selection(VimClipboard *cbd); +int clip_x11_owner_exists(VimClipboard *cbd); +void yank_cut_buffer0(Display *dpy, VimClipboard *cbd); +int jump_to_mouse(int flags, int *inclusive, int which_button); +int mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump); +win_T *mouse_find_win(int *rowp, int *colp); +int get_fpos_of_mouse(pos_T *mpos); +int vcol2col(win_T *wp, linenr_T lnum, int vcol); +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..1052d40 --- /dev/null +++ b/src/proto/undo.pro @@ -0,0 +1,31 @@ +/* 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); +char_u *u_get_undo_file_name(char_u *buf_ffname, int reading); +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_saveline(linenr_T lnum); +void u_clearline(void); +void u_undoline(void); +void u_blockfree(buf_T *buf); +int bufIsChanged(buf_T *buf); +int bufIsChangedNotTerm(buf_T *buf); +int curbufIsChanged(void); +void u_eval_tree(u_header_T *first_uhp, list_T *list); +/* vim: set ft=c : */ diff --git a/src/proto/userfunc.pro b/src/proto/userfunc.pro new file mode 100644 index 0000000..25f1c3c --- /dev/null +++ b/src/proto/userfunc.pro @@ -0,0 +1,58 @@ +/* userfunc.c */ +void func_init(void); +int get_lambda_tv(char_u **arg, typval_T *rettv, int evaluate); +char_u *deref_func_name(char_u *name, int *lenp, partial_T **partialp, int no_autoload); +int get_func_tv(char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, partial_T *partial, dict_T *selfdict); +ufunc_T *find_func(char_u *name); +void save_funccal(funccal_entry_T *entry); +void restore_funccal(void); +void free_all_functions(void); +int func_call(char_u *name, typval_T *args, partial_T *partial, dict_T *selfdict, typval_T *rettv); +int call_func(char_u *funcname, int len, typval_T *rettv, int argcount_in, typval_T *argvars_in, int (*argv_func)(int, typval_T *, int), linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, partial_T *partial, dict_T *selfdict_in); +char_u *trans_function_name(char_u **pp, int skip, int flags, funcdict_T *fdp, partial_T **partial); +void ex_function(exarg_T *eap); +int eval_fname_script(char_u *p); +int translated_function_exists(char_u *name); +int function_exists(char_u *name, int no_deref); +char_u *get_expanded_name(char_u *name, int check); +void func_dump_profile(FILE *fd); +void prof_child_enter(proftime_T *tm); +void prof_child_exit(proftime_T *tm); +char_u *get_user_func_name(expand_T *xp, int idx); +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); +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); +void func_line_start(void *cookie); +void func_line_exec(void *cookie); +void func_line_end(void *cookie); +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..8139772 --- /dev/null +++ b/src/proto/version.pro @@ -0,0 +1,11 @@ +/* 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 intro_message(int colon); +void ex_intro(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..990c1cf --- /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(VimClipboard *cbd); +void clip_mch_lose_selection(VimClipboard *cbd); +void clip_mch_request_selection(VimClipboard *cbd); +void clip_mch_set_selection(VimClipboard *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..4527a37 --- /dev/null +++ b/src/proto/window.pro @@ -0,0 +1,98 @@ +/* window.c */ +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(win_T *win); +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 close_windows(buf_T *buf, int keep_curwin); +int one_window(void); +int win_close(win_T *win, int free_buf); +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 curwin_init(void); +void win_init_empty(win_T *wp); +int win_alloc_first(void); +void win_alloc_aucmd_win(void); +void win_init_size(void); +void free_tabpage(tabpage_T *tp); +int win_new_tabpage(int after); +int may_open_tabpage(void); +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); +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); +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); +void win_append(win_T *after, win_T *wp); +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_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); +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 path_with_url(char_u *fname); +int vim_isAbsName(char_u *name); +int vim_FullName(char_u *fname, char_u *buf, int len, int force); +int min_rows(void); +int only_one_window(void); +void check_lnums(int do_curwin); +void make_snapshot(int idx); +void restore_snapshot(int idx, int close_curwin); +int switch_win(win_T **save_curwin, tabpage_T **save_curtab, win_T *win, tabpage_T *tp, int no_display); +void restore_win(win_T *save_curwin, tabpage_T *save_curtab, int no_display); +void switch_buffer(bufref_T *save_curbuf, buf_T *buf); +void restore_buffer(bufref_T *save_curbuf); +int win_hasvertsplit(void); +int match_add(win_T *wp, char_u *grp, char_u *pat, int prio, int id, list_T *pos_list, char_u *conceal_char); +int match_delete(win_T *wp, int id, int perr); +void clear_matches(win_T *wp); +matchitem_T *get_match(win_T *wp, int id); +int get_win_number(win_T *wp, win_T *first_win); +int get_tab_number(tabpage_T *tp); +int win_getid(typval_T *argvars); +int win_gotoid(typval_T *argvars); +void win_id2tabwin(typval_T *argvars, list_T *list); +win_T *win_id2wp(typval_T *argvars); +int win_id2win(typval_T *argvars); +void win_findbuf(typval_T *argvars, list_T *list); +void get_framelayout(frame_T *fr, list_T *l, int outer); +/* vim: set ft=c : */ |