"Fossies" - the Fresh Open Source Software Archive

Member "vim-8.2.1354/src/structs.h" (2 Aug 2020, 135920 Bytes) of package /linux/misc/vim-8.2.1354.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "structs.h" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 8.2.1322_vs_8.2.1333.

    1 /* vi:set ts=8 sts=4 sw=4 noet:
    2  *
    3  * VIM - Vi IMproved    by Bram Moolenaar
    4  *
    5  * Do ":help uganda"  in Vim to read copying and usage conditions.
    6  * Do ":help credits" in Vim to see a list of people who contributed.
    7  */
    8 
    9 /*
   10  * This file contains various definitions of structures that are used by Vim
   11  */
   12 
   13 /*
   14  * There is something wrong in the SAS compiler that makes typedefs not
   15  * valid in include files.  Has been fixed in version 6.58.
   16  */
   17 #if defined(SASC) && SASC < 658
   18 typedef long        linenr_T;
   19 typedef int     colnr_T;
   20 typedef unsigned short  short_u;
   21 #endif
   22 
   23 /*
   24  * Position in file or buffer.
   25  */
   26 typedef struct
   27 {
   28     linenr_T    lnum;   // line number
   29     colnr_T col;    // column number
   30     colnr_T coladd; // extra virtual column
   31 } pos_T;
   32 
   33 
   34 /*
   35  * Same, but without coladd.
   36  */
   37 typedef struct
   38 {
   39     linenr_T    lnum;   // line number
   40     colnr_T col;    // column number
   41 } lpos_T;
   42 
   43 /*
   44  * Structure used for growing arrays.
   45  * This is used to store information that only grows, is deleted all at
   46  * once, and needs to be accessed by index.  See ga_clear() and ga_grow().
   47  */
   48 typedef struct growarray
   49 {
   50     int     ga_len;         // current number of items used
   51     int     ga_maxlen;          // maximum number of items possible
   52     int     ga_itemsize;        // sizeof(item)
   53     int     ga_growsize;        // number of items to grow each time
   54     void    *ga_data;           // pointer to the first item
   55 } garray_T;
   56 
   57 #define GA_EMPTY    {0, 0, 0, 0, NULL}
   58 
   59 typedef struct window_S     win_T;
   60 typedef struct wininfo_S    wininfo_T;
   61 typedef struct frame_S      frame_T;
   62 typedef int         scid_T;     // script ID
   63 typedef struct file_buffer  buf_T;      // forward declaration
   64 typedef struct terminal_S   term_T;
   65 
   66 #ifdef FEAT_MENU
   67 typedef struct VimMenu vimmenu_T;
   68 #endif
   69 
   70 // maximum value for sc_version
   71 #define SCRIPT_VERSION_MAX 4
   72 // value for sc_version in a Vim9 script file
   73 #define SCRIPT_VERSION_VIM9 999999
   74 
   75 /*
   76  * SCript ConteXt (SCTX): identifies a script line.
   77  * When sourcing a script "sc_lnum" is zero, "sourcing_lnum" is the current
   78  * line number. When executing a user function "sc_lnum" is the line where the
   79  * function was defined, "sourcing_lnum" is the line number inside the
   80  * function.  When stored with a function, mapping, option, etc. "sc_lnum" is
   81  * the line number in the script "sc_sid".
   82  *
   83  * sc_version is also here, for convenience.
   84  */
   85 typedef struct {
   86     scid_T  sc_sid;     // script ID
   87     int     sc_seq;     // sourcing sequence number
   88     linenr_T    sc_lnum;    // line number
   89     int     sc_version; // :scriptversion
   90 } sctx_T;
   91 
   92 /*
   93  * Reference to a buffer that stores the value of buf_free_count.
   94  * bufref_valid() only needs to check "buf" when the count differs.
   95  */
   96 typedef struct {
   97     buf_T   *br_buf;
   98     int     br_fnum;
   99     int     br_buf_free_count;
  100 } bufref_T;
  101 
  102 /*
  103  * This is here because regexp.h needs pos_T and below regprog_T is used.
  104  */
  105 #include "regexp.h"
  106 
  107 /*
  108  * This is here because gui.h needs the pos_T and win_T, and win_T needs gui.h
  109  * for scrollbar_T.
  110  */
  111 #ifdef FEAT_GUI
  112 # include "gui.h"
  113 #else
  114 # ifdef FEAT_XCLIPBOARD
  115 #  include <X11/Intrinsic.h>
  116 # endif
  117 # define guicolor_T long
  118 # define INVALCOLOR ((guicolor_T)0x1ffffff)
  119     // only used for cterm.bg_rgb and cterm.fg_rgb: use cterm color
  120 # define CTERMCOLOR ((guicolor_T)0x1fffffe)
  121 #endif
  122 #define COLOR_INVALID(x) ((x) == INVALCOLOR || (x) == CTERMCOLOR)
  123 
  124 /*
  125  * marks: positions in a file
  126  * (a normal mark is a lnum/col pair, the same as a file position)
  127  */
  128 
  129 // (Note: for EBCDIC there are more than 26, because there are gaps in the
  130 // alphabet coding.  To minimize changes to the code, I decided to just
  131 // increase the number of possible marks.
  132 #define NMARKS      ('z' - 'a' + 1) // max. # of named marks
  133 #define EXTRA_MARKS 10      // marks 0-9
  134 #define JUMPLISTSIZE    100     // max. # of marks in jump list
  135 #define TAGSTACKSIZE    20      // max. # of tags in tag stack
  136 
  137 typedef struct filemark
  138 {
  139     pos_T   mark;       // cursor position
  140     int     fnum;       // file number
  141 } fmark_T;
  142 
  143 // Xtended file mark: also has a file name
  144 typedef struct xfilemark
  145 {
  146     fmark_T fmark;
  147     char_u  *fname;     // file name, used when fnum == 0
  148 #ifdef FEAT_VIMINFO
  149     time_T  time_set;
  150 #endif
  151 } xfmark_T;
  152 
  153 /*
  154  * The taggy struct is used to store the information about a :tag command.
  155  */
  156 typedef struct taggy
  157 {
  158     char_u  *tagname;   // tag name
  159     fmark_T fmark;      // cursor position BEFORE ":tag"
  160     int     cur_match;  // match number
  161     int     cur_fnum;   // buffer number used for cur_match
  162     char_u  *user_data; // used with tagfunc
  163 } taggy_T;
  164 
  165 /*
  166  * Structure that contains all options that are local to a window.
  167  * Used twice in a window: for the current buffer and for all buffers.
  168  * Also used in wininfo_T.
  169  */
  170 typedef struct
  171 {
  172 #ifdef FEAT_ARABIC
  173     int     wo_arab;
  174 # define w_p_arab w_onebuf_opt.wo_arab  // 'arabic'
  175 #endif
  176 #ifdef FEAT_LINEBREAK
  177     int     wo_bri;
  178 # define w_p_bri w_onebuf_opt.wo_bri    // 'breakindent'
  179     char_u  *wo_briopt;
  180 # define w_p_briopt w_onebuf_opt.wo_briopt // 'breakindentopt'
  181 #endif
  182     char_u  *wo_wcr;
  183 # define w_p_wcr w_onebuf_opt.wo_wcr    // 'wincolor'
  184 #ifdef FEAT_DIFF
  185     int     wo_diff;
  186 # define w_p_diff w_onebuf_opt.wo_diff  // 'diff'
  187 #endif
  188 #ifdef FEAT_FOLDING
  189     long    wo_fdc;
  190 # define w_p_fdc w_onebuf_opt.wo_fdc    // 'foldcolumn'
  191     int     wo_fdc_save;
  192 # define w_p_fdc_save w_onebuf_opt.wo_fdc_save  // 'foldenable' saved for diff mode
  193     int     wo_fen;
  194 # define w_p_fen w_onebuf_opt.wo_fen    // 'foldenable'
  195     int     wo_fen_save;
  196 # define w_p_fen_save w_onebuf_opt.wo_fen_save  // 'foldenable' saved for diff mode
  197     char_u  *wo_fdi;
  198 # define w_p_fdi w_onebuf_opt.wo_fdi    // 'foldignore'
  199     long    wo_fdl;
  200 # define w_p_fdl w_onebuf_opt.wo_fdl    // 'foldlevel'
  201     int     wo_fdl_save;
  202 # define w_p_fdl_save w_onebuf_opt.wo_fdl_save  // 'foldlevel' state saved for diff mode
  203     char_u  *wo_fdm;
  204 # define w_p_fdm w_onebuf_opt.wo_fdm    // 'foldmethod'
  205     char_u  *wo_fdm_save;
  206 # define w_p_fdm_save w_onebuf_opt.wo_fdm_save  // 'fdm' saved for diff mode
  207     long    wo_fml;
  208 # define w_p_fml w_onebuf_opt.wo_fml    // 'foldminlines'
  209     long    wo_fdn;
  210 # define w_p_fdn w_onebuf_opt.wo_fdn    // 'foldnestmax'
  211 # ifdef FEAT_EVAL
  212     char_u  *wo_fde;
  213 # define w_p_fde w_onebuf_opt.wo_fde    // 'foldexpr'
  214     char_u  *wo_fdt;
  215 #  define w_p_fdt w_onebuf_opt.wo_fdt   // 'foldtext'
  216 # endif
  217     char_u  *wo_fmr;
  218 # define w_p_fmr w_onebuf_opt.wo_fmr    // 'foldmarker'
  219 #endif
  220 #ifdef FEAT_LINEBREAK
  221     int     wo_lbr;
  222 # define w_p_lbr w_onebuf_opt.wo_lbr    // 'linebreak'
  223 #endif
  224     int     wo_list;
  225 #define w_p_list w_onebuf_opt.wo_list   // 'list'
  226     int     wo_nu;
  227 #define w_p_nu w_onebuf_opt.wo_nu   // 'number'
  228     int     wo_rnu;
  229 #define w_p_rnu w_onebuf_opt.wo_rnu // 'relativenumber'
  230 #ifdef FEAT_LINEBREAK
  231     long    wo_nuw;
  232 # define w_p_nuw w_onebuf_opt.wo_nuw    // 'numberwidth'
  233 #endif
  234     int     wo_wfh;
  235 # define w_p_wfh w_onebuf_opt.wo_wfh    // 'winfixheight'
  236     int     wo_wfw;
  237 # define w_p_wfw w_onebuf_opt.wo_wfw    // 'winfixwidth'
  238 #if defined(FEAT_QUICKFIX)
  239     int     wo_pvw;
  240 # define w_p_pvw w_onebuf_opt.wo_pvw    // 'previewwindow'
  241 #endif
  242 #ifdef FEAT_RIGHTLEFT
  243     int     wo_rl;
  244 # define w_p_rl w_onebuf_opt.wo_rl  // 'rightleft'
  245     char_u  *wo_rlc;
  246 # define w_p_rlc w_onebuf_opt.wo_rlc    // 'rightleftcmd'
  247 #endif
  248     long    wo_scr;
  249 #define w_p_scr w_onebuf_opt.wo_scr // 'scroll'
  250 #ifdef FEAT_SPELL
  251     int     wo_spell;
  252 # define w_p_spell w_onebuf_opt.wo_spell // 'spell'
  253 #endif
  254 #ifdef FEAT_SYN_HL
  255     int     wo_cuc;
  256 # define w_p_cuc w_onebuf_opt.wo_cuc    // 'cursorcolumn'
  257     int     wo_cul;
  258 # define w_p_cul w_onebuf_opt.wo_cul    // 'cursorline'
  259     char_u  *wo_culopt;
  260 # define w_p_culopt w_onebuf_opt.wo_culopt  // 'cursorlineopt'
  261     char_u  *wo_cc;
  262 # define w_p_cc w_onebuf_opt.wo_cc  // 'colorcolumn'
  263 #endif
  264 #ifdef FEAT_LINEBREAK
  265     char_u  *wo_sbr;
  266 #define w_p_sbr w_onebuf_opt.wo_sbr // 'showbreak'
  267 #endif
  268 #ifdef FEAT_STL_OPT
  269     char_u  *wo_stl;
  270 #define w_p_stl w_onebuf_opt.wo_stl // 'statusline'
  271 #endif
  272     int     wo_scb;
  273 #define w_p_scb w_onebuf_opt.wo_scb // 'scrollbind'
  274     int     wo_diff_saved; // options were saved for starting diff mode
  275 #define w_p_diff_saved w_onebuf_opt.wo_diff_saved
  276     int     wo_scb_save;    // 'scrollbind' saved for diff mode
  277 #define w_p_scb_save w_onebuf_opt.wo_scb_save
  278     int     wo_wrap;
  279 #define w_p_wrap w_onebuf_opt.wo_wrap   // 'wrap'
  280 #ifdef FEAT_DIFF
  281     int     wo_wrap_save;   // 'wrap' state saved for diff mode
  282 # define w_p_wrap_save w_onebuf_opt.wo_wrap_save
  283 #endif
  284 #ifdef FEAT_CONCEAL
  285     char_u  *wo_cocu;       // 'concealcursor'
  286 # define w_p_cocu w_onebuf_opt.wo_cocu
  287     long    wo_cole;        // 'conceallevel'
  288 # define w_p_cole w_onebuf_opt.wo_cole
  289 #endif
  290     int     wo_crb;
  291 #define w_p_crb w_onebuf_opt.wo_crb // 'cursorbind'
  292     int     wo_crb_save;    // 'cursorbind' state saved for diff mode
  293 #define w_p_crb_save w_onebuf_opt.wo_crb_save
  294 #ifdef FEAT_SIGNS
  295     char_u  *wo_scl;
  296 # define w_p_scl w_onebuf_opt.wo_scl    // 'signcolumn'
  297 #endif
  298 #ifdef FEAT_TERMINAL
  299     char_u  *wo_twk;
  300 # define w_p_twk w_onebuf_opt.wo_twk    // 'termwinkey'
  301     char_u  *wo_tws;
  302 # define w_p_tws w_onebuf_opt.wo_tws    // 'termwinsize'
  303 #endif
  304 
  305 #ifdef FEAT_EVAL
  306     sctx_T  wo_script_ctx[WV_COUNT];    // SCTXs for window-local options
  307 # define w_p_script_ctx w_onebuf_opt.wo_script_ctx
  308 #endif
  309 } winopt_T;
  310 
  311 /*
  312  * Window info stored with a buffer.
  313  *
  314  * Two types of info are kept for a buffer which are associated with a
  315  * specific window:
  316  * 1. Each window can have a different line number associated with a buffer.
  317  * 2. The window-local options for a buffer work in a similar way.
  318  * The window-info is kept in a list at b_wininfo.  It is kept in
  319  * most-recently-used order.
  320  */
  321 struct wininfo_S
  322 {
  323     wininfo_T   *wi_next;   // next entry or NULL for last entry
  324     wininfo_T   *wi_prev;   // previous entry or NULL for first entry
  325     win_T   *wi_win;    // pointer to window that did set wi_fpos
  326     pos_T   wi_fpos;    // last cursor position in the file
  327     int     wi_optset;  // TRUE when wi_opt has useful values
  328     winopt_T    wi_opt;     // local window options
  329 #ifdef FEAT_FOLDING
  330     int     wi_fold_manual; // copy of w_fold_manual
  331     garray_T    wi_folds;   // clone of w_folds
  332 #endif
  333 };
  334 
  335 /*
  336  * Info used to pass info about a fold from the fold-detection code to the
  337  * code that displays the foldcolumn.
  338  */
  339 typedef struct foldinfo
  340 {
  341     int     fi_level;   // level of the fold; when this is zero the
  342                 // other fields are invalid
  343     int     fi_lnum;    // line number where fold starts
  344     int     fi_low_level;   // lowest fold level that starts in the same
  345                 // line
  346 } foldinfo_T;
  347 
  348 /*
  349  * Structure to store info about the Visual area.
  350  */
  351 typedef struct
  352 {
  353     pos_T   vi_start;   // start pos of last VIsual
  354     pos_T   vi_end;     // end position of last VIsual
  355     int     vi_mode;    // VIsual_mode of last VIsual
  356     colnr_T vi_curswant;    // MAXCOL from w_curswant
  357 } visualinfo_T;
  358 
  359 /*
  360  * structures used for undo
  361  */
  362 
  363 // One line saved for undo.  After the NUL terminated text there might be text
  364 // properties, thus ul_len can be larger than STRLEN(ul_line) + 1.
  365 typedef struct {
  366     char_u  *ul_line;   // text of the line
  367     long    ul_len;     // length of the line including NUL, plus text
  368                 // properties
  369 } undoline_T;
  370 
  371 typedef struct u_entry u_entry_T;
  372 typedef struct u_header u_header_T;
  373 struct u_entry
  374 {
  375     u_entry_T   *ue_next;   // pointer to next entry in list
  376     linenr_T    ue_top;     // number of line above undo block
  377     linenr_T    ue_bot;     // number of line below undo block
  378     linenr_T    ue_lcount;  // linecount when u_save called
  379     undoline_T  *ue_array;  // array of lines in undo block
  380     long    ue_size;    // number of lines in ue_array
  381 #ifdef U_DEBUG
  382     int     ue_magic;   // magic number to check allocation
  383 #endif
  384 };
  385 
  386 struct u_header
  387 {
  388     // The following have a pointer and a number. The number is used when
  389     // reading the undo file in u_read_undo()
  390     union {
  391     u_header_T *ptr;    // pointer to next undo header in list
  392     long       seq;
  393     } uh_next;
  394     union {
  395     u_header_T *ptr;    // pointer to previous header in list
  396     long       seq;
  397     } uh_prev;
  398     union {
  399     u_header_T *ptr;    // pointer to next header for alt. redo
  400     long       seq;
  401     } uh_alt_next;
  402     union {
  403     u_header_T *ptr;    // pointer to previous header for alt. redo
  404     long       seq;
  405     } uh_alt_prev;
  406     long    uh_seq;     // sequence number, higher == newer undo
  407     int     uh_walk;    // used by undo_time()
  408     u_entry_T   *uh_entry;  // pointer to first entry
  409     u_entry_T   *uh_getbot_entry; // pointer to where ue_bot must be set
  410     pos_T   uh_cursor;  // cursor position before saving
  411     long    uh_cursor_vcol;
  412     int     uh_flags;   // see below
  413     pos_T   uh_namedm[NMARKS];  // marks before undo/after redo
  414     visualinfo_T uh_visual; // Visual areas before undo/after redo
  415     time_T  uh_time;    // timestamp when the change was made
  416     long    uh_save_nr; // set when the file was saved after the
  417                 // changes in this block
  418 #ifdef U_DEBUG
  419     int     uh_magic;   // magic number to check allocation
  420 #endif
  421 };
  422 
  423 // values for uh_flags
  424 #define UH_CHANGED  0x01    // b_changed flag before undo/after redo
  425 #define UH_EMPTYBUF 0x02    // buffer was empty
  426 
  427 /*
  428  * structures used in undo.c
  429  */
  430 #define ALIGN_LONG  // longword alignment and use filler byte
  431 #define ALIGN_SIZE (sizeof(long))
  432 
  433 #define ALIGN_MASK (ALIGN_SIZE - 1)
  434 
  435 typedef struct m_info minfo_T;
  436 
  437 /*
  438  * structure used to link chunks in one of the free chunk lists.
  439  */
  440 struct m_info
  441 {
  442 #ifdef ALIGN_LONG
  443     long_u  m_size;     // size of the chunk (including m_info)
  444 #else
  445     short_u m_size;     // size of the chunk (including m_info)
  446 #endif
  447     minfo_T *m_next;    // pointer to next free chunk in the list
  448 };
  449 
  450 /*
  451  * things used in memfile.c
  452  */
  453 
  454 typedef struct block_hdr    bhdr_T;
  455 typedef struct memfile      memfile_T;
  456 typedef long            blocknr_T;
  457 
  458 /*
  459  * mf_hashtab_T is a chained hashtable with blocknr_T key and arbitrary
  460  * structures as items.  This is an intrusive data structure: we require
  461  * that items begin with mf_hashitem_T which contains the key and linked
  462  * list pointers.  List of items in each bucket is doubly-linked.
  463  */
  464 
  465 typedef struct mf_hashitem_S mf_hashitem_T;
  466 
  467 struct mf_hashitem_S
  468 {
  469     mf_hashitem_T   *mhi_next;
  470     mf_hashitem_T   *mhi_prev;
  471     blocknr_T       mhi_key;
  472 };
  473 
  474 #define MHT_INIT_SIZE   64
  475 
  476 typedef struct mf_hashtab_S
  477 {
  478     long_u      mht_mask;       // mask used for hash value (nr of items
  479                     // in array is "mht_mask" + 1)
  480     long_u      mht_count;      // nr of items inserted into hashtable
  481     mf_hashitem_T   **mht_buckets;  // points to mht_small_buckets or
  482                     //dynamically allocated array
  483     mf_hashitem_T   *mht_small_buckets[MHT_INIT_SIZE];   // initial buckets
  484     char        mht_fixed;      // non-zero value forbids growth
  485 } mf_hashtab_T;
  486 
  487 /*
  488  * for each (previously) used block in the memfile there is one block header.
  489  *
  490  * The block may be linked in the used list OR in the free list.
  491  * The used blocks are also kept in hash lists.
  492  *
  493  * The used list is a doubly linked list, most recently used block first.
  494  *  The blocks in the used list have a block of memory allocated.
  495  *  mf_used_count is the number of pages in the used list.
  496  * The hash lists are used to quickly find a block in the used list.
  497  * The free list is a single linked list, not sorted.
  498  *  The blocks in the free list have no block of memory allocated and
  499  *  the contents of the block in the file (if any) is irrelevant.
  500  */
  501 
  502 struct block_hdr
  503 {
  504     mf_hashitem_T bh_hashitem;      // header for hash table and key
  505 #define bh_bnum bh_hashitem.mhi_key // block number, part of bh_hashitem
  506 
  507     bhdr_T  *bh_next;       // next block_hdr in free or used list
  508     bhdr_T  *bh_prev;       // previous block_hdr in used list
  509     char_u  *bh_data;       // pointer to memory (for used block)
  510     int     bh_page_count;      // number of pages in this block
  511 
  512 #define BH_DIRTY    1
  513 #define BH_LOCKED   2
  514     char    bh_flags;       // BH_DIRTY or BH_LOCKED
  515 };
  516 
  517 /*
  518  * when a block with a negative number is flushed to the file, it gets
  519  * a positive number. Because the reference to the block is still the negative
  520  * number, we remember the translation to the new positive number in the
  521  * double linked trans lists. The structure is the same as the hash lists.
  522  */
  523 typedef struct nr_trans NR_TRANS;
  524 
  525 struct nr_trans
  526 {
  527     mf_hashitem_T nt_hashitem;      // header for hash table and key
  528 #define nt_old_bnum nt_hashitem.mhi_key // old, negative, number
  529 
  530     blocknr_T   nt_new_bnum;        // new, positive, number
  531 };
  532 
  533 
  534 typedef struct buffblock buffblock_T;
  535 typedef struct buffheader buffheader_T;
  536 
  537 /*
  538  * structure used to store one block of the stuff/redo/recording buffers
  539  */
  540 struct buffblock
  541 {
  542     buffblock_T *b_next;    // pointer to next buffblock
  543     char_u  b_str[1];   // contents (actually longer)
  544 };
  545 
  546 /*
  547  * header used for the stuff buffer and the redo buffer
  548  */
  549 struct buffheader
  550 {
  551     buffblock_T bh_first;   // first (dummy) block of list
  552     buffblock_T *bh_curr;   // buffblock for appending
  553     int     bh_index;   // index for reading
  554     int     bh_space;   // space in bh_curr for appending
  555 };
  556 
  557 typedef struct
  558 {
  559     buffheader_T sr_redobuff;
  560     buffheader_T sr_old_redobuff;
  561 } save_redo_T;
  562 
  563 /*
  564  * used for completion on the command line
  565  */
  566 typedef struct expand
  567 {
  568     char_u  *xp_pattern;        // start of item to expand
  569     int     xp_context;     // type of expansion
  570     int     xp_pattern_len;     // bytes in xp_pattern before cursor
  571 #if defined(FEAT_EVAL)
  572     char_u  *xp_arg;        // completion function
  573     sctx_T  xp_script_ctx;      // SCTX for completion function
  574 #endif
  575     int     xp_backslash;       // one of the XP_BS_ values
  576 #ifndef BACKSLASH_IN_FILENAME
  577     int     xp_shell;       // TRUE for a shell command, more
  578                     // characters need to be escaped
  579 #endif
  580     int     xp_numfiles;        // number of files found by
  581                     // file name completion
  582     int     xp_col;         // cursor position in line
  583     char_u  **xp_files;     // list of files
  584     char_u  *xp_line;       // text being completed
  585 } expand_T;
  586 
  587 /*
  588  * values for xp_backslash
  589  */
  590 #define XP_BS_NONE  0   // nothing special for backslashes
  591 #define XP_BS_ONE   1   // uses one backslash before a space
  592 #define XP_BS_THREE 2   // uses three backslashes before a space
  593 
  594 /*
  595  * Variables shared between getcmdline(), redrawcmdline() and others.
  596  * These need to be saved when using CTRL-R |, that's why they are in a
  597  * structure.
  598  */
  599 typedef struct
  600 {
  601     char_u  *cmdbuff;   // pointer to command line buffer
  602     int     cmdbufflen; // length of cmdbuff
  603     int     cmdlen;     // number of chars in command line
  604     int     cmdpos;     // current cursor position
  605     int     cmdspos;    // cursor column on screen
  606     int     cmdfirstc;  // ':', '/', '?', '=', '>' or NUL
  607     int     cmdindent;  // number of spaces before cmdline
  608     char_u  *cmdprompt; // message in front of cmdline
  609     int     cmdattr;    // attributes for prompt
  610     int     overstrike; // Typing mode on the command line.  Shared by
  611                 // getcmdline() and put_on_cmdline().
  612     expand_T    *xpc;       // struct being used for expansion, xp_pattern
  613                 // may point into cmdbuff
  614     int     xp_context; // type of expansion
  615 # ifdef FEAT_EVAL
  616     char_u  *xp_arg;    // user-defined expansion arg
  617     int     input_fn;   // when TRUE Invoked for input() function
  618 # endif
  619 } cmdline_info_T;
  620 
  621 /*
  622  * Command modifiers ":vertical", ":browse", ":confirm" and ":hide" set a flag.
  623  * This needs to be saved for recursive commands, put them in a structure for
  624  * easy manipulation.
  625  */
  626 typedef struct
  627 {
  628     int     hide;           // TRUE when ":hide" was used
  629 # ifdef FEAT_BROWSE_CMD
  630     int     browse;         // TRUE to invoke file dialog
  631 # endif
  632     int     split;          // flags for win_split()
  633     int     tab;            // > 0 when ":tab" was used
  634 # if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
  635     int     confirm;        // TRUE to invoke yes/no dialog
  636 # endif
  637     int     keepalt;        // TRUE when ":keepalt" was used
  638     int     keepmarks;      // TRUE when ":keepmarks" was used
  639     int     keepjumps;      // TRUE when ":keepjumps" was used
  640     int     lockmarks;      // TRUE when ":lockmarks" was used
  641     int     keeppatterns;       // TRUE when ":keeppatterns" was used
  642     int     noswapfile;     // TRUE when ":noswapfile" was used
  643     char_u  *save_ei;       // saved value of 'eventignore'
  644     regmatch_T  filter_regmatch;    // set by :filter /pat/
  645     int     filter_force;       // set for :filter!
  646 } cmdmod_T;
  647 
  648 #define MF_SEED_LEN 8
  649 
  650 struct memfile
  651 {
  652     char_u  *mf_fname;      // name of the file
  653     char_u  *mf_ffname;     // idem, full path
  654     int     mf_fd;          // file descriptor
  655     int     mf_flags;       // flags used when opening this memfile
  656     int     mf_reopen;      // mf_fd was closed, retry opening
  657     bhdr_T  *mf_free_first;     // first block_hdr in free list
  658     bhdr_T  *mf_used_first;     // mru block_hdr in used list
  659     bhdr_T  *mf_used_last;      // lru block_hdr in used list
  660     unsigned    mf_used_count;      // number of pages in used list
  661     unsigned    mf_used_count_max;  // maximum number of pages in memory
  662     mf_hashtab_T mf_hash;       // hash lists
  663     mf_hashtab_T mf_trans;      // trans lists
  664     blocknr_T   mf_blocknr_max;     // highest positive block number + 1
  665     blocknr_T   mf_blocknr_min;     // lowest negative block number - 1
  666     blocknr_T   mf_neg_count;       // number of negative blocks numbers
  667     blocknr_T   mf_infile_count;    // number of pages in the file
  668     unsigned    mf_page_size;       // number of bytes in a page
  669     int     mf_dirty;       // TRUE if there are dirty blocks
  670 #ifdef FEAT_CRYPT
  671     buf_T   *mf_buffer;     // buffer this memfile is for
  672     char_u  mf_seed[MF_SEED_LEN];   // seed for encryption
  673 
  674     // Values for key, method and seed used for reading data blocks when
  675     // updating for a newly set key or method. Only when mf_old_key != NULL.
  676     char_u  *mf_old_key;
  677     int     mf_old_cm;
  678     char_u  mf_old_seed[MF_SEED_LEN];
  679 #endif
  680 };
  681 
  682 /*
  683  * things used in memline.c
  684  */
  685 /*
  686  * When searching for a specific line, we remember what blocks in the tree
  687  * are the branches leading to that block. This is stored in ml_stack.  Each
  688  * entry is a pointer to info in a block (may be data block or pointer block)
  689  */
  690 typedef struct info_pointer
  691 {
  692     blocknr_T   ip_bnum;    // block number
  693     linenr_T    ip_low;     // lowest lnum in this block
  694     linenr_T    ip_high;    // highest lnum in this block
  695     int     ip_index;   // index for block with current lnum
  696 } infoptr_T;    // block/index pair
  697 
  698 #ifdef FEAT_BYTEOFF
  699 typedef struct ml_chunksize
  700 {
  701     int     mlcs_numlines;
  702     long    mlcs_totalsize;
  703 } chunksize_T;
  704 
  705 /*
  706  * Flags when calling ml_updatechunk()
  707  */
  708 # define ML_CHNK_ADDLINE 1
  709 # define ML_CHNK_DELLINE 2
  710 # define ML_CHNK_UPDLINE 3
  711 #endif
  712 
  713 /*
  714  * the memline structure holds all the information about a memline
  715  */
  716 typedef struct memline
  717 {
  718     linenr_T    ml_line_count;  // number of lines in the buffer
  719 
  720     memfile_T   *ml_mfp;    // pointer to associated memfile
  721 
  722     infoptr_T   *ml_stack;  // stack of pointer blocks (array of IPTRs)
  723     int     ml_stack_top;   // current top of ml_stack
  724     int     ml_stack_size;  // total number of entries in ml_stack
  725 
  726 #define ML_EMPTY    1   // empty buffer
  727 #define ML_LINE_DIRTY   2   // cached line was changed and allocated
  728 #define ML_LOCKED_DIRTY 4   // ml_locked was changed
  729 #define ML_LOCKED_POS   8   // ml_locked needs positive block number
  730     int     ml_flags;
  731 
  732     colnr_T ml_line_len;    // length of the cached line, including NUL
  733     linenr_T    ml_line_lnum;   // line number of cached line, 0 if not valid
  734     char_u  *ml_line_ptr;   // pointer to cached line
  735 
  736     bhdr_T  *ml_locked; // block used by last ml_get
  737     linenr_T    ml_locked_low;  // first line in ml_locked
  738     linenr_T    ml_locked_high; // last line in ml_locked
  739     int     ml_locked_lineadd;  // number of lines inserted in ml_locked
  740 #ifdef FEAT_BYTEOFF
  741     chunksize_T *ml_chunksize;
  742     int     ml_numchunks;
  743     int     ml_usedchunks;
  744 #endif
  745 } memline_T;
  746 
  747 // Values for the flags argument of ml_delete_flags().
  748 #define ML_DEL_MESSAGE      1   // may give a "No lines in buffer" message
  749 #define ML_DEL_UNDO     2   // called from undo, do not update textprops
  750 
  751 // Values for the flags argument of ml_append_int().
  752 #define ML_APPEND_NEW       1   // starting to edit a new file
  753 #define ML_APPEND_MARK      2   // mark the new line
  754 #define ML_APPEND_UNDO      4   // called from undo
  755 
  756 
  757 /*
  758  * Structure defining text properties.  These stick with the text.
  759  * When stored in memline they are after the text, ml_line_len is larger than
  760  * STRLEN(ml_line_ptr) + 1.
  761  */
  762 typedef struct textprop_S
  763 {
  764     colnr_T tp_col;     // start column (one based, in bytes)
  765     colnr_T tp_len;     // length in bytes
  766     int     tp_id;      // identifier
  767     int     tp_type;    // property type
  768     int     tp_flags;   // TP_FLAG_ values
  769 } textprop_T;
  770 
  771 #define TP_FLAG_CONT_NEXT   1   // property continues in next line
  772 #define TP_FLAG_CONT_PREV   2   // property was continued from prev line
  773 
  774 /*
  775  * Structure defining a property type.
  776  */
  777 typedef struct proptype_S
  778 {
  779     int     pt_id;      // value used for tp_id
  780     int     pt_type;    // number used for tp_type
  781     int     pt_hl_id;   // highlighting
  782     int     pt_priority;    // priority
  783     int     pt_flags;   // PT_FLAG_ values
  784     char_u  pt_name[1]; // property type name, actually longer
  785 } proptype_T;
  786 
  787 #define PT_FLAG_INS_START_INCL  1   // insert at start included in property
  788 #define PT_FLAG_INS_END_INCL    2   // insert at end included in property
  789 #define PT_FLAG_COMBINE     4   // combine with syntax highlight
  790 
  791 // Sign group
  792 typedef struct signgroup_S
  793 {
  794     int     sg_next_sign_id;    // next sign id for this group
  795     short_u sg_refcount;        // number of signs in this group
  796     char_u  sg_name[1];     // sign group name, actually longer
  797 } signgroup_T;
  798 
  799 typedef struct sign_entry sign_entry_T;
  800 struct sign_entry
  801 {
  802     int      se_id;     // unique identifier for each placed sign
  803     int      se_typenr; // typenr of sign
  804     int      se_priority;   // priority for highlighting
  805     linenr_T     se_lnum;   // line number which has this sign
  806     signgroup_T  *se_group; // sign group
  807     sign_entry_T *se_next;  // next entry in a list of signs
  808     sign_entry_T *se_prev;  // previous entry -- for easy reordering
  809 };
  810 
  811 /*
  812  * Sign attributes. Used by the screen refresh routines.
  813  */
  814 typedef struct sign_attrs_S {
  815     int     sat_typenr;
  816     void    *sat_icon;
  817     char_u  *sat_text;
  818     int     sat_texthl;
  819     int     sat_linehl;
  820 } sign_attrs_T;
  821 
  822 #if defined(FEAT_SIGNS) || defined(PROTO)
  823 // Macros to get the sign group structure from the group name
  824 #define SGN_KEY_OFF offsetof(signgroup_T, sg_name)
  825 #define HI2SG(hi)   ((signgroup_T *)((hi)->hi_key - SGN_KEY_OFF))
  826 
  827 // Default sign priority for highlighting
  828 #define SIGN_DEF_PRIO   10
  829 
  830 #endif
  831 
  832 /*
  833  * Argument list: Array of file names.
  834  * Used for the global argument list and the argument lists local to a window.
  835  */
  836 typedef struct arglist
  837 {
  838     garray_T    al_ga;      // growarray with the array of file names
  839     int     al_refcount;    // number of windows using this arglist
  840     int     id;     // id of this arglist
  841 } alist_T;
  842 
  843 /*
  844  * For each argument remember the file name as it was given, and the buffer
  845  * number that contains the expanded file name (required for when ":cd" is
  846  * used).
  847  */
  848 typedef struct argentry
  849 {
  850     char_u  *ae_fname;  // file name as specified
  851     int     ae_fnum;    // buffer number with expanded file name
  852 } aentry_T;
  853 
  854 #define ALIST(win)  (win)->w_alist
  855 #define GARGLIST    ((aentry_T *)global_alist.al_ga.ga_data)
  856 #define ARGLIST     ((aentry_T *)ALIST(curwin)->al_ga.ga_data)
  857 #define WARGLIST(wp)    ((aentry_T *)ALIST(wp)->al_ga.ga_data)
  858 #define AARGLIST(al)    ((aentry_T *)((al)->al_ga.ga_data))
  859 #define GARGCOUNT   (global_alist.al_ga.ga_len)
  860 #define ARGCOUNT    (ALIST(curwin)->al_ga.ga_len)
  861 #define WARGCOUNT(wp)   (ALIST(wp)->al_ga.ga_len)
  862 
  863 /*
  864  * A list used for saving values of "emsg_silent".  Used by ex_try() to save the
  865  * value of "emsg_silent" if it was non-zero.  When this is done, the CSF_SILENT
  866  * flag below is set.
  867  */
  868 
  869 typedef struct eslist_elem eslist_T;
  870 struct eslist_elem
  871 {
  872     int     saved_emsg_silent;  // saved value of "emsg_silent"
  873     eslist_T    *next;          // next element on the list
  874 };
  875 
  876 /*
  877  * For conditional commands a stack is kept of nested conditionals.
  878  * When cs_idx < 0, there is no conditional command.
  879  */
  880 #define CSTACK_LEN  50
  881 
  882 typedef struct {
  883     short   cs_flags[CSTACK_LEN];   // CSF_ flags
  884     char    cs_pending[CSTACK_LEN]; // CSTP_: what's pending in ":finally"
  885     union {
  886     void    *csp_rv[CSTACK_LEN];    // return typeval for pending return
  887     void    *csp_ex[CSTACK_LEN];    // exception for pending throw
  888     }       cs_pend;
  889     void    *cs_forinfo[CSTACK_LEN]; // info used by ":for"
  890     int     cs_line[CSTACK_LEN];    // line nr of ":while"/":for" line
  891     int     cs_idx;         // current entry, or -1 if none
  892     int     cs_looplevel;       // nr of nested ":while"s and ":for"s
  893     int     cs_trylevel;        // nr of nested ":try"s
  894     eslist_T    *cs_emsg_silent_list;   // saved values of "emsg_silent"
  895     char    cs_lflags;      // loop flags: CSL_ flags
  896 } cstack_T;
  897 # define cs_rettv   cs_pend.csp_rv
  898 # define cs_exception   cs_pend.csp_ex
  899 
  900 // There is no CSF_IF, the lack of CSF_WHILE, CSF_FOR and CSF_TRY means ":if"
  901 // was used.
  902 # define CSF_TRUE   0x0001  // condition was TRUE
  903 # define CSF_ACTIVE 0x0002  // current state is active
  904 # define CSF_ELSE   0x0004  // ":else" has been passed
  905 # define CSF_WHILE  0x0008  // is a ":while"
  906 # define CSF_FOR    0x0010  // is a ":for"
  907 
  908 # define CSF_TRY    0x0100  // is a ":try"
  909 # define CSF_FINALLY    0x0200  // ":finally" has been passed
  910 # define CSF_THROWN 0x0400  // exception thrown to this try conditional
  911 # define CSF_CAUGHT 0x0800  // exception caught by this try conditional
  912 # define CSF_SILENT 0x1000  // "emsg_silent" reset by ":try"
  913 // Note that CSF_ELSE is only used when CSF_TRY and CSF_WHILE are unset
  914 // (an ":if"), and CSF_SILENT is only used when CSF_TRY is set.
  915 
  916 /*
  917  * What's pending for being reactivated at the ":endtry" of this try
  918  * conditional:
  919  */
  920 # define CSTP_NONE  0   // nothing pending in ":finally" clause
  921 # define CSTP_ERROR 1   // an error is pending
  922 # define CSTP_INTERRUPT 2   // an interrupt is pending
  923 # define CSTP_THROW 4   // a throw is pending
  924 # define CSTP_BREAK 8   // ":break" is pending
  925 # define CSTP_CONTINUE  16  // ":continue" is pending
  926 # define CSTP_RETURN    24  // ":return" is pending
  927 # define CSTP_FINISH    32  // ":finish" is pending
  928 
  929 /*
  930  * Flags for the cs_lflags item in cstack_T.
  931  */
  932 # define CSL_HAD_LOOP    1  // just found ":while" or ":for"
  933 # define CSL_HAD_ENDLOOP 2  // just found ":endwhile" or ":endfor"
  934 # define CSL_HAD_CONT    4  // just found ":continue"
  935 # define CSL_HAD_FINA    8  // just found ":finally"
  936 
  937 /*
  938  * A list of error messages that can be converted to an exception.  "throw_msg"
  939  * is only set in the first element of the list.  Usually, it points to the
  940  * original message stored in that element, but sometimes it points to a later
  941  * message in the list.  See cause_errthrow().
  942  */
  943 typedef struct msglist msglist_T;
  944 struct msglist
  945 {
  946     char    *msg;       // original message, allocated
  947     char    *throw_msg; // msg to throw: usually original one
  948     char_u  *sfile;     // value from estack_sfile(), allocated
  949     long    slnum;      // line number for "sfile"
  950     msglist_T   *next;      // next of several messages in a row
  951 };
  952 
  953 /*
  954  * The exception types.
  955  */
  956 typedef enum
  957 {
  958     ET_USER,        // exception caused by ":throw" command
  959     ET_ERROR,       // error exception
  960     ET_INTERRUPT,   // interrupt exception triggered by Ctrl-C
  961 } except_type_T;
  962 
  963 /*
  964  * Structure describing an exception.
  965  * (don't use "struct exception", it's used by the math library).
  966  */
  967 typedef struct vim_exception except_T;
  968 struct vim_exception
  969 {
  970     except_type_T   type;       // exception type
  971     char        *value;     // exception value
  972     struct msglist  *messages;  // message(s) causing error exception
  973     char_u      *throw_name;    // name of the throw point
  974     linenr_T        throw_lnum; // line number of the throw point
  975     except_T        *caught;    // next exception on the caught stack
  976 };
  977 
  978 /*
  979  * Structure to save the error/interrupt/exception state between calls to
  980  * enter_cleanup() and leave_cleanup().  Must be allocated as an automatic
  981  * variable by the (common) caller of these functions.
  982  */
  983 typedef struct cleanup_stuff cleanup_T;
  984 struct cleanup_stuff
  985 {
  986     int pending;        // error/interrupt/exception state
  987     except_T *exception;    // exception value
  988 };
  989 
  990 #ifdef FEAT_SYN_HL
  991 // struct passed to in_id_list()
  992 struct sp_syn
  993 {
  994     int     inc_tag;    // ":syn include" unique tag
  995     short   id;     // highlight group ID of item
  996     short   *cont_in_list;  // cont.in group IDs, if non-zero
  997 };
  998 
  999 /*
 1000  * Each keyword has one keyentry, which is linked in a hash list.
 1001  */
 1002 typedef struct keyentry keyentry_T;
 1003 
 1004 struct keyentry
 1005 {
 1006     keyentry_T  *ke_next;   // next entry with identical "keyword[]"
 1007     struct sp_syn k_syn;    // struct passed to in_id_list()
 1008     short   *next_list; // ID list for next match (if non-zero)
 1009     int     flags;
 1010     int     k_char;     // conceal substitute character
 1011     char_u  keyword[1]; // actually longer
 1012 };
 1013 
 1014 /*
 1015  * Struct used to store one state of the state stack.
 1016  */
 1017 typedef struct buf_state
 1018 {
 1019     int         bs_idx;  // index of pattern
 1020     int         bs_flags;    // flags for pattern
 1021 #ifdef FEAT_CONCEAL
 1022     int         bs_seqnr;    // stores si_seqnr
 1023     int         bs_cchar;    // stores si_cchar
 1024 #endif
 1025     reg_extmatch_T *bs_extmatch; // external matches from start pattern
 1026 } bufstate_T;
 1027 
 1028 /*
 1029  * syn_state contains the syntax state stack for the start of one line.
 1030  * Used by b_sst_array[].
 1031  */
 1032 typedef struct syn_state synstate_T;
 1033 
 1034 struct syn_state
 1035 {
 1036     synstate_T  *sst_next;  // next entry in used or free list
 1037     linenr_T    sst_lnum;   // line number for this state
 1038     union
 1039     {
 1040     bufstate_T  sst_stack[SST_FIX_STATES]; // short state stack
 1041     garray_T    sst_ga; // growarray for long state stack
 1042     } sst_union;
 1043     int     sst_next_flags; // flags for sst_next_list
 1044     int     sst_stacksize;  // number of states on the stack
 1045     short   *sst_next_list; // "nextgroup" list in this state
 1046                 // (this is a copy, don't free it!
 1047     disptick_T  sst_tick;   // tick when last displayed
 1048     linenr_T    sst_change_lnum;// when non-zero, change in this line
 1049                 // may have made the state invalid
 1050 };
 1051 #endif // FEAT_SYN_HL
 1052 
 1053 #define MAX_HL_ID       20000   // maximum value for a highlight ID.
 1054 
 1055 /*
 1056  * Structure shared between syntax.c, screen.c and gui_x11.c.
 1057  */
 1058 typedef struct attr_entry
 1059 {
 1060     short       ae_attr;        // HL_BOLD, etc.
 1061     union
 1062     {
 1063     struct
 1064     {
 1065         char_u      *start; // start escape sequence
 1066         char_u      *stop;  // stop escape sequence
 1067     } term;
 1068     struct
 1069     {
 1070         // These colors need to be > 8 bits to hold 256.
 1071         short_u     fg_color;   // foreground color number
 1072         short_u     bg_color;   // background color number
 1073         short_u     ul_color;   // underline color number
 1074 # ifdef FEAT_TERMGUICOLORS
 1075         guicolor_T      fg_rgb; // foreground color RGB
 1076         guicolor_T      bg_rgb; // background color RGB
 1077         guicolor_T      ul_rgb; // underline color RGB
 1078 # endif
 1079     } cterm;
 1080 # ifdef FEAT_GUI
 1081     struct
 1082     {
 1083         guicolor_T      fg_color;   // foreground color handle
 1084         guicolor_T      bg_color;   // background color handle
 1085         guicolor_T      sp_color;   // special color handle
 1086         GuiFont     font;   // font handle
 1087 #  ifdef FEAT_XFONTSET
 1088         GuiFontset      fontset;    // fontset handle
 1089 #  endif
 1090     } gui;
 1091 # endif
 1092     } ae_u;
 1093 } attrentry_T;
 1094 
 1095 #ifdef USE_ICONV
 1096 # ifdef HAVE_ICONV_H
 1097 #  include <iconv.h>
 1098 # else
 1099 #  if defined(MACOS_X)
 1100 #   include <sys/errno.h>
 1101 #   ifndef EILSEQ
 1102 #    define EILSEQ ENOENT // Early MacOS X does not have EILSEQ
 1103 #   endif
 1104 typedef struct _iconv_t *iconv_t;
 1105 #  else
 1106 #   include <errno.h>
 1107 #  endif
 1108 typedef void *iconv_t;
 1109 # endif
 1110 #endif
 1111 
 1112 /*
 1113  * Used for the typeahead buffer: typebuf.
 1114  */
 1115 typedef struct
 1116 {
 1117     char_u  *tb_buf;    // buffer for typed characters
 1118     char_u  *tb_noremap;    // mapping flags for characters in tb_buf[]
 1119     int     tb_buflen;  // size of tb_buf[]
 1120     int     tb_off;     // current position in tb_buf[]
 1121     int     tb_len;     // number of valid bytes in tb_buf[]
 1122     int     tb_maplen;  // nr of mapped bytes in tb_buf[]
 1123     int     tb_silent;  // nr of silently mapped bytes in tb_buf[]
 1124     int     tb_no_abbr_cnt; // nr of bytes without abbrev. in tb_buf[]
 1125     int     tb_change_cnt;  // nr of time tb_buf was changed; never zero
 1126 } typebuf_T;
 1127 
 1128 // Struct to hold the saved typeahead for save_typeahead().
 1129 typedef struct
 1130 {
 1131     typebuf_T       save_typebuf;
 1132     int         typebuf_valid;      // TRUE when save_typebuf valid
 1133     int         old_char;
 1134     int         old_mod_mask;
 1135     buffheader_T    save_readbuf1;
 1136     buffheader_T    save_readbuf2;
 1137 #ifdef USE_INPUT_BUF
 1138     char_u      *save_inputbuf;
 1139 #endif
 1140 } tasave_T;
 1141 
 1142 /*
 1143  * Used for conversion of terminal I/O and script files.
 1144  */
 1145 typedef struct
 1146 {
 1147     int     vc_type;    // zero or one of the CONV_ values
 1148     int     vc_factor;  // max. expansion factor
 1149 # ifdef MSWIN
 1150     int     vc_cpfrom;  // codepage to convert from (CONV_CODEPAGE)
 1151     int     vc_cpto;    // codepage to convert to (CONV_CODEPAGE)
 1152 # endif
 1153 # ifdef USE_ICONV
 1154     iconv_t vc_fd;      // for CONV_ICONV
 1155 # endif
 1156     int     vc_fail;    // fail for invalid char, don't use '?'
 1157 } vimconv_T;
 1158 
 1159 /*
 1160  * Structure used for the command line history.
 1161  */
 1162 typedef struct hist_entry
 1163 {
 1164     int     hisnum;     // identifying number
 1165     int     viminfo;    // when TRUE hisstr comes from viminfo
 1166     char_u  *hisstr;    // actual entry, separator char after the NUL
 1167     time_t  time_set;   // when it was typed, zero if unknown
 1168 } histentry_T;
 1169 
 1170 #define CONV_NONE       0
 1171 #define CONV_TO_UTF8        1
 1172 #define CONV_9_TO_UTF8      2
 1173 #define CONV_TO_LATIN1      3
 1174 #define CONV_TO_LATIN9      4
 1175 #define CONV_ICONV      5
 1176 #ifdef MSWIN
 1177 # define CONV_CODEPAGE      10  // codepage -> codepage
 1178 #endif
 1179 #ifdef MACOS_X
 1180 # define CONV_MAC_LATIN1    20
 1181 # define CONV_LATIN1_MAC    21
 1182 # define CONV_MAC_UTF8      22
 1183 # define CONV_UTF8_MAC      23
 1184 #endif
 1185 
 1186 /*
 1187  * Structure used for mappings and abbreviations.
 1188  */
 1189 typedef struct mapblock mapblock_T;
 1190 struct mapblock
 1191 {
 1192     mapblock_T  *m_next;    // next mapblock in list
 1193     char_u  *m_keys;    // mapped from, lhs
 1194     char_u  *m_str;     // mapped to, rhs
 1195     char_u  *m_orig_str;    // rhs as entered by the user
 1196     int     m_keylen;   // strlen(m_keys)
 1197     int     m_mode;     // valid mode
 1198     int     m_simplified;   // m_keys was simplified, do not use this map
 1199                 // if seenModifyOtherKeys is TRUE
 1200     int     m_noremap;  // if non-zero no re-mapping for m_str
 1201     char    m_silent;   // <silent> used, don't echo commands
 1202     char    m_nowait;   // <nowait> used
 1203 #ifdef FEAT_EVAL
 1204     char    m_expr;     // <expr> used, m_str is an expression
 1205     sctx_T  m_script_ctx;   // SCTX where map was defined
 1206 #endif
 1207 };
 1208 
 1209 /*
 1210  * Used for highlighting in the status line.
 1211  */
 1212 struct stl_hlrec
 1213 {
 1214     char_u  *start;
 1215     int     userhl;     // 0: no HL, 1-9: User HL, < 0 for syn ID
 1216 };
 1217 
 1218 
 1219 /*
 1220  * Syntax items - usually buffer-specific.
 1221  */
 1222 
 1223 /*
 1224  * Item for a hashtable.  "hi_key" can be one of three values:
 1225  * NULL:       Never been used
 1226  * HI_KEY_REMOVED: Entry was removed
 1227  * Otherwise:      Used item, pointer to the actual key; this usually is
 1228  *         inside the item, subtract an offset to locate the item.
 1229  *         This reduces the size of hashitem by 1/3.
 1230  */
 1231 typedef struct hashitem_S
 1232 {
 1233     long_u  hi_hash;    // cached hash number of hi_key
 1234     char_u  *hi_key;
 1235 } hashitem_T;
 1236 
 1237 // The address of "hash_removed" is used as a magic number for hi_key to
 1238 // indicate a removed item.
 1239 #define HI_KEY_REMOVED &hash_removed
 1240 #define HASHITEM_EMPTY(hi) ((hi)->hi_key == NULL || (hi)->hi_key == &hash_removed)
 1241 
 1242 // Initial size for a hashtable.  Our items are relatively small and growing
 1243 // is expensive, thus use 16 as a start.  Must be a power of 2.
 1244 // This allows for storing 10 items (2/3 of 16) before a resize is needed.
 1245 #define HT_INIT_SIZE 16
 1246 
 1247 typedef struct hashtable_S
 1248 {
 1249     long_u  ht_mask;    // mask used for hash value (nr of items in
 1250                 // array is "ht_mask" + 1)
 1251     long_u  ht_used;    // number of items used
 1252     long_u  ht_filled;  // number of items used + removed
 1253     int     ht_changed; // incremented when adding or removing an item
 1254     int     ht_locked;  // counter for hash_lock()
 1255     int     ht_error;   // when set growing failed, can't add more
 1256                 // items before growing works
 1257     hashitem_T  *ht_array;  // points to the array, allocated when it's
 1258                 // not "ht_smallarray"
 1259     hashitem_T  ht_smallarray[HT_INIT_SIZE];   // initial array
 1260 } hashtab_T;
 1261 
 1262 typedef long_u hash_T;      // Type for hi_hash
 1263 
 1264 
 1265 // Use 64-bit Number.
 1266 #ifdef MSWIN
 1267 # ifdef PROTO
 1268    // workaround for cproto that doesn't recognize __int64
 1269    typedef long         varnumber_T;
 1270    typedef unsigned long    uvarnumber_T;
 1271 #  define VARNUM_MIN        LONG_MIN
 1272 #  define VARNUM_MAX        LONG_MAX
 1273 #  define UVARNUM_MAX       ULONG_MAX
 1274 # else
 1275    typedef __int64      varnumber_T;
 1276    typedef unsigned __int64 uvarnumber_T;
 1277 #  define VARNUM_MIN        _I64_MIN
 1278 #  define VARNUM_MAX        _I64_MAX
 1279 #  define UVARNUM_MAX       _UI64_MAX
 1280 # endif
 1281 #elif defined(HAVE_NO_LONG_LONG)
 1282 # if defined(HAVE_STDINT_H)
 1283    typedef int64_t      varnumber_T;
 1284    typedef uint64_t     uvarnumber_T;
 1285 #  define VARNUM_MIN        INT64_MIN
 1286 #  define VARNUM_MAX        INT64_MAX
 1287 #  define UVARNUM_MAX       UINT64_MAX
 1288 # else
 1289    // this may cause trouble for code that depends on 64 bit ints
 1290    typedef long         varnumber_T;
 1291    typedef unsigned long    uvarnumber_T;
 1292 #  define VARNUM_MIN        LONG_MIN
 1293 #  define VARNUM_MAX        LONG_MAX
 1294 #  define UVARNUM_MAX       ULONG_MAX
 1295 # endif
 1296 #else
 1297   typedef long long     varnumber_T;
 1298   typedef unsigned long long    uvarnumber_T;
 1299 # ifdef LLONG_MIN
 1300 #  define VARNUM_MIN        LLONG_MIN
 1301 #  define VARNUM_MAX        LLONG_MAX
 1302 #  define UVARNUM_MAX       ULLONG_MAX
 1303 # else
 1304 #  define VARNUM_MIN        LONG_LONG_MIN
 1305 #  define VARNUM_MAX        LONG_LONG_MAX
 1306 #  define UVARNUM_MAX       ULONG_LONG_MAX
 1307 # endif
 1308 #endif
 1309 
 1310 // On rare systems "char" is unsigned, sometimes we really want a signed 8-bit
 1311 // value.
 1312 typedef signed char int8_T;
 1313 
 1314 typedef double  float_T;
 1315 
 1316 typedef struct listvar_S list_T;
 1317 typedef struct dictvar_S dict_T;
 1318 typedef struct partial_S partial_T;
 1319 typedef struct blobvar_S blob_T;
 1320 
 1321 // Struct that holds both a normal function name and a partial_T, as used for a
 1322 // callback argument.
 1323 // When used temporarily "cb_name" is not allocated.  The refcounts to either
 1324 // the function or the partial are incremented and need to be decremented
 1325 // later with free_callback().
 1326 typedef struct {
 1327     char_u  *cb_name;
 1328     partial_T   *cb_partial;
 1329     int     cb_free_name;       // cb_name was allocated
 1330 } callback_T;
 1331 
 1332 typedef struct isn_S isn_T;     // instruction
 1333 typedef struct dfunc_S dfunc_T;     // :def function
 1334 
 1335 typedef struct jobvar_S job_T;
 1336 typedef struct readq_S readq_T;
 1337 typedef struct writeq_S writeq_T;
 1338 typedef struct jsonq_S jsonq_T;
 1339 typedef struct cbq_S cbq_T;
 1340 typedef struct channel_S channel_T;
 1341 typedef struct cctx_S cctx_T;
 1342 
 1343 typedef enum
 1344 {
 1345     VAR_UNKNOWN = 0,    // not set, any type or "void" allowed
 1346     VAR_ANY,        // used for "any" type
 1347     VAR_VOID,       // no value (function not returning anything)
 1348     VAR_BOOL,       // "v_number" is used: VVAL_TRUE or VVAL_FALSE
 1349     VAR_SPECIAL,    // "v_number" is used: VVAL_NULL or VVAL_NONE
 1350     VAR_NUMBER,     // "v_number" is used
 1351     VAR_FLOAT,      // "v_float" is used
 1352     VAR_STRING,     // "v_string" is used
 1353     VAR_BLOB,       // "v_blob" is used
 1354     VAR_FUNC,       // "v_string" is function name
 1355     VAR_PARTIAL,    // "v_partial" is used
 1356     VAR_LIST,       // "v_list" is used
 1357     VAR_DICT,       // "v_dict" is used
 1358     VAR_JOB,        // "v_job" is used
 1359     VAR_CHANNEL,    // "v_channel" is used
 1360 } vartype_T;
 1361 
 1362 // A type specification.
 1363 typedef struct type_S type_T;
 1364 struct type_S {
 1365     vartype_T       tt_type;
 1366     int8_T      tt_argcount;    // for func, incl. vararg, -1 for unknown
 1367     char        tt_min_argcount; // number of non-optional arguments
 1368     char        tt_flags;       // TTFLAG_ values
 1369     type_T      *tt_member;     // for list, dict, func return type
 1370     type_T      **tt_args;      // func argument types, allocated
 1371 };
 1372 
 1373 #define TTFLAG_VARARGS  1       // func args ends with "..."
 1374 #define TTFLAG_OPTARG   2       // func arg type with "?"
 1375 
 1376 /*
 1377  * Structure to hold an internal variable without a name.
 1378  */
 1379 typedef struct
 1380 {
 1381     vartype_T   v_type;
 1382     char    v_lock;     // see below: VAR_LOCKED, VAR_FIXED
 1383     union
 1384     {
 1385     varnumber_T v_number;   // number value
 1386 #ifdef FEAT_FLOAT
 1387     float_T     v_float;    // floating number value
 1388 #endif
 1389     char_u      *v_string;  // string value (can be NULL!)
 1390     list_T      *v_list;    // list value (can be NULL!)
 1391     dict_T      *v_dict;    // dict value (can be NULL!)
 1392     partial_T   *v_partial; // closure: function with args
 1393 #ifdef FEAT_JOB_CHANNEL
 1394     job_T       *v_job;     // job value (can be NULL!)
 1395     channel_T   *v_channel; // channel value (can be NULL!)
 1396 #endif
 1397     blob_T      *v_blob;    // blob value (can be NULL!)
 1398     }       vval;
 1399 } typval_T;
 1400 
 1401 // Values for "dv_scope".
 1402 #define VAR_SCOPE     1 // a:, v:, s:, etc. scope dictionaries
 1403 #define VAR_DEF_SCOPE 2 // l:, g: scope dictionaries: here funcrefs are not
 1404             // allowed to mask existing functions
 1405 
 1406 // Values for "v_lock".
 1407 #define VAR_LOCKED  1   // locked with lock(), can use unlock()
 1408 #define VAR_FIXED   2   // locked forever
 1409 
 1410 /*
 1411  * Structure to hold an item of a list: an internal variable without a name.
 1412  */
 1413 typedef struct listitem_S listitem_T;
 1414 
 1415 struct listitem_S
 1416 {
 1417     listitem_T  *li_next;   // next item in list
 1418     listitem_T  *li_prev;   // previous item in list
 1419     typval_T    li_tv;      // type and value of the variable
 1420 };
 1421 
 1422 // Struct used by those that are using an item in a list.
 1423 typedef struct listwatch_S listwatch_T;
 1424 
 1425 struct listwatch_S
 1426 {
 1427     listitem_T      *lw_item;   // item being watched
 1428     listwatch_T     *lw_next;   // next watcher
 1429 };
 1430 
 1431 /*
 1432  * Structure to hold info about a list.
 1433  * Order of members is optimized to reduce padding.
 1434  * When created by range() it will at first have special value:
 1435  *  lv_first == &range_list_item;
 1436  * and use lv_start, lv_end, lv_stride.
 1437  */
 1438 struct listvar_S
 1439 {
 1440     listitem_T  *lv_first;  // first item, NULL if none
 1441     listwatch_T *lv_watch;  // first watcher, NULL if none
 1442     union {
 1443     struct {    // used for non-materialized range list:
 1444             // "lv_first" is &range_list_item
 1445         varnumber_T lv_start;
 1446         varnumber_T lv_end;
 1447         int     lv_stride;
 1448     } nonmat;
 1449     struct {    // used for materialized list
 1450         listitem_T  *lv_last;   // last item, NULL if none
 1451         listitem_T  *lv_idx_item;   // when not NULL item at index "lv_idx"
 1452         int     lv_idx;     // cached index of an item
 1453     } mat;
 1454     } lv_u;
 1455     list_T  *lv_copylist;   // copied list used by deepcopy()
 1456     list_T  *lv_used_next;  // next list in used lists list
 1457     list_T  *lv_used_prev;  // previous list in used lists list
 1458     int     lv_refcount;    // reference count
 1459     int     lv_len;     // number of items
 1460     int     lv_with_items;  // number of items following this struct that
 1461                 // should not be freed
 1462     int     lv_copyID;  // ID used by deepcopy()
 1463     char    lv_lock;    // zero, VAR_LOCKED, VAR_FIXED
 1464 };
 1465 
 1466 /*
 1467  * Static list with 10 items.  Use init_static_list() to initialize.
 1468  */
 1469 typedef struct {
 1470     list_T  sl_list;    // must be first
 1471     listitem_T  sl_items[10];
 1472 } staticList10_T;
 1473 
 1474 /*
 1475  * Structure to hold an item of a Dictionary.
 1476  * Also used for a variable.
 1477  * The key is copied into "di_key" to avoid an extra alloc/free for it.
 1478  */
 1479 struct dictitem_S
 1480 {
 1481     typval_T    di_tv;      // type and value of the variable
 1482     char_u  di_flags;   // DI_FLAGS_ flags (only used for variable)
 1483     char_u  di_key[1];  // key (actually longer!)
 1484 };
 1485 typedef struct dictitem_S dictitem_T;
 1486 
 1487 /*
 1488  * A dictitem with a 16 character key (plus NUL).  This is an efficient way to
 1489  * have a fixed-size dictitem.
 1490  */
 1491 #define DICTITEM16_KEY_LEN 16
 1492 struct dictitem16_S
 1493 {
 1494     typval_T    di_tv;      // type and value of the variable
 1495     char_u  di_flags;   // DI_FLAGS_ flags (only used for variable)
 1496     char_u  di_key[DICTITEM16_KEY_LEN + 1]; // key
 1497 };
 1498 typedef struct dictitem16_S dictitem16_T;
 1499 
 1500 // Flags for "di_flags"
 1501 #define DI_FLAGS_RO    0x01     // read-only variable
 1502 #define DI_FLAGS_RO_SBX    0x02     // read-only in the sandbox
 1503 #define DI_FLAGS_FIX       0x04     // fixed: no :unlet or remove()
 1504 #define DI_FLAGS_LOCK      0x08     // locked variable
 1505 #define DI_FLAGS_ALLOC     0x10     // separately allocated
 1506 #define DI_FLAGS_RELOAD    0x20     // set when script sourced again
 1507 
 1508 /*
 1509  * Structure to hold info about a Dictionary.
 1510  */
 1511 struct dictvar_S
 1512 {
 1513     char    dv_lock;    // zero, VAR_LOCKED, VAR_FIXED
 1514     char    dv_scope;   // zero, VAR_SCOPE, VAR_DEF_SCOPE
 1515     int     dv_refcount;    // reference count
 1516     int     dv_copyID;  // ID used by deepcopy()
 1517     hashtab_T   dv_hashtab; // hashtab that refers to the items
 1518     dict_T  *dv_copydict;   // copied dict used by deepcopy()
 1519     dict_T  *dv_used_next;  // next dict in used dicts list
 1520     dict_T  *dv_used_prev;  // previous dict in used dicts list
 1521 };
 1522 
 1523 /*
 1524  * Structure to hold info about a blob.
 1525  */
 1526 struct blobvar_S
 1527 {
 1528     garray_T    bv_ga;      // growarray with the data
 1529     int     bv_refcount;    // reference count
 1530     char    bv_lock;    // zero, VAR_LOCKED, VAR_FIXED
 1531 };
 1532 
 1533 typedef int (*cfunc_T)(int argcount, typval_T *argvars, typval_T *rettv, void *state);
 1534 typedef void (*cfunc_free_T)(void *state);
 1535 
 1536 #if defined(FEAT_EVAL) || defined(PROTO)
 1537 typedef struct funccall_S funccall_T;
 1538 
 1539 // values used for "uf_dfunc_idx"
 1540 typedef enum {
 1541     UF_NOT_COMPILED,
 1542     UF_TO_BE_COMPILED,
 1543     UF_COMPILING,
 1544     UF_COMPILED
 1545 } def_status_T;
 1546 
 1547 /*
 1548  * Structure to hold info for a user function.
 1549  * When adding a field check copy_func().
 1550  */
 1551 typedef struct
 1552 {
 1553     int     uf_varargs; // variable nr of arguments (old style)
 1554     int     uf_flags;   // FC_ flags
 1555     int     uf_calls;   // nr of active calls
 1556     int     uf_cleared; // func_clear() was already called
 1557     def_status_T uf_def_status; // UF_NOT_COMPILED, UF_TO_BE_COMPILED, etc.
 1558     int     uf_dfunc_idx;   // only valid if uf_def_status is UF_COMPILED
 1559     garray_T    uf_args;    // arguments, including optional arguments
 1560     garray_T    uf_def_args;    // default argument expressions
 1561 
 1562     // for :def (for :function uf_ret_type is NULL)
 1563     type_T  **uf_arg_types; // argument types (count == uf_args.ga_len)
 1564     type_T  *uf_ret_type;   // return type
 1565     garray_T    uf_type_list;   // types used in arg and return types
 1566     int     *uf_def_arg_idx; // instruction indexes for evaluating
 1567                 // uf_def_args; length: uf_def_args.ga_len + 1
 1568     char_u  *uf_va_name;    // name from "...name" or NULL
 1569     type_T  *uf_va_type;    // type from "...name: type" or NULL
 1570     type_T  *uf_func_type;  // type of the function, &t_func_any if unknown
 1571 # if defined(FEAT_LUA)
 1572     cfunc_T     uf_cb;      // callback function for cfunc
 1573     cfunc_free_T uf_cb_free;    // callback function to free cfunc
 1574     void        *uf_cb_state;   // state of uf_cb
 1575 # endif
 1576 
 1577     garray_T    uf_lines;   // function lines
 1578 # ifdef FEAT_PROFILE
 1579     int     uf_profiling;   // TRUE when func is being profiled
 1580     int     uf_prof_initialized;
 1581     // profiling the function as a whole
 1582     int     uf_tm_count;    // nr of calls
 1583     proftime_T  uf_tm_total;    // time spent in function + children
 1584     proftime_T  uf_tm_self; // time spent in function itself
 1585     proftime_T  uf_tm_children; // time spent in children this call
 1586     // profiling the function per line
 1587     int     *uf_tml_count;  // nr of times line was executed
 1588     proftime_T  *uf_tml_total;  // time spent in a line + children
 1589     proftime_T  *uf_tml_self;   // time spent in a line itself
 1590     proftime_T  uf_tml_start;   // start time for current line
 1591     proftime_T  uf_tml_children; // time spent in children for this line
 1592     proftime_T  uf_tml_wait;    // start wait time for current line
 1593     int     uf_tml_idx; // index of line being timed; -1 if none
 1594     int     uf_tml_execed;  // line being timed was executed
 1595 # endif
 1596     sctx_T  uf_script_ctx;  // SCTX where function was defined,
 1597                 // used for s: variables
 1598     int     uf_refcount;    // reference count, see func_name_refcount()
 1599 
 1600     funccall_T  *uf_scoped; // l: local variables for closure
 1601 
 1602     char_u  *uf_name_exp;   // if "uf_name[]" starts with SNR the name with
 1603                 // "<SNR>" as a string, otherwise NULL
 1604     char_u  uf_name[1]; // name of function (actually longer); can
 1605                 // start with <SNR>123_ (<SNR> is K_SPECIAL
 1606                 // KS_EXTRA KE_SNR)
 1607 } ufunc_T;
 1608 
 1609 // flags used in uf_flags
 1610 #define FC_ABORT    0x01    // abort function on error
 1611 #define FC_RANGE    0x02    // function accepts range
 1612 #define FC_DICT     0x04    // Dict function, uses "self"
 1613 #define FC_CLOSURE  0x08    // closure, uses outer scope variables
 1614 #define FC_DELETED  0x10    // :delfunction used while uf_refcount > 0
 1615 #define FC_REMOVED  0x20    // function redefined while uf_refcount > 0
 1616 #define FC_SANDBOX  0x40    // function defined in the sandbox
 1617 #define FC_DEAD     0x80    // function kept only for reference to dfunc
 1618 #define FC_EXPORT   0x100   // "export def Func()"
 1619 #define FC_NOARGS   0x200   // no a: variables in lambda
 1620 #define FC_VIM9     0x400   // defined in vim9 script file
 1621 #define FC_CFUNC    0x800   // defined as Lua C func
 1622 #define FC_COPY     0x1000  // copy of another function by copy_func()
 1623 
 1624 #define MAX_FUNC_ARGS   20  // maximum number of function arguments
 1625 #define VAR_SHORT_LEN   20  // short variable name length
 1626 #define FIXVAR_CNT  12  // number of fixed variables
 1627 
 1628 /*
 1629  * Structure to hold info for a function that is currently being executed.
 1630  */
 1631 struct funccall_S
 1632 {
 1633     ufunc_T *func;      // function being called
 1634     int     linenr;     // next line to be executed
 1635     int     returned;   // ":return" used
 1636     struct          // fixed variables for arguments
 1637     {
 1638     dictitem_T  var;        // variable (without room for name)
 1639     char_u  room[VAR_SHORT_LEN];    // room for the name
 1640     } fixvar[FIXVAR_CNT];
 1641     dict_T  l_vars;     // l: local function variables
 1642     dictitem_T  l_vars_var; // variable for l: scope
 1643     dict_T  l_avars;    // a: argument variables
 1644     dictitem_T  l_avars_var;    // variable for a: scope
 1645     list_T  l_varlist;  // list for a:000
 1646     listitem_T  l_listitems[MAX_FUNC_ARGS]; // listitems for a:000
 1647     typval_T    *rettv;     // return value
 1648     linenr_T    breakpoint; // next line with breakpoint or zero
 1649     int     dbg_tick;   // debug_tick when breakpoint was set
 1650     int     level;      // top nesting level of executed function
 1651 #ifdef FEAT_PROFILE
 1652     proftime_T  prof_child; // time spent in a child
 1653 #endif
 1654     funccall_T  *caller;    // calling function or NULL
 1655 
 1656     // for closure
 1657     int     fc_refcount;    // number of user functions that reference this
 1658                 // funccal
 1659     int     fc_copyID;  // for garbage collection
 1660     garray_T    fc_funcs;   // list of ufunc_T* which keep a reference to
 1661                 // "func"
 1662 };
 1663 
 1664 /*
 1665  * Struct used by trans_function_name()
 1666  */
 1667 typedef struct
 1668 {
 1669     dict_T  *fd_dict;   // Dictionary used
 1670     char_u  *fd_newkey; // new key in "dict" in allocated memory
 1671     dictitem_T  *fd_di;     // Dictionary item used
 1672 } funcdict_T;
 1673 
 1674 typedef struct funccal_entry funccal_entry_T;
 1675 struct funccal_entry {
 1676     void        *top_funccal;
 1677     funccal_entry_T *next;
 1678 };
 1679 
 1680 // From user function to hashitem and back.
 1681 #define UF2HIKEY(fp) ((fp)->uf_name)
 1682 #define HIKEY2UF(p)  ((ufunc_T *)((p) - offsetof(ufunc_T, uf_name)))
 1683 #define HI2UF(hi)     HIKEY2UF((hi)->hi_key)
 1684 
 1685 /*
 1686  * Holds the hashtab with variables local to each sourced script.
 1687  * Each item holds a variable (nameless) that points to the dict_T.
 1688  */
 1689 typedef struct
 1690 {
 1691     dictitem_T  sv_var;
 1692     dict_T  sv_dict;
 1693 } scriptvar_T;
 1694 
 1695 /*
 1696  * Entry for "sn_var_vals".  Used for script-local variables.
 1697  */
 1698 typedef struct {
 1699     char_u  *sv_name;   // points into "sn_vars" di_key
 1700     typval_T    *sv_tv;     // points into "sn_vars" di_tv
 1701     type_T  *sv_type;
 1702     int     sv_const;
 1703     int     sv_export;  // "export let var = val"
 1704 } svar_T;
 1705 
 1706 typedef struct {
 1707     char_u  *imp_name;      // name imported as (allocated)
 1708     int     imp_sid;        // script ID of "from"
 1709 
 1710     // for "import * as Name", "imp_name" is "Name"
 1711     int     imp_all;
 1712 
 1713     // for variable
 1714     type_T  *imp_type;
 1715     int     imp_var_vals_idx;   // index in sn_var_vals of "from"
 1716 
 1717     // for function
 1718     char_u  *imp_funcname;      // user func name (NOT allocated)
 1719 } imported_T;
 1720 
 1721 /*
 1722  * Growarray to store info about already sourced scripts.
 1723  * For Unix also store the dev/ino, so that we don't have to stat() each
 1724  * script when going through the list.
 1725  */
 1726 typedef struct
 1727 {
 1728     char_u  *sn_name;
 1729 
 1730     scriptvar_T *sn_vars;   // stores s: variables for this script
 1731     garray_T    sn_var_vals;    // same variables as a list of svar_T
 1732 
 1733     garray_T    sn_imports; // imported items, imported_T
 1734 
 1735     garray_T    sn_type_list;   // keeps types used by variables
 1736 
 1737     int     sn_version; // :scriptversion
 1738     int     sn_had_command; // TRUE if any command was executed
 1739     char_u  *sn_save_cpo;   // 'cpo' value when :vim9script found
 1740 
 1741 # ifdef FEAT_PROFILE
 1742     int     sn_prof_on; // TRUE when script is/was profiled
 1743     int     sn_pr_force;    // forceit: profile functions in this script
 1744     proftime_T  sn_pr_child;    // time set when going into first child
 1745     int     sn_pr_nest; // nesting for sn_pr_child
 1746     // profiling the script as a whole
 1747     int     sn_pr_count;    // nr of times sourced
 1748     proftime_T  sn_pr_total;    // time spent in script + children
 1749     proftime_T  sn_pr_self; // time spent in script itself
 1750     proftime_T  sn_pr_start;    // time at script start
 1751     proftime_T  sn_pr_children; // time in children after script start
 1752     // profiling the script per line
 1753     garray_T    sn_prl_ga;  // things stored for every line
 1754     proftime_T  sn_prl_start;   // start time for current line
 1755     proftime_T  sn_prl_children; // time spent in children for this line
 1756     proftime_T  sn_prl_wait;    // wait start time for current line
 1757     int     sn_prl_idx; // index of line being timed; -1 if none
 1758     int     sn_prl_execed;  // line being timed was executed
 1759 # endif
 1760 } scriptitem_T;
 1761 
 1762 // Struct passed through eval() functions.
 1763 // See EVALARG_EVALUATE for a fixed value with eval_flags set to EVAL_EVALUATE.
 1764 typedef struct {
 1765     int     eval_flags;     // EVAL_ flag values below
 1766     int     eval_break_count;   // nr of line breaks consumed
 1767 
 1768     // copied from exarg_T when "getline" is "getsourceline". Can be NULL.
 1769     char_u  *(*eval_getline)(int, void *, int, int);
 1770     void    *eval_cookie;       // argument for eval_getline()
 1771 
 1772     // used when compiling a :def function, NULL otherwise
 1773     cctx_T  *eval_cctx;
 1774 
 1775     // Used to collect lines while parsing them, so that they can be
 1776     // concatenated later.  Used when "eval_ga.ga_itemsize" is not zero.
 1777     // "eval_ga.ga_data" is a list of pointers to lines.
 1778     garray_T    eval_ga;
 1779 
 1780     // pointer to the last line obtained with getsourceline()
 1781     char_u  *eval_tofree;
 1782 
 1783     // pointer to the lines concatenated for a lambda.
 1784     char_u  *eval_tofree_lambda;
 1785 } evalarg_T;
 1786 
 1787 // Flags for expression evaluation.
 1788 #define EVAL_EVALUATE       1       // when missing don't actually evaluate
 1789 #define EVAL_CONSTANT       2       // when not a constant return FAIL
 1790 
 1791 # ifdef FEAT_PROFILE
 1792 /*
 1793  * Struct used in sn_prl_ga for every line of a script.
 1794  */
 1795 typedef struct sn_prl_S
 1796 {
 1797     int     snp_count;  // nr of times line was executed
 1798     proftime_T  sn_prl_total;   // time spent in a line + children
 1799     proftime_T  sn_prl_self;    // time spent in a line itself
 1800 } sn_prl_T;
 1801 
 1802 #  define PRL_ITEM(si, idx) (((sn_prl_T *)(si)->sn_prl_ga.ga_data)[(idx)])
 1803 # endif
 1804 #else
 1805 // dummy typedefs for use in function prototypes
 1806 typedef struct
 1807 {
 1808     int     dummy;
 1809 } ufunc_T;
 1810 typedef struct
 1811 {
 1812     int     dummy;
 1813 } funccall_T;
 1814 typedef struct
 1815 {
 1816     int     dummy;
 1817 } funcdict_T;
 1818 typedef struct
 1819 {
 1820     int     dummy;
 1821 } funccal_entry_T;
 1822 typedef struct
 1823 {
 1824     int     dummy;
 1825 } scriptitem_T;
 1826 typedef struct
 1827 {
 1828     int     dummy;
 1829 } evalarg_T;
 1830 #endif
 1831 
 1832 // Struct passed between functions dealing with function call execution.
 1833 //
 1834 // "argv_func", when not NULL, can be used to fill in arguments only when the
 1835 // invoked function uses them.  It is called like this:
 1836 //   new_argcount = argv_func(current_argcount, argv, partial_argcount,
 1837 //                          called_func_argcount)
 1838 //
 1839 typedef struct {
 1840     int     (* argv_func)(int, typval_T *, int, int);
 1841     linenr_T    firstline;  // first line of range
 1842     linenr_T    lastline;   // last line of range
 1843     int     *doesrange; // if not NULL: return: function handled range
 1844     int     evaluate;   // actually evaluate expressions
 1845     partial_T   *partial;   // for extra arguments
 1846     dict_T  *selfdict;  // Dictionary for "self"
 1847     typval_T    *basetv;    // base for base->method()
 1848 } funcexe_T;
 1849 
 1850 /*
 1851  * Structure to hold the context of a compiled function, used by closures
 1852  * defined in that function.
 1853  */
 1854 typedef struct funcstack_S
 1855 {
 1856     garray_T    fs_ga;      // contains the stack, with:
 1857                 // - arguments
 1858                 // - frame
 1859                 // - local variables
 1860 
 1861     int     fs_refcount;    // nr of closures referencing this funcstack
 1862     int     fs_copyID;  // for garray_T collection
 1863 } funcstack_T;
 1864 
 1865 struct partial_S
 1866 {
 1867     int     pt_refcount;    // reference count
 1868     char_u  *pt_name;   // function name; when NULL use
 1869                 // pt_func->uf_name
 1870     ufunc_T *pt_func;   // function pointer; when NULL lookup function
 1871                 // with pt_name
 1872     int     pt_auto;    // when TRUE the partial was created for using
 1873                 // dict.member in handle_subscript()
 1874 
 1875     // For a compiled closure: the arguments and local variables.
 1876     garray_T    *pt_ectx_stack;     // where to find local vars
 1877     int     pt_ectx_frame;      // index of function frame in uf_ectx_stack
 1878     funcstack_T *pt_funcstack;      // copy of stack, used after context
 1879                     // function returns
 1880 
 1881     int     pt_argc;    // number of arguments
 1882     typval_T    *pt_argv;   // arguments in allocated array
 1883 
 1884     dict_T  *pt_dict;   // dict for "self"
 1885     int     pt_copyID;  // funcstack may contain pointer to partial
 1886 };
 1887 
 1888 typedef struct AutoPatCmd_S AutoPatCmd;
 1889 
 1890 /*
 1891  * Entry in the execution stack "exestack".
 1892  */
 1893 typedef enum {
 1894     ETYPE_TOP,          // toplevel
 1895     ETYPE_SCRIPT,           // sourcing script, use es_info.sctx
 1896     ETYPE_UFUNC,            // user function, use es_info.ufunc
 1897     ETYPE_AUCMD,            // autocomand, use es_info.aucmd
 1898     ETYPE_MODELINE,         // modeline, use es_info.sctx
 1899     ETYPE_EXCEPT,           // exception, use es_info.exception
 1900     ETYPE_ARGS,             // command line argument
 1901     ETYPE_ENV,              // environment variable
 1902     ETYPE_INTERNAL,         // internal operation
 1903     ETYPE_SPELL,            // loading spell file
 1904 } etype_T;
 1905 
 1906 typedef struct {
 1907     long      es_lnum;      // replaces "sourcing_lnum"
 1908     char_u    *es_name;     // replaces "sourcing_name"
 1909     etype_T   es_type;
 1910     union {
 1911     sctx_T  *sctx;      // script and modeline info
 1912 #if defined(FEAT_EVAL)
 1913     ufunc_T *ufunc;     // function info
 1914 #endif
 1915     AutoPatCmd *aucmd;  // autocommand info
 1916     except_T   *except; // exception info
 1917     } es_info;
 1918 #if defined(FEAT_EVAL)
 1919     scid_T  es_save_sid;        // saved sc_sid when calling function
 1920 #endif
 1921 } estack_T;
 1922 
 1923 // Information returned by get_tty_info().
 1924 typedef struct {
 1925     int backspace;  // what the Backspace key produces
 1926     int enter;      // what the Enter key produces
 1927     int interrupt;  // interrupt character
 1928     int nl_does_cr; // TRUE when a NL is expanded to CR-NL on output
 1929 } ttyinfo_T;
 1930 
 1931 // Status of a job.  Order matters!
 1932 typedef enum
 1933 {
 1934     JOB_FAILED,
 1935     JOB_STARTED,
 1936     JOB_ENDED,      // detected job done
 1937     JOB_FINISHED,   // job done and cleanup done
 1938 } jobstatus_T;
 1939 
 1940 /*
 1941  * Structure to hold info about a Job.
 1942  */
 1943 struct jobvar_S
 1944 {
 1945     job_T   *jv_next;
 1946     job_T   *jv_prev;
 1947 #ifdef UNIX
 1948     pid_t   jv_pid;
 1949 #endif
 1950 #ifdef MSWIN
 1951     PROCESS_INFORMATION jv_proc_info;
 1952     HANDLE      jv_job_object;
 1953 #endif
 1954     char_u  *jv_tty_in; // controlling tty input, allocated
 1955     char_u  *jv_tty_out;    // controlling tty output, allocated
 1956     jobstatus_T jv_status;
 1957     char_u  *jv_stoponexit; // allocated
 1958 #ifdef UNIX
 1959     char_u  *jv_termsig;    // allocated
 1960 #endif
 1961 #ifdef MSWIN
 1962     char_u  *jv_tty_type;   // allocated
 1963 #endif
 1964     int     jv_exitval;
 1965     callback_T  jv_exit_cb;
 1966 
 1967     buf_T   *jv_in_buf; // buffer from "in-name"
 1968 
 1969     int     jv_refcount;    // reference count
 1970     int     jv_copyID;
 1971 
 1972     channel_T   *jv_channel;    // channel for I/O, reference counted
 1973     char    **jv_argv;  // command line used to start the job
 1974 };
 1975 
 1976 /*
 1977  * Structures to hold info about a Channel.
 1978  */
 1979 struct readq_S
 1980 {
 1981     char_u  *rq_buffer;
 1982     long_u  rq_buflen;
 1983     readq_T *rq_next;
 1984     readq_T *rq_prev;
 1985 };
 1986 
 1987 struct writeq_S
 1988 {
 1989     garray_T    wq_ga;
 1990     writeq_T    *wq_next;
 1991     writeq_T    *wq_prev;
 1992 };
 1993 
 1994 struct jsonq_S
 1995 {
 1996     typval_T    *jq_value;
 1997     jsonq_T *jq_next;
 1998     jsonq_T *jq_prev;
 1999     int     jq_no_callback; // TRUE when no callback was found
 2000 };
 2001 
 2002 struct cbq_S
 2003 {
 2004     callback_T  cq_callback;
 2005     int     cq_seq_nr;
 2006     cbq_T   *cq_next;
 2007     cbq_T   *cq_prev;
 2008 };
 2009 
 2010 // mode for a channel
 2011 typedef enum
 2012 {
 2013     MODE_NL = 0,
 2014     MODE_RAW,
 2015     MODE_JSON,
 2016     MODE_JS,
 2017 } ch_mode_T;
 2018 
 2019 typedef enum {
 2020     JIO_PIPE,       // default
 2021     JIO_NULL,
 2022     JIO_FILE,
 2023     JIO_BUFFER,
 2024     JIO_OUT
 2025 } job_io_T;
 2026 
 2027 #define CH_PART_FD(part)    ch_part[part].ch_fd
 2028 
 2029 // Ordering matters, it is used in for loops: IN is last, only SOCK/OUT/ERR
 2030 // are polled.
 2031 typedef enum {
 2032     PART_SOCK = 0,
 2033 #define CH_SOCK_FD  CH_PART_FD(PART_SOCK)
 2034 #ifdef FEAT_JOB_CHANNEL
 2035     PART_OUT,
 2036 # define CH_OUT_FD  CH_PART_FD(PART_OUT)
 2037     PART_ERR,
 2038 # define CH_ERR_FD  CH_PART_FD(PART_ERR)
 2039     PART_IN,
 2040 # define CH_IN_FD   CH_PART_FD(PART_IN)
 2041 #endif
 2042     PART_COUNT,
 2043 } ch_part_T;
 2044 
 2045 #define INVALID_FD  (-1)
 2046 
 2047 // The per-fd info for a channel.
 2048 typedef struct {
 2049     sock_T  ch_fd;      // socket/stdin/stdout/stderr, -1 if not used
 2050 
 2051 # if defined(UNIX) && !defined(HAVE_SELECT)
 2052     int     ch_poll_idx;    // used by channel_poll_setup()
 2053 # endif
 2054 
 2055 #ifdef FEAT_GUI_X11
 2056     XtInputId   ch_inputHandler; // Cookie for input
 2057 #endif
 2058 #ifdef FEAT_GUI_GTK
 2059     gint    ch_inputHandler; // Cookie for input
 2060 #endif
 2061 
 2062     ch_mode_T   ch_mode;
 2063     job_io_T    ch_io;
 2064     int     ch_timeout; // request timeout in msec
 2065 
 2066     readq_T ch_head;    // header for circular raw read queue
 2067     jsonq_T ch_json_head;   // header for circular json read queue
 2068     garray_T    ch_block_ids;   // list of IDs that channel_read_json_block()
 2069                 // is waiting for
 2070     // When ch_wait_len is non-zero use ch_deadline to wait for incomplete
 2071     // message to be complete. The value is the length of the incomplete
 2072     // message when the deadline was set.  If it gets longer (something was
 2073     // received) the deadline is reset.
 2074     size_t  ch_wait_len;
 2075 #ifdef MSWIN
 2076     DWORD   ch_deadline;
 2077 #else
 2078     struct timeval ch_deadline;
 2079 #endif
 2080     int     ch_block_write; // for testing: 0 when not used, -1 when write
 2081                 // does not block, 1 simulate blocking
 2082     int     ch_nonblocking; // write() is non-blocking
 2083     writeq_T    ch_writeque;    // header for write queue
 2084 
 2085     cbq_T   ch_cb_head; // dummy node for per-request callbacks
 2086     callback_T  ch_callback;    // call when a msg is not handled
 2087 
 2088     bufref_T    ch_bufref;  // buffer to read from or write to
 2089     int     ch_nomodifiable; // TRUE when buffer can be 'nomodifiable'
 2090     int     ch_nomod_error; // TRUE when e_modifiable was given
 2091     int     ch_buf_append;  // write appended lines instead top-bot
 2092     linenr_T    ch_buf_top; // next line to send
 2093     linenr_T    ch_buf_bot; // last line to send
 2094 } chanpart_T;
 2095 
 2096 struct channel_S {
 2097     channel_T   *ch_next;
 2098     channel_T   *ch_prev;
 2099 
 2100     int     ch_id;      // ID of the channel
 2101     int     ch_last_msg_id; // ID of the last message
 2102 
 2103     chanpart_T  ch_part[PART_COUNT]; // info for socket, out, err and in
 2104     int     ch_write_text_mode; // write buffer lines with CR, not NL
 2105 
 2106     char    *ch_hostname;   // only for socket, allocated
 2107     int     ch_port;    // only for socket
 2108 
 2109     int     ch_to_be_closed; // bitset of readable fds to be closed.
 2110                  // When all readable fds have been closed,
 2111                  // set to (1 << PART_COUNT).
 2112     int     ch_to_be_freed; // When TRUE channel must be freed when it's
 2113                 // safe to invoke callbacks.
 2114     int     ch_error;   // When TRUE an error was reported.  Avoids
 2115                 // giving pages full of error messages when
 2116                 // the other side has exited, only mention the
 2117                 // first error until the connection works
 2118                 // again.
 2119 
 2120     void    (*ch_nb_close_cb)(void);
 2121                 // callback for Netbeans when channel is
 2122                 // closed
 2123 
 2124 #ifdef MSWIN
 2125     int     ch_named_pipe;  // using named pipe instead of pty
 2126 #endif
 2127     callback_T  ch_callback;    // call when any msg is not handled
 2128     callback_T  ch_close_cb;    // call when channel is closed
 2129     int     ch_drop_never;
 2130     int     ch_keep_open;   // do not close on read error
 2131     int     ch_nonblock;
 2132 
 2133     job_T   *ch_job;    // Job that uses this channel; this does not
 2134                 // count as a reference to avoid a circular
 2135                 // reference, the job refers to the channel.
 2136     int     ch_job_killed;  // TRUE when there was a job and it was killed
 2137                 // or we know it died.
 2138     int     ch_anonymous_pipe;  // ConPTY
 2139     int     ch_killing;     // TerminateJobObject() was called
 2140 
 2141     int     ch_refcount;    // reference count
 2142     int     ch_copyID;
 2143 };
 2144 
 2145 #define JO_MODE         0x0001  // channel mode
 2146 #define JO_IN_MODE      0x0002  // stdin mode
 2147 #define JO_OUT_MODE     0x0004  // stdout mode
 2148 #define JO_ERR_MODE     0x0008  // stderr mode
 2149 #define JO_CALLBACK     0x0010  // channel callback
 2150 #define JO_OUT_CALLBACK     0x0020  // stdout callback
 2151 #define JO_ERR_CALLBACK     0x0040  // stderr callback
 2152 #define JO_CLOSE_CALLBACK   0x0080  // "close_cb"
 2153 #define JO_WAITTIME     0x0100  // only for ch_open()
 2154 #define JO_TIMEOUT      0x0200  // all timeouts
 2155 #define JO_OUT_TIMEOUT      0x0400  // stdout timeouts
 2156 #define JO_ERR_TIMEOUT      0x0800  // stderr timeouts
 2157 #define JO_PART         0x1000  // "part"
 2158 #define JO_ID           0x2000  // "id"
 2159 #define JO_STOPONEXIT       0x4000  // "stoponexit"
 2160 #define JO_EXIT_CB      0x8000  // "exit_cb"
 2161 #define JO_OUT_IO       0x10000 // "out_io"
 2162 #define JO_ERR_IO       0x20000 // "err_io" (JO_OUT_IO << 1)
 2163 #define JO_IN_IO        0x40000 // "in_io" (JO_OUT_IO << 2)
 2164 #define JO_OUT_NAME     0x80000 // "out_name"
 2165 #define JO_ERR_NAME     0x100000    // "err_name" (JO_OUT_NAME << 1)
 2166 #define JO_IN_NAME      0x200000    // "in_name" (JO_OUT_NAME << 2)
 2167 #define JO_IN_TOP       0x400000    // "in_top"
 2168 #define JO_IN_BOT       0x800000    // "in_bot"
 2169 #define JO_OUT_BUF      0x1000000   // "out_buf"
 2170 #define JO_ERR_BUF      0x2000000   // "err_buf" (JO_OUT_BUF << 1)
 2171 #define JO_IN_BUF       0x4000000   // "in_buf" (JO_OUT_BUF << 2)
 2172 #define JO_CHANNEL      0x8000000   // "channel"
 2173 #define JO_BLOCK_WRITE      0x10000000  // "block_write"
 2174 #define JO_OUT_MODIFIABLE   0x20000000  // "out_modifiable"
 2175 #define JO_ERR_MODIFIABLE   0x40000000  // "err_modifiable" (JO_OUT_ << 1)
 2176 #define JO_ALL          0x7fffffff
 2177 
 2178 #define JO2_OUT_MSG     0x0001  // "out_msg"
 2179 #define JO2_ERR_MSG     0x0002  // "err_msg" (JO_OUT_ << 1)
 2180 #define JO2_TERM_NAME       0x0004  // "term_name"
 2181 #define JO2_TERM_FINISH     0x0008  // "term_finish"
 2182 #define JO2_ENV         0x0010  // "env"
 2183 #define JO2_CWD         0x0020  // "cwd"
 2184 #define JO2_TERM_ROWS       0x0040  // "term_rows"
 2185 #define JO2_TERM_COLS       0x0080  // "term_cols"
 2186 #define JO2_VERTICAL        0x0100  // "vertical"
 2187 #define JO2_CURWIN      0x0200  // "curwin"
 2188 #define JO2_HIDDEN      0x0400  // "hidden"
 2189 #define JO2_TERM_OPENCMD    0x0800  // "term_opencmd"
 2190 #define JO2_EOF_CHARS       0x1000  // "eof_chars"
 2191 #define JO2_NORESTORE       0x2000  // "norestore"
 2192 #define JO2_TERM_KILL       0x4000  // "term_kill"
 2193 #define JO2_ANSI_COLORS     0x8000  // "ansi_colors"
 2194 #define JO2_TTY_TYPE        0x10000 // "tty_type"
 2195 #define JO2_BUFNR       0x20000 // "bufnr"
 2196 #define JO2_TERM_API        0x40000 // "term_api"
 2197 #define JO2_TERM_HIGHLIGHT  0x80000 // "highlight"
 2198 
 2199 #define JO_MODE_ALL (JO_MODE + JO_IN_MODE + JO_OUT_MODE + JO_ERR_MODE)
 2200 #define JO_CB_ALL \
 2201     (JO_CALLBACK + JO_OUT_CALLBACK + JO_ERR_CALLBACK + JO_CLOSE_CALLBACK)
 2202 #define JO_TIMEOUT_ALL  (JO_TIMEOUT + JO_OUT_TIMEOUT + JO_ERR_TIMEOUT)
 2203 
 2204 /*
 2205  * Options for job and channel commands.
 2206  */
 2207 typedef struct
 2208 {
 2209     int     jo_set;     // JO_ bits for values that were set
 2210     int     jo_set2;    // JO2_ bits for values that were set
 2211 
 2212     ch_mode_T   jo_mode;
 2213     ch_mode_T   jo_in_mode;
 2214     ch_mode_T   jo_out_mode;
 2215     ch_mode_T   jo_err_mode;
 2216     int     jo_noblock;
 2217 
 2218     job_io_T    jo_io[4];   // PART_OUT, PART_ERR, PART_IN
 2219     char_u  jo_io_name_buf[4][NUMBUFLEN];
 2220     char_u  *jo_io_name[4]; // not allocated!
 2221     int     jo_io_buf[4];
 2222     int     jo_pty;
 2223     int     jo_modifiable[4];
 2224     int     jo_message[4];
 2225     channel_T   *jo_channel;
 2226 
 2227     linenr_T    jo_in_top;
 2228     linenr_T    jo_in_bot;
 2229 
 2230     callback_T  jo_callback;
 2231     callback_T  jo_out_cb;
 2232     callback_T  jo_err_cb;
 2233     callback_T  jo_close_cb;
 2234     callback_T  jo_exit_cb;
 2235     int     jo_drop_never;
 2236     int     jo_waittime;
 2237     int     jo_timeout;
 2238     int     jo_out_timeout;
 2239     int     jo_err_timeout;
 2240     int     jo_block_write; // for testing only
 2241     int     jo_part;
 2242     int     jo_id;
 2243     char_u  jo_stoponexit_buf[NUMBUFLEN];
 2244     char_u  *jo_stoponexit;
 2245     dict_T  *jo_env;    // environment variables
 2246     char_u  jo_cwd_buf[NUMBUFLEN];
 2247     char_u  *jo_cwd;
 2248 
 2249 #ifdef FEAT_TERMINAL
 2250     // when non-zero run the job in a terminal window of this size
 2251     int     jo_term_rows;
 2252     int     jo_term_cols;
 2253     int     jo_vertical;
 2254     int     jo_curwin;
 2255     buf_T   *jo_bufnr_buf;
 2256     int     jo_hidden;
 2257     int     jo_term_norestore;
 2258     char_u  jo_term_name_buf[NUMBUFLEN];
 2259     char_u  *jo_term_name;
 2260     char_u  jo_term_opencmd_buf[NUMBUFLEN];
 2261     char_u  *jo_term_opencmd;
 2262     int     jo_term_finish;
 2263     char_u  jo_eof_chars_buf[NUMBUFLEN];
 2264     char_u  *jo_eof_chars;
 2265     char_u  jo_term_kill_buf[NUMBUFLEN];
 2266     char_u  *jo_term_kill;
 2267 # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
 2268     long_u  jo_ansi_colors[16];
 2269 # endif
 2270     char_u  jo_term_highlight_buf[NUMBUFLEN];
 2271     char_u  *jo_term_highlight;
 2272     int     jo_tty_type;        // first character of "tty_type"
 2273     char_u  jo_term_api_buf[NUMBUFLEN];
 2274     char_u  *jo_term_api;
 2275 #endif
 2276 } jobopt_T;
 2277 
 2278 #ifdef FEAT_EVAL
 2279 /*
 2280  * Structure used for listeners added with listener_add().
 2281  */
 2282 typedef struct listener_S listener_T;
 2283 struct listener_S
 2284 {
 2285     listener_T  *lr_next;
 2286     int     lr_id;
 2287     callback_T  lr_callback;
 2288 };
 2289 #endif
 2290 
 2291 /*
 2292  * structure used for explicit stack while garbage collecting hash tables
 2293  */
 2294 typedef struct ht_stack_S
 2295 {
 2296     hashtab_T       *ht;
 2297     struct ht_stack_S   *prev;
 2298 } ht_stack_T;
 2299 
 2300 /*
 2301  * structure used for explicit stack while garbage collecting lists
 2302  */
 2303 typedef struct list_stack_S
 2304 {
 2305     list_T      *list;
 2306     struct list_stack_S *prev;
 2307 } list_stack_T;
 2308 
 2309 /*
 2310  * Structure used for iterating over dictionary items.
 2311  * Initialize with dict_iterate_start().
 2312  */
 2313 typedef struct
 2314 {
 2315     long_u  dit_todo;
 2316     hashitem_T  *dit_hi;
 2317 } dict_iterator_T;
 2318 
 2319 // values for b_syn_spell: what to do with toplevel text
 2320 #define SYNSPL_DEFAULT  0   // spell check if @Spell not defined
 2321 #define SYNSPL_TOP  1   // spell check toplevel text
 2322 #define SYNSPL_NOTOP    2   // don't spell check toplevel text
 2323 
 2324 // values for b_syn_foldlevel: how to compute foldlevel on a line
 2325 #define SYNFLD_START    0   // use level of item at start of line
 2326 #define SYNFLD_MINIMUM  1   // use lowest local minimum level on line
 2327 
 2328 // avoid #ifdefs for when b_spell is not available
 2329 #ifdef FEAT_SPELL
 2330 # define B_SPELL(buf)  ((buf)->b_spell)
 2331 #else
 2332 # define B_SPELL(buf)  (0)
 2333 #endif
 2334 
 2335 typedef struct qf_info_S qf_info_T;
 2336 
 2337 #ifdef FEAT_PROFILE
 2338 /*
 2339  * Used for :syntime: timing of executing a syntax pattern.
 2340  */
 2341 typedef struct {
 2342     proftime_T  total;      // total time used
 2343     proftime_T  slowest;    // time of slowest call
 2344     long    count;      // nr of times used
 2345     long    match;      // nr of times matched
 2346 } syn_time_T;
 2347 #endif
 2348 
 2349 typedef struct timer_S timer_T;
 2350 struct timer_S
 2351 {
 2352     long    tr_id;
 2353 #ifdef FEAT_TIMERS
 2354     timer_T *tr_next;
 2355     timer_T *tr_prev;
 2356     proftime_T  tr_due;         // when the callback is to be invoked
 2357     char    tr_firing;      // when TRUE callback is being called
 2358     char    tr_paused;      // when TRUE callback is not invoked
 2359     int     tr_repeat;      // number of times to repeat, -1 forever
 2360     long    tr_interval;        // msec
 2361     callback_T  tr_callback;
 2362     int     tr_emsg_count;
 2363 #endif
 2364 };
 2365 
 2366 #ifdef FEAT_CRYPT
 2367 /*
 2368  * Structure to hold the type of encryption and the state of encryption or
 2369  * decryption.
 2370  */
 2371 typedef struct {
 2372     int     method_nr;
 2373     void    *method_state;  // method-specific state information
 2374 } cryptstate_T;
 2375 
 2376 // values for method_nr
 2377 # define CRYPT_M_ZIP    0
 2378 # define CRYPT_M_BF 1
 2379 # define CRYPT_M_BF2    2
 2380 # define CRYPT_M_COUNT  3 // number of crypt methods
 2381 
 2382 // Currently all crypt methods work inplace.  If one is added that isn't then
 2383 // define this.
 2384 //  # define CRYPT_NOT_INPLACE 1
 2385 #endif
 2386 
 2387 #ifdef FEAT_PROP_POPUP
 2388 typedef enum {
 2389     POPPOS_BOTLEFT,
 2390     POPPOS_TOPLEFT,
 2391     POPPOS_BOTRIGHT,
 2392     POPPOS_TOPRIGHT,
 2393     POPPOS_CENTER,
 2394     POPPOS_NONE
 2395 } poppos_T;
 2396 
 2397 typedef enum {
 2398     POPCLOSE_NONE,
 2399     POPCLOSE_BUTTON,
 2400     POPCLOSE_CLICK
 2401 } popclose_T;
 2402 
 2403 # define POPUPWIN_DEFAULT_ZINDEX     50
 2404 # define POPUPMENU_ZINDEX       100
 2405 # define POPUPWIN_DIALOG_ZINDEX     200
 2406 # define POPUPWIN_NOTIFICATION_ZINDEX   300
 2407 #endif
 2408 
 2409 /*
 2410  * These are items normally related to a buffer.  But when using ":ownsyntax"
 2411  * a window may have its own instance.
 2412  */
 2413 typedef struct {
 2414 #ifdef FEAT_SYN_HL
 2415     hashtab_T   b_keywtab;      // syntax keywords hash table
 2416     hashtab_T   b_keywtab_ic;       // idem, ignore case
 2417     int     b_syn_error;        // TRUE when error occurred in HL
 2418 # ifdef FEAT_RELTIME
 2419     int     b_syn_slow;     // TRUE when 'redrawtime' reached
 2420 # endif
 2421     int     b_syn_ic;       // ignore case for :syn cmds
 2422     int     b_syn_foldlevel;    // how to compute foldlevel on a line
 2423     int     b_syn_spell;        // SYNSPL_ values
 2424     garray_T    b_syn_patterns;     // table for syntax patterns
 2425     garray_T    b_syn_clusters;     // table for syntax clusters
 2426     int     b_spell_cluster_id; // @Spell cluster ID or 0
 2427     int     b_nospell_cluster_id;   // @NoSpell cluster ID or 0
 2428     int     b_syn_containedin;  // TRUE when there is an item with a
 2429                     // "containedin" argument
 2430     int     b_syn_sync_flags;   // flags about how to sync
 2431     short   b_syn_sync_id;      // group to sync on
 2432     long    b_syn_sync_minlines;    // minimal sync lines offset
 2433     long    b_syn_sync_maxlines;    // maximal sync lines offset
 2434     long    b_syn_sync_linebreaks;  // offset for multi-line pattern
 2435     char_u  *b_syn_linecont_pat;    // line continuation pattern
 2436     regprog_T   *b_syn_linecont_prog;   // line continuation program
 2437 #ifdef FEAT_PROFILE
 2438     syn_time_T  b_syn_linecont_time;
 2439 #endif
 2440     int     b_syn_linecont_ic;  // ignore-case flag for above
 2441     int     b_syn_topgrp;       // for ":syntax include"
 2442 # ifdef FEAT_CONCEAL
 2443     int     b_syn_conceal;      // auto-conceal for :syn cmds
 2444 # endif
 2445 # ifdef FEAT_FOLDING
 2446     int     b_syn_folditems;    // number of patterns with the HL_FOLD
 2447                     // flag set
 2448 # endif
 2449     /*
 2450      * b_sst_array[] contains the state stack for a number of lines, for the
 2451      * start of that line (col == 0).  This avoids having to recompute the
 2452      * syntax state too often.
 2453      * b_sst_array[] is allocated to hold the state for all displayed lines,
 2454      * and states for 1 out of about 20 other lines.
 2455      * b_sst_array  pointer to an array of synstate_T
 2456      * b_sst_len    number of entries in b_sst_array[]
 2457      * b_sst_first  pointer to first used entry in b_sst_array[] or NULL
 2458      * b_sst_firstfree  pointer to first free entry in b_sst_array[] or NULL
 2459      * b_sst_freecount  number of free entries in b_sst_array[]
 2460      * b_sst_check_lnum entries after this lnum need to be checked for
 2461      *          validity (MAXLNUM means no check needed)
 2462      */
 2463     synstate_T  *b_sst_array;
 2464     int     b_sst_len;
 2465     synstate_T  *b_sst_first;
 2466     synstate_T  *b_sst_firstfree;
 2467     int     b_sst_freecount;
 2468     linenr_T    b_sst_check_lnum;
 2469     short_u b_sst_lasttick; // last display tick
 2470 #endif // FEAT_SYN_HL
 2471 
 2472 #ifdef FEAT_SPELL
 2473     // for spell checking
 2474     garray_T    b_langp;        // list of pointers to slang_T, see spell.c
 2475     char_u  b_spell_ismw[256];  // flags: is midword char
 2476     char_u  *b_spell_ismw_mb;   // multi-byte midword chars
 2477     char_u  *b_p_spc;       // 'spellcapcheck'
 2478     regprog_T   *b_cap_prog;        // program for 'spellcapcheck'
 2479     char_u  *b_p_spf;       // 'spellfile'
 2480     char_u  *b_p_spl;       // 'spelllang'
 2481     char_u  *b_p_spo;       // 'spelloptions'
 2482     int     b_cjk;          // all CJK letters as OK
 2483 #endif
 2484 #if !defined(FEAT_SYN_HL) && !defined(FEAT_SPELL)
 2485     int     dummy;
 2486 #endif
 2487     char_u  b_syn_chartab[32];  // syntax iskeyword option
 2488     char_u  *b_syn_isk;     // iskeyword option
 2489 } synblock_T;
 2490 
 2491 
 2492 /*
 2493  * buffer: structure that holds information about one file
 2494  *
 2495  * Several windows can share a single Buffer
 2496  * A buffer is unallocated if there is no memfile for it.
 2497  * A buffer is new if the associated file has never been loaded yet.
 2498  */
 2499 
 2500 struct file_buffer
 2501 {
 2502     memline_T   b_ml;       // associated memline (also contains line
 2503                 // count)
 2504 
 2505     buf_T   *b_next;    // links in list of buffers
 2506     buf_T   *b_prev;
 2507 
 2508     int     b_nwindows; // nr of windows open on this buffer
 2509 
 2510     int     b_flags;    // various BF_ flags
 2511     int     b_locked;   // Buffer is being closed or referenced, don't
 2512                 // let autocommands wipe it out.
 2513 
 2514     /*
 2515      * b_ffname has the full path of the file (NULL for no name).
 2516      * b_sfname is the name as the user typed it (or NULL).
 2517      * b_fname is the same as b_sfname, unless ":cd" has been done,
 2518      *      then it is the same as b_ffname (NULL for no name).
 2519      */
 2520     char_u  *b_ffname;  // full path file name, allocated
 2521     char_u  *b_sfname;  // short file name, allocated, may be equal to
 2522                 // b_ffname
 2523     char_u  *b_fname;   // current file name, points to b_ffname or
 2524                 // b_sfname
 2525 
 2526 #ifdef UNIX
 2527     int     b_dev_valid;    // TRUE when b_dev has a valid number
 2528     dev_t   b_dev;      // device number
 2529     ino_t   b_ino;      // inode number
 2530 #endif
 2531 #ifdef FEAT_CW_EDITOR
 2532     FSSpec  b_FSSpec;   // MacOS File Identification
 2533 #endif
 2534 #ifdef VMS
 2535     char     b_fab_rfm; // Record format
 2536     char     b_fab_rat; // Record attribute
 2537     unsigned int b_fab_mrs; // Max record size
 2538 #endif
 2539     int     b_fnum;     // buffer number for this file.
 2540     char_u  b_key[VIM_SIZEOF_INT * 2 + 1];
 2541                 // key used for buf_hashtab, holds b_fnum as
 2542                 // hex string
 2543 
 2544     int     b_changed;  // 'modified': Set to TRUE if something in the
 2545                 // file has been changed and not written out.
 2546     dictitem16_T b_ct_di;   // holds the b:changedtick value in
 2547                 // b_ct_di.di_tv.vval.v_number;
 2548                 // incremented for each change, also for undo
 2549 #define CHANGEDTICK(buf) ((buf)->b_ct_di.di_tv.vval.v_number)
 2550 
 2551     varnumber_T b_last_changedtick; // b:changedtick when TextChanged or
 2552                     // TextChangedI was last triggered.
 2553     varnumber_T b_last_changedtick_pum; // b:changedtick when TextChangedP was
 2554                     // last triggered.
 2555 
 2556     int     b_saving;   // Set to TRUE if we are in the middle of
 2557                 // saving the buffer.
 2558 
 2559     /*
 2560      * Changes to a buffer require updating of the display.  To minimize the
 2561      * work, remember changes made and update everything at once.
 2562      */
 2563     int     b_mod_set;  // TRUE when there are changes since the last
 2564                 // time the display was updated
 2565     linenr_T    b_mod_top;  // topmost lnum that was changed
 2566     linenr_T    b_mod_bot;  // lnum below last changed line, AFTER the
 2567                 // change
 2568     long    b_mod_xlines;   // number of extra buffer lines inserted;
 2569                 // negative when lines were deleted
 2570 
 2571     wininfo_T   *b_wininfo; // list of last used info for each window
 2572 
 2573     long    b_mtime;    // last change time of original file
 2574     long    b_mtime_read;   // last change time when reading
 2575     off_T   b_orig_size;    // size of original file in bytes
 2576     int     b_orig_mode;    // mode of original file
 2577 #ifdef FEAT_VIMINFO
 2578     time_T  b_last_used;    // time when the buffer was last used; used
 2579                 // for viminfo
 2580 #endif
 2581 
 2582     pos_T   b_namedm[NMARKS]; // current named marks (mark.c)
 2583 
 2584     // These variables are set when VIsual_active becomes FALSE
 2585     visualinfo_T b_visual;
 2586 #ifdef FEAT_EVAL
 2587     int     b_visual_mode_eval;  // b_visual.vi_mode for visualmode()
 2588 #endif
 2589 
 2590     pos_T   b_last_cursor;  // cursor position when last unloading this
 2591                 // buffer
 2592     pos_T   b_last_insert;  // where Insert mode was left
 2593     pos_T   b_last_change;  // position of last change: '. mark
 2594 
 2595 #ifdef FEAT_JUMPLIST
 2596     /*
 2597      * the changelist contains old change positions
 2598      */
 2599     pos_T   b_changelist[JUMPLISTSIZE];
 2600     int     b_changelistlen;    // number of active entries
 2601     int     b_new_change;       // set by u_savecommon()
 2602 #endif
 2603 
 2604     /*
 2605      * Character table, only used in charset.c for 'iskeyword'
 2606      * 32 bytes of 8 bits: 1 bit per character 0-255.
 2607      */
 2608     char_u  b_chartab[32];
 2609 
 2610     // Table used for mappings local to a buffer.
 2611     mapblock_T  *(b_maphash[256]);
 2612 
 2613     // First abbreviation local to a buffer.
 2614     mapblock_T  *b_first_abbr;
 2615 
 2616     // User commands local to the buffer.
 2617     garray_T    b_ucmds;
 2618     // start and end of an operator, also used for '[ and ']
 2619     pos_T   b_op_start;
 2620     pos_T   b_op_start_orig;  // used for Insstart_orig
 2621     pos_T   b_op_end;
 2622 
 2623 #ifdef FEAT_VIMINFO
 2624     int     b_marks_read;   // Have we read viminfo marks yet?
 2625 #endif
 2626 
 2627     /*
 2628      * The following only used in undo.c.
 2629      */
 2630     u_header_T  *b_u_oldhead;   // pointer to oldest header
 2631     u_header_T  *b_u_newhead;   // pointer to newest header; may not be valid
 2632                 // if b_u_curhead is not NULL
 2633     u_header_T  *b_u_curhead;   // pointer to current header
 2634     int     b_u_numhead;    // current number of headers
 2635     int     b_u_synced; // entry lists are synced
 2636     long    b_u_seq_last;   // last used undo sequence number
 2637     long    b_u_save_nr_last; // counter for last file write
 2638     long    b_u_seq_cur;    // hu_seq of header below which we are now
 2639     time_T  b_u_time_cur;   // uh_time of header below which we are now
 2640     long    b_u_save_nr_cur; // file write nr after which we are now
 2641 
 2642     /*
 2643      * variables for "U" command in undo.c
 2644      */
 2645     undoline_T  b_u_line_ptr;   // saved line for "U" command
 2646     linenr_T    b_u_line_lnum;  // line number of line in u_line
 2647     colnr_T b_u_line_colnr; // optional column number
 2648 
 2649     int     b_scanned;  // ^N/^P have scanned this buffer
 2650 
 2651     // flags for use of ":lmap" and IM control
 2652     long    b_p_iminsert;   // input mode for insert
 2653     long    b_p_imsearch;   // input mode for search
 2654 #define B_IMODE_USE_INSERT -1   //  Use b_p_iminsert value for search
 2655 #define B_IMODE_NONE 0      //  Input via none
 2656 #define B_IMODE_LMAP 1      //  Input via langmap
 2657 #define B_IMODE_IM 2        //  Input via input method
 2658 #define B_IMODE_LAST 2
 2659 
 2660 #ifdef FEAT_KEYMAP
 2661     short   b_kmap_state;   // using "lmap" mappings
 2662 # define KEYMAP_INIT    1   // 'keymap' was set, call keymap_init()
 2663 # define KEYMAP_LOADED  2   // 'keymap' mappings have been loaded
 2664     garray_T    b_kmap_ga;  // the keymap table
 2665 #endif
 2666 
 2667     /*
 2668      * Options local to a buffer.
 2669      * They are here because their value depends on the type of file
 2670      * or contents of the file being edited.
 2671      */
 2672     int     b_p_initialized;    // set when options initialized
 2673 
 2674 #ifdef FEAT_EVAL
 2675     sctx_T  b_p_script_ctx[BV_COUNT]; // SCTXs for buffer-local options
 2676 #endif
 2677 
 2678     int     b_p_ai;     // 'autoindent'
 2679     int     b_p_ai_nopaste; // b_p_ai saved for paste mode
 2680     char_u  *b_p_bkc;   // 'backupcopy'
 2681     unsigned    b_bkc_flags;    // flags for 'backupcopy'
 2682     int     b_p_ci;     // 'copyindent'
 2683     int     b_p_bin;    // 'binary'
 2684     int     b_p_bomb;   // 'bomb'
 2685     char_u  *b_p_bh;    // 'bufhidden'
 2686     char_u  *b_p_bt;    // 'buftype'
 2687 #ifdef FEAT_QUICKFIX
 2688 #define BUF_HAS_QF_ENTRY 1
 2689 #define BUF_HAS_LL_ENTRY 2
 2690     int     b_has_qf_entry;
 2691 #endif
 2692     int     b_p_bl;     // 'buflisted'
 2693 #ifdef FEAT_CINDENT
 2694     int     b_p_cin;    // 'cindent'
 2695     char_u  *b_p_cino;  // 'cinoptions'
 2696     char_u  *b_p_cink;  // 'cinkeys'
 2697 #endif
 2698 #if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT)
 2699     char_u  *b_p_cinw;  // 'cinwords'
 2700 #endif
 2701     char_u  *b_p_com;   // 'comments'
 2702 #ifdef FEAT_FOLDING
 2703     char_u  *b_p_cms;   // 'commentstring'
 2704 #endif
 2705     char_u  *b_p_cpt;   // 'complete'
 2706 #ifdef BACKSLASH_IN_FILENAME
 2707     char_u  *b_p_csl;   // 'completeslash'
 2708 #endif
 2709 #ifdef FEAT_COMPL_FUNC
 2710     char_u  *b_p_cfu;   // 'completefunc'
 2711     char_u  *b_p_ofu;   // 'omnifunc'
 2712 #endif
 2713 #ifdef FEAT_EVAL
 2714     char_u  *b_p_tfu;   // 'tagfunc'
 2715 #endif
 2716     int     b_p_eol;    // 'endofline'
 2717     int     b_p_fixeol; // 'fixendofline'
 2718     int     b_p_et;     // 'expandtab'
 2719     int     b_p_et_nobin;   // b_p_et saved for binary mode
 2720     int     b_p_et_nopaste; // b_p_et saved for paste mode
 2721     char_u  *b_p_fenc;  // 'fileencoding'
 2722     char_u  *b_p_ff;    // 'fileformat'
 2723     char_u  *b_p_ft;    // 'filetype'
 2724     char_u  *b_p_fo;    // 'formatoptions'
 2725     char_u  *b_p_flp;   // 'formatlistpat'
 2726     int     b_p_inf;    // 'infercase'
 2727     char_u  *b_p_isk;   // 'iskeyword'
 2728 #ifdef FEAT_FIND_ID
 2729     char_u  *b_p_def;   // 'define' local value
 2730     char_u  *b_p_inc;   // 'include'
 2731 # ifdef FEAT_EVAL
 2732     char_u  *b_p_inex;  // 'includeexpr'
 2733     long_u  b_p_inex_flags; // flags for 'includeexpr'
 2734 # endif
 2735 #endif
 2736 #if defined(FEAT_CINDENT) && defined(FEAT_EVAL)
 2737     char_u  *b_p_inde;  // 'indentexpr'
 2738     long_u  b_p_inde_flags; // flags for 'indentexpr'
 2739     char_u  *b_p_indk;  // 'indentkeys'
 2740 #endif
 2741     char_u  *b_p_fp;    // 'formatprg'
 2742 #if defined(FEAT_EVAL)
 2743     char_u  *b_p_fex;   // 'formatexpr'
 2744     long_u  b_p_fex_flags;  // flags for 'formatexpr'
 2745 #endif
 2746 #ifdef FEAT_CRYPT
 2747     char_u  *b_p_key;   // 'key'
 2748 #endif
 2749     char_u  *b_p_kp;    // 'keywordprg'
 2750 #ifdef FEAT_LISP
 2751     int     b_p_lisp;   // 'lisp'
 2752 #endif
 2753     char_u  *b_p_menc;  // 'makeencoding'
 2754     char_u  *b_p_mps;   // 'matchpairs'
 2755     int     b_p_ml;     // 'modeline'
 2756     int     b_p_ml_nobin;   // b_p_ml saved for binary mode
 2757     int     b_p_ma;     // 'modifiable'
 2758     char_u  *b_p_nf;    // 'nrformats'
 2759     int     b_p_pi;     // 'preserveindent'
 2760 #ifdef FEAT_TEXTOBJ
 2761     char_u  *b_p_qe;    // 'quoteescape'
 2762 #endif
 2763     int     b_p_ro;     // 'readonly'
 2764     long    b_p_sw;     // 'shiftwidth'
 2765     int     b_p_sn;     // 'shortname'
 2766 #ifdef FEAT_SMARTINDENT
 2767     int     b_p_si;     // 'smartindent'
 2768 #endif
 2769     long    b_p_sts;    // 'softtabstop'
 2770     long    b_p_sts_nopaste; // b_p_sts saved for paste mode
 2771 #ifdef FEAT_SEARCHPATH
 2772     char_u  *b_p_sua;   // 'suffixesadd'
 2773 #endif
 2774     int     b_p_swf;    // 'swapfile'
 2775 #ifdef FEAT_SYN_HL
 2776     long    b_p_smc;    // 'synmaxcol'
 2777     char_u  *b_p_syn;   // 'syntax'
 2778 #endif
 2779     long    b_p_ts;     // 'tabstop'
 2780     int     b_p_tx;     // 'textmode'
 2781     long    b_p_tw;     // 'textwidth'
 2782     long    b_p_tw_nobin;   // b_p_tw saved for binary mode
 2783     long    b_p_tw_nopaste; // b_p_tw saved for paste mode
 2784     long    b_p_wm;     // 'wrapmargin'
 2785     long    b_p_wm_nobin;   // b_p_wm saved for binary mode
 2786     long    b_p_wm_nopaste; // b_p_wm saved for paste mode
 2787 #ifdef FEAT_VARTABS
 2788     char_u  *b_p_vsts;  // 'varsofttabstop'
 2789     int     *b_p_vsts_array;   // 'varsofttabstop' in internal format
 2790     char_u  *b_p_vsts_nopaste; // b_p_vsts saved for paste mode
 2791     char_u  *b_p_vts;   // 'vartabstop'
 2792     int     *b_p_vts_array; // 'vartabstop' in internal format
 2793 #endif
 2794 #ifdef FEAT_KEYMAP
 2795     char_u  *b_p_keymap;    // 'keymap'
 2796 #endif
 2797 
 2798     /*
 2799      * local values for options which are normally global
 2800      */
 2801 #ifdef FEAT_QUICKFIX
 2802     char_u  *b_p_gp;    // 'grepprg' local value
 2803     char_u  *b_p_mp;    // 'makeprg' local value
 2804     char_u  *b_p_efm;   // 'errorformat' local value
 2805 #endif
 2806     char_u  *b_p_ep;    // 'equalprg' local value
 2807     char_u  *b_p_path;  // 'path' local value
 2808     int     b_p_ar;     // 'autoread' local value
 2809     char_u  *b_p_tags;  // 'tags' local value
 2810     char_u  *b_p_tc;    // 'tagcase' local value
 2811     unsigned    b_tc_flags;     // flags for 'tagcase'
 2812     char_u  *b_p_dict;  // 'dictionary' local value
 2813     char_u  *b_p_tsr;   // 'thesaurus' local value
 2814     long    b_p_ul;     // 'undolevels' local value
 2815 #ifdef FEAT_PERSISTENT_UNDO
 2816     int     b_p_udf;    // 'undofile'
 2817 #endif
 2818 #ifdef FEAT_LISP
 2819     char_u  *b_p_lw;    // 'lispwords' local value
 2820 #endif
 2821 #ifdef FEAT_TERMINAL
 2822     long    b_p_twsl;   // 'termwinscroll'
 2823 #endif
 2824 
 2825     /*
 2826      * end of buffer options
 2827      */
 2828 
 2829 #ifdef FEAT_CINDENT
 2830     // values set from b_p_cino
 2831     int     b_ind_level;
 2832     int     b_ind_open_imag;
 2833     int     b_ind_no_brace;
 2834     int     b_ind_first_open;
 2835     int     b_ind_open_extra;
 2836     int     b_ind_close_extra;
 2837     int     b_ind_open_left_imag;
 2838     int     b_ind_jump_label;
 2839     int     b_ind_case;
 2840     int     b_ind_case_code;
 2841     int     b_ind_case_break;
 2842     int     b_ind_param;
 2843     int     b_ind_func_type;
 2844     int     b_ind_comment;
 2845     int     b_ind_in_comment;
 2846     int     b_ind_in_comment2;
 2847     int     b_ind_cpp_baseclass;
 2848     int     b_ind_continuation;
 2849     int     b_ind_unclosed;
 2850     int     b_ind_unclosed2;
 2851     int     b_ind_unclosed_noignore;
 2852     int     b_ind_unclosed_wrapped;
 2853     int     b_ind_unclosed_whiteok;
 2854     int     b_ind_matching_paren;
 2855     int     b_ind_paren_prev;
 2856     int     b_ind_maxparen;
 2857     int     b_ind_maxcomment;
 2858     int     b_ind_scopedecl;
 2859     int     b_ind_scopedecl_code;
 2860     int     b_ind_java;
 2861     int     b_ind_js;
 2862     int     b_ind_keep_case_label;
 2863     int     b_ind_hash_comment;
 2864     int     b_ind_cpp_namespace;
 2865     int     b_ind_if_for_while;
 2866     int     b_ind_cpp_extern_c;
 2867     int     b_ind_pragma;
 2868 #endif
 2869 
 2870     linenr_T    b_no_eol_lnum;  // non-zero lnum when last line of next binary
 2871                 // write should not have an end-of-line
 2872 
 2873     int     b_start_eol;    // last line had eol when it was read
 2874     int     b_start_ffc;    // first char of 'ff' when edit started
 2875     char_u  *b_start_fenc;  // 'fileencoding' when edit started or NULL
 2876     int     b_bad_char; // "++bad=" argument when edit started or 0
 2877     int     b_start_bomb;   // 'bomb' when it was read
 2878 
 2879 #ifdef FEAT_EVAL
 2880     dictitem_T  b_bufvar;   // variable for "b:" Dictionary
 2881     dict_T  *b_vars;    // internal variables, local to buffer
 2882 
 2883     listener_T  *b_listener;
 2884     list_T  *b_recorded_changes;
 2885 #endif
 2886 #ifdef FEAT_PROP_POPUP
 2887     int     b_has_textprop; // TRUE when text props were added
 2888     hashtab_T   *b_proptypes;   // text property types local to buffer
 2889 #endif
 2890 
 2891 #if defined(FEAT_BEVAL) && defined(FEAT_EVAL)
 2892     char_u  *b_p_bexpr; // 'balloonexpr' local value
 2893     long_u  b_p_bexpr_flags;// flags for 'balloonexpr'
 2894 #endif
 2895 #ifdef FEAT_CRYPT
 2896     char_u  *b_p_cm;    // 'cryptmethod'
 2897 #endif
 2898 
 2899     // When a buffer is created, it starts without a swap file.  b_may_swap is
 2900     // then set to indicate that a swap file may be opened later.  It is reset
 2901     // if a swap file could not be opened.
 2902     int     b_may_swap;
 2903     int     b_did_warn; // Set to 1 if user has been warned on first
 2904                 // change of a read-only file
 2905 
 2906     // Two special kinds of buffers:
 2907     // help buffer  - used for help files, won't use a swap file.
 2908     // spell buffer - used for spell info, never displayed and doesn't have a
 2909     //            file name.
 2910     int     b_help;     // TRUE for help file buffer (when set b_p_bt
 2911                 // is "help")
 2912 #ifdef FEAT_SPELL
 2913     int     b_spell;    // TRUE for a spell file buffer, most fields
 2914                 // are not used!  Use the B_SPELL macro to
 2915                 // access b_spell without #ifdef.
 2916 #endif
 2917 
 2918     int     b_shortname;    // this file has an 8.3 file name
 2919 
 2920 #ifdef FEAT_JOB_CHANNEL
 2921     char_u  *b_prompt_text;     // set by prompt_setprompt()
 2922     callback_T  b_prompt_callback;  // set by prompt_setcallback()
 2923     callback_T  b_prompt_interrupt; // set by prompt_setinterrupt()
 2924     int     b_prompt_insert;    // value for restart_edit when entering
 2925                     // a prompt buffer window.
 2926 #endif
 2927 #ifdef FEAT_MZSCHEME
 2928     void    *b_mzscheme_ref; // The MzScheme reference to this buffer
 2929 #endif
 2930 
 2931 #ifdef FEAT_PERL
 2932     void    *b_perl_private;
 2933 #endif
 2934 
 2935 #ifdef FEAT_PYTHON
 2936     void    *b_python_ref;  // The Python reference to this buffer
 2937 #endif
 2938 
 2939 #ifdef FEAT_PYTHON3
 2940     void    *b_python3_ref; // The Python3 reference to this buffer
 2941 #endif
 2942 
 2943 #ifdef FEAT_TCL
 2944     void    *b_tcl_ref;
 2945 #endif
 2946 
 2947 #ifdef FEAT_RUBY
 2948     void    *b_ruby_ref;
 2949 #endif
 2950 
 2951 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL)
 2952     synblock_T  b_s;        // Info related to syntax highlighting.  w_s
 2953                 // normally points to this, but some windows
 2954                 // may use a different synblock_T.
 2955 #endif
 2956 
 2957 #ifdef FEAT_SIGNS
 2958     sign_entry_T *b_signlist;      // list of placed signs
 2959 # ifdef FEAT_NETBEANS_INTG
 2960     int     b_has_sign_column; // Flag that is set when a first sign is
 2961                    // added and remains set until the end of
 2962                    // the netbeans session.
 2963 # endif
 2964 #endif
 2965 
 2966 #ifdef FEAT_NETBEANS_INTG
 2967     int     b_netbeans_file;    // TRUE when buffer is owned by NetBeans
 2968     int     b_was_netbeans_file;// TRUE if b_netbeans_file was once set
 2969 #endif
 2970 #ifdef FEAT_JOB_CHANNEL
 2971     int     b_write_to_channel; // TRUE when appended lines are written to
 2972                     // a channel.
 2973 #endif
 2974 
 2975 #ifdef FEAT_CRYPT
 2976     cryptstate_T *b_cryptstate; // Encryption state while reading or writing
 2977                 // the file. NULL when not using encryption.
 2978 #endif
 2979     int     b_mapped_ctrl_c; // modes where CTRL-C is mapped
 2980 
 2981 #ifdef FEAT_TERMINAL
 2982     term_T  *b_term;    // When not NULL this buffer is for a terminal
 2983                 // window.
 2984 #endif
 2985 #ifdef FEAT_DIFF
 2986     int     b_diff_failed;  // internal diff failed for this buffer
 2987 #endif
 2988 }; // file_buffer
 2989 
 2990 
 2991 #ifdef FEAT_DIFF
 2992 /*
 2993  * Stuff for diff mode.
 2994  */
 2995 # define DB_COUNT 8 // up to eight buffers can be diff'ed
 2996 
 2997 /*
 2998  * Each diffblock defines where a block of lines starts in each of the buffers
 2999  * and how many lines it occupies in that buffer.  When the lines are missing
 3000  * in the buffer the df_count[] is zero.  This is all counted in
 3001  * buffer lines.
 3002  * There is always at least one unchanged line in between the diffs.
 3003  * Otherwise it would have been included in the diff above or below it.
 3004  * df_lnum[] + df_count[] is the lnum below the change.  When in one buffer
 3005  * lines have been inserted, in the other buffer df_lnum[] is the line below
 3006  * the insertion and df_count[] is zero.  When appending lines at the end of
 3007  * the buffer, df_lnum[] is one beyond the end!
 3008  * This is using a linked list, because the number of differences is expected
 3009  * to be reasonable small.  The list is sorted on lnum.
 3010  */
 3011 typedef struct diffblock_S diff_T;
 3012 struct diffblock_S
 3013 {
 3014     diff_T  *df_next;
 3015     linenr_T    df_lnum[DB_COUNT];  // line number in buffer
 3016     linenr_T    df_count[DB_COUNT]; // nr of inserted/changed lines
 3017 };
 3018 #endif
 3019 
 3020 #define SNAP_HELP_IDX   0
 3021 #define SNAP_AUCMD_IDX 1
 3022 #define SNAP_COUNT  2
 3023 
 3024 /*
 3025  * Tab pages point to the top frame of each tab page.
 3026  * Note: Most values are NOT valid for the current tab page!  Use "curwin",
 3027  * "firstwin", etc. for that.  "tp_topframe" is always valid and can be
 3028  * compared against "topframe" to find the current tab page.
 3029  */
 3030 typedef struct tabpage_S tabpage_T;
 3031 struct tabpage_S
 3032 {
 3033     tabpage_T       *tp_next;       // next tabpage or NULL
 3034     frame_T     *tp_topframe;   // topframe for the windows
 3035     win_T       *tp_curwin;     // current window in this Tab page
 3036     win_T       *tp_prevwin;    // previous window in this Tab page
 3037     win_T       *tp_firstwin;   // first window in this Tab page
 3038     win_T       *tp_lastwin;    // last window in this Tab page
 3039 #ifdef FEAT_PROP_POPUP
 3040     win_T       *tp_first_popupwin; // first popup window in this Tab page
 3041 #endif
 3042     long        tp_old_Rows;    // Rows when Tab page was left
 3043     long        tp_old_Columns; // Columns when Tab page was left
 3044     long        tp_ch_used;     // value of 'cmdheight' when frame size
 3045                     // was set
 3046 #ifdef FEAT_GUI
 3047     int         tp_prev_which_scrollbars[3];
 3048                     // previous value of which_scrollbars
 3049 #endif
 3050 
 3051     char_u      *tp_localdir;   // absolute path of local directory or
 3052                     // NULL
 3053     char_u      *tp_prevdir;    // previous directory
 3054 
 3055 #ifdef FEAT_DIFF
 3056     diff_T      *tp_first_diff;
 3057     buf_T       *(tp_diffbuf[DB_COUNT]);
 3058     int         tp_diff_invalid;    // list of diffs is outdated
 3059     int         tp_diff_update; // update diffs before redrawing
 3060 #endif
 3061     frame_T     *(tp_snapshot[SNAP_COUNT]);  // window layout snapshots
 3062 #ifdef FEAT_EVAL
 3063     dictitem_T      tp_winvar;      // variable for "t:" Dictionary
 3064     dict_T      *tp_vars;       // internal variables, local to tab page
 3065 #endif
 3066 
 3067 #ifdef FEAT_PYTHON
 3068     void        *tp_python_ref; // The Python value for this tab page
 3069 #endif
 3070 
 3071 #ifdef FEAT_PYTHON3
 3072     void        *tp_python3_ref;    // The Python value for this tab page
 3073 #endif
 3074 };
 3075 
 3076 /*
 3077  * Structure to cache info for displayed lines in w_lines[].
 3078  * Each logical line has one entry.
 3079  * The entry tells how the logical line is currently displayed in the window.
 3080  * This is updated when displaying the window.
 3081  * When the display is changed (e.g., when clearing the screen) w_lines_valid
 3082  * is changed to exclude invalid entries.
 3083  * When making changes to the buffer, wl_valid is reset to indicate wl_size
 3084  * may not reflect what is actually in the buffer.  When wl_valid is FALSE,
 3085  * the entries can only be used to count the number of displayed lines used.
 3086  * wl_lnum and wl_lastlnum are invalid too.
 3087  */
 3088 typedef struct w_line
 3089 {
 3090     linenr_T    wl_lnum;    // buffer line number for logical line
 3091     short_u wl_size;    // height in screen lines
 3092     char    wl_valid;   // TRUE values are valid for text in buffer
 3093 #ifdef FEAT_FOLDING
 3094     char    wl_folded;  // TRUE when this is a range of folded lines
 3095     linenr_T    wl_lastlnum;    // last buffer line number for logical line
 3096 #endif
 3097 } wline_T;
 3098 
 3099 /*
 3100  * Windows are kept in a tree of frames.  Each frame has a column (FR_COL)
 3101  * or row (FR_ROW) layout or is a leaf, which has a window.
 3102  */
 3103 struct frame_S
 3104 {
 3105     char    fr_layout;  // FR_LEAF, FR_COL or FR_ROW
 3106     int     fr_width;
 3107     int     fr_newwidth;    // new width used in win_equal_rec()
 3108     int     fr_height;
 3109     int     fr_newheight;   // new height used in win_equal_rec()
 3110     frame_T *fr_parent; // containing frame or NULL
 3111     frame_T *fr_next;   // frame right or below in same parent, NULL
 3112                 // for last
 3113     frame_T *fr_prev;   // frame left or above in same parent, NULL
 3114                 // for first
 3115     // fr_child and fr_win are mutually exclusive
 3116     frame_T *fr_child;  // first contained frame
 3117     win_T   *fr_win;    // window that fills this frame
 3118 };
 3119 
 3120 #define FR_LEAF 0   // frame is a leaf
 3121 #define FR_ROW  1   // frame with a row of windows
 3122 #define FR_COL  2   // frame with a column of windows
 3123 
 3124 /*
 3125  * Struct used for highlighting 'hlsearch' matches, matches defined by
 3126  * ":match" and matches defined by match functions.
 3127  * For 'hlsearch' there is one pattern for all windows.  For ":match" and the
 3128  * match functions there is a different pattern for each window.
 3129  */
 3130 typedef struct
 3131 {
 3132     regmmatch_T rm;     // points to the regexp program; contains last
 3133                 // found match (may continue in next line)
 3134     buf_T   *buf;       // the buffer to search for a match
 3135     linenr_T    lnum;       // the line to search for a match
 3136     int     attr;       // attributes to be used for a match
 3137     int     attr_cur;   // attributes currently active in win_line()
 3138     linenr_T    first_lnum; // first lnum to search for multi-line pat
 3139     colnr_T startcol;   // in win_line() points to char where HL starts
 3140     colnr_T endcol;     // in win_line() points to char where HL ends
 3141     int     is_addpos;  // position specified directly by
 3142                 // matchaddpos(). TRUE/FALSE
 3143 #ifdef FEAT_RELTIME
 3144     proftime_T  tm;     // for a time limit
 3145 #endif
 3146 } match_T;
 3147 
 3148 // number of positions supported by matchaddpos()
 3149 #define MAXPOSMATCH 8
 3150 
 3151 /*
 3152  * Same as lpos_T, but with additional field len.
 3153  */
 3154 typedef struct
 3155 {
 3156     linenr_T    lnum;   // line number
 3157     colnr_T col;    // column number
 3158     int     len;    // length: 0 - to the end of line
 3159 } llpos_T;
 3160 
 3161 /*
 3162  * posmatch_T provides an array for storing match items for matchaddpos()
 3163  * function.
 3164  */
 3165 typedef struct posmatch posmatch_T;
 3166 struct posmatch
 3167 {
 3168     llpos_T pos[MAXPOSMATCH];   // array of positions
 3169     int     cur;            // internal position counter
 3170     linenr_T    toplnum;        // top buffer line
 3171     linenr_T    botlnum;        // bottom buffer line
 3172 };
 3173 
 3174 /*
 3175  * matchitem_T provides a linked list for storing match items for ":match" and
 3176  * the match functions.
 3177  */
 3178 typedef struct matchitem matchitem_T;
 3179 struct matchitem
 3180 {
 3181     matchitem_T *next;
 3182     int     id;     // match ID
 3183     int     priority;   // match priority
 3184     char_u  *pattern;   // pattern to highlight
 3185     regmmatch_T match;      // regexp program for pattern
 3186     posmatch_T  pos;        // position matches
 3187     match_T hl;     // struct for doing the actual highlighting
 3188     int     hlg_id;     // highlight group ID
 3189 #ifdef FEAT_CONCEAL
 3190     int     conceal_char; // cchar for Conceal highlighting
 3191 #endif
 3192 };
 3193 
 3194 // Structure to store last cursor position and topline.  Used by check_lnums()
 3195 // and reset_lnums().
 3196 typedef struct
 3197 {
 3198     int     w_topline_save; // original topline value
 3199     int     w_topline_corr; // corrected topline value
 3200     pos_T   w_cursor_save;  // original cursor position
 3201     pos_T   w_cursor_corr;  // corrected cursor position
 3202 } pos_save_T;
 3203 
 3204 #ifdef FEAT_MENU
 3205 typedef struct {
 3206     int     wb_startcol;
 3207     int     wb_endcol;
 3208     vimmenu_T   *wb_menu;
 3209 } winbar_item_T;
 3210 #endif
 3211 
 3212 /*
 3213  * Structure which contains all information that belongs to a window
 3214  *
 3215  * All row numbers are relative to the start of the window, except w_winrow.
 3216  */
 3217 struct window_S
 3218 {
 3219     int     w_id;           // unique window ID
 3220 
 3221     buf_T   *w_buffer;      // buffer we are a window into
 3222 
 3223     win_T   *w_prev;        // link to previous window
 3224     win_T   *w_next;        // link to next window
 3225 
 3226 #if defined(FEAT_SYN_HL) || defined(FEAT_SPELL)
 3227     synblock_T  *w_s;           // for :ownsyntax
 3228 #endif
 3229 
 3230     int     w_closing;      // window is being closed, don't let
 3231                     // autocommands close it too.
 3232 
 3233     frame_T *w_frame;       // frame containing this window
 3234 
 3235     pos_T   w_cursor;       // cursor position in buffer
 3236 
 3237     colnr_T w_curswant;     // The column we'd like to be at.  This is
 3238                     // used to try to stay in the same column
 3239                     // for up/down cursor motions.
 3240 
 3241     int     w_set_curswant;     // If set, then update w_curswant the next
 3242                     // time through cursupdate() to the
 3243                     // current virtual column
 3244 
 3245 #ifdef FEAT_SYN_HL
 3246     linenr_T    w_last_cursorline;  // where last time 'cursorline' was drawn
 3247 #endif
 3248 
 3249     /*
 3250      * the next seven are used to update the Visual highlighting
 3251      */
 3252     char    w_old_visual_mode;  // last known VIsual_mode
 3253     linenr_T    w_old_cursor_lnum;  // last known end of visual part
 3254     colnr_T w_old_cursor_fcol;  // first column for block visual part
 3255     colnr_T w_old_cursor_lcol;  // last column for block visual part
 3256     linenr_T    w_old_visual_lnum;  // last known start of visual part
 3257     colnr_T w_old_visual_col;   // last known start of visual part
 3258     colnr_T w_old_curswant;     // last known value of Curswant
 3259 
 3260     /*
 3261      * "w_topline", "w_leftcol" and "w_skipcol" specify the offsets for
 3262      * displaying the buffer.
 3263      */
 3264     linenr_T    w_topline;      // buffer line number of the line at the
 3265                     // top of the window
 3266     char    w_topline_was_set;  // flag set to TRUE when topline is set,
 3267                     // e.g. by winrestview()
 3268 #ifdef FEAT_DIFF
 3269     int     w_topfill;      // number of filler lines above w_topline
 3270     int     w_old_topfill;      // w_topfill at last redraw
 3271     int     w_botfill;      // TRUE when filler lines are actually
 3272                     // below w_topline (at end of file)
 3273     int     w_old_botfill;      // w_botfill at last redraw
 3274 #endif
 3275     colnr_T w_leftcol;      // window column number of the left most
 3276                     // character in the window; used when
 3277                     // 'wrap' is off
 3278     colnr_T w_skipcol;      // starting column when a single line
 3279                     // doesn't fit in the window
 3280 
 3281     /*
 3282      * Layout of the window in the screen.
 3283      * May need to add "msg_scrolled" to "w_winrow" in rare situations.
 3284      */
 3285     int     w_winrow;       // first row of window in screen
 3286     int     w_height;       // number of rows in window, excluding
 3287                     // status/command/winbar line(s)
 3288     int     w_status_height;    // number of status lines (0 or 1)
 3289     int     w_wincol;       // Leftmost column of window in screen.
 3290     int     w_width;        // Width of window, excluding separation.
 3291     int     w_vsep_width;       // Number of separator columns (0 or 1).
 3292     pos_save_T  w_save_cursor;      // backup of cursor pos and topline
 3293 #ifdef FEAT_PROP_POPUP
 3294     int     w_popup_flags;      // POPF_ values
 3295     int     w_popup_handled;    // POPUP_HANDLE[0-9] flags
 3296     char_u  *w_popup_title;
 3297     poppos_T    w_popup_pos;
 3298     int     w_popup_fixed;      // do not shift popup to fit on screen
 3299     int     w_popup_prop_type;  // when not zero: textprop type ID
 3300     win_T   *w_popup_prop_win;  // window to search for textprop
 3301     int     w_popup_prop_id;    // when not zero: textprop ID
 3302     int     w_zindex;
 3303     int     w_minheight;        // "minheight" for popup window
 3304     int     w_minwidth;     // "minwidth" for popup window
 3305     int     w_maxheight;        // "maxheight" for popup window
 3306     int     w_maxwidth;     // "maxwidth" for popup window
 3307     int     w_maxwidth_opt;     // maxwidth from option
 3308     int     w_wantline;     // "line" for popup window
 3309     int     w_wantcol;      // "col" for popup window
 3310     int     w_firstline;        // "firstline" for popup window
 3311     int     w_want_scrollbar;   // when zero don't use a scrollbar
 3312     int     w_has_scrollbar;    // 1 if scrollbar displayed, 0 otherwise
 3313     char_u  *w_scrollbar_highlight; // "scrollbarhighlight"
 3314     char_u  *w_thumb_highlight; // "thumbhighlight"
 3315     int     w_popup_padding[4]; // popup padding top/right/bot/left
 3316     int     w_popup_border[4];  // popup border top/right/bot/left
 3317     char_u  *w_border_highlight[4];  // popup border highlight
 3318     int     w_border_char[8];   // popup border characters
 3319 
 3320     int     w_popup_leftoff;    // columns left of the screen
 3321     int     w_popup_rightoff;   // columns right of the screen
 3322     varnumber_T w_popup_last_changedtick; // b:changedtick of popup buffer
 3323                       // when position was computed
 3324     varnumber_T w_popup_prop_changedtick; // b:changedtick of buffer with
 3325                       // w_popup_prop_type when position
 3326                       // was computed
 3327     int     w_popup_prop_topline; // w_topline of window with
 3328                       // w_popup_prop_type when position was
 3329                       // computed
 3330     linenr_T    w_popup_last_curline; // last known w_cursor.lnum of window
 3331                       // with "cursorline" set
 3332     callback_T  w_close_cb;     // popup close callback
 3333     callback_T  w_filter_cb;        // popup filter callback
 3334     int     w_filter_mode;      // mode when filter callback is used
 3335 
 3336     win_T   *w_popup_curwin;    // close popup if curwin differs
 3337     linenr_T    w_popup_lnum;       // close popup if cursor not on this line
 3338     colnr_T w_popup_mincol;     // close popup if cursor before this col
 3339     colnr_T w_popup_maxcol;     // close popup if cursor after this col
 3340     int     w_popup_mouse_row;  // close popup if mouse moves away
 3341     int     w_popup_mouse_mincol;  // close popup if mouse moves away
 3342     int     w_popup_mouse_maxcol;  // close popup if mouse moves away
 3343     popclose_T  w_popup_close;      // allow closing the popup with the mouse
 3344 
 3345     list_T  *w_popup_mask;       // list of lists for "mask"
 3346     char_u  *w_popup_mask_cells; // cached mask cells
 3347     int     w_popup_mask_height; // height of w_popup_mask_cells
 3348     int     w_popup_mask_width;  // width of w_popup_mask_cells
 3349 # if defined(FEAT_TIMERS)
 3350     timer_T *w_popup_timer;     // timer for closing popup window
 3351 # endif
 3352 #endif
 3353 
 3354 
 3355     /*
 3356      * === start of cached values ====
 3357      */
 3358     /*
 3359      * Recomputing is minimized by storing the result of computations.
 3360      * Use functions in screen.c to check if they are valid and to update.
 3361      * w_valid is a bitfield of flags, which indicate if specific values are
 3362      * valid or need to be recomputed.  See screen.c for values.
 3363      */
 3364     int     w_valid;
 3365     pos_T   w_valid_cursor;     // last known position of w_cursor, used
 3366                     // to adjust w_valid
 3367     colnr_T w_valid_leftcol;    // last known w_leftcol
 3368 
 3369     /*
 3370      * w_cline_height is the number of physical lines taken by the buffer line
 3371      * that the cursor is on.  We use this to avoid extra calls to plines().
 3372      */
 3373     int     w_cline_height;     // current size of cursor line
 3374 #ifdef FEAT_FOLDING
 3375     int     w_cline_folded;     // cursor line is folded
 3376 #endif
 3377 
 3378     int     w_cline_row;        // starting row of the cursor line
 3379 
 3380     colnr_T w_virtcol;      // column number of the cursor in the
 3381                     // buffer line, as opposed to the column
 3382                     // number we're at on the screen.  This
 3383                     // makes a difference on lines which span
 3384                     // more than one screen line or when
 3385                     // w_leftcol is non-zero
 3386 
 3387     /*
 3388      * w_wrow and w_wcol specify the cursor position in the window.
 3389      * This is related to positions in the window, not in the display or
 3390      * buffer, thus w_wrow is relative to w_winrow.
 3391      */
 3392     int     w_wrow, w_wcol;     // cursor position in window
 3393 
 3394     linenr_T    w_botline;      // number of the line below the bottom of
 3395                     // the window
 3396     int     w_empty_rows;       // number of ~ rows in window
 3397 #ifdef FEAT_DIFF
 3398     int     w_filler_rows;      // number of filler rows at the end of the
 3399                     // window
 3400 #endif
 3401 
 3402     /*
 3403      * Info about the lines currently in the window is remembered to avoid
 3404      * recomputing it every time.  The allocated size of w_lines[] is Rows.
 3405      * Only the w_lines_valid entries are actually valid.
 3406      * When the display is up-to-date w_lines[0].wl_lnum is equal to w_topline
 3407      * and w_lines[w_lines_valid - 1].wl_lnum is equal to w_botline.
 3408      * Between changing text and updating the display w_lines[] represents
 3409      * what is currently displayed.  wl_valid is reset to indicated this.
 3410      * This is used for efficient redrawing.
 3411      */
 3412     int     w_lines_valid;      // number of valid entries
 3413     wline_T *w_lines;
 3414 
 3415 #ifdef FEAT_FOLDING
 3416     garray_T    w_folds;        // array of nested folds
 3417     char    w_fold_manual;      // when TRUE: some folds are opened/closed
 3418                     // manually
 3419     char    w_foldinvalid;      // when TRUE: folding needs to be
 3420                     // recomputed
 3421 #endif
 3422 #ifdef FEAT_LINEBREAK
 3423     int     w_nrwidth;      // width of 'number' and 'relativenumber'
 3424                     // column being used
 3425 #endif
 3426 
 3427     /*
 3428      * === end of cached values ===
 3429      */
 3430 
 3431     int     w_redr_type;        // type of redraw to be performed on win
 3432     int     w_upd_rows;     // number of window lines to update when
 3433                     // w_redr_type is REDRAW_TOP
 3434     linenr_T    w_redraw_top;       // when != 0: first line needing redraw
 3435     linenr_T    w_redraw_bot;       // when != 0: last line needing redraw
 3436     int     w_redr_status;      // if TRUE status line must be redrawn
 3437 
 3438 #ifdef FEAT_CMDL_INFO
 3439     // remember what is shown in the ruler for this window (if 'ruler' set)
 3440     pos_T   w_ru_cursor;        // cursor position shown in ruler
 3441     colnr_T w_ru_virtcol;       // virtcol shown in ruler
 3442     linenr_T    w_ru_topline;       // topline shown in ruler
 3443     linenr_T    w_ru_line_count;    // line count used for ruler
 3444 # ifdef FEAT_DIFF
 3445     int     w_ru_topfill;       // topfill shown in ruler
 3446 # endif
 3447     char    w_ru_empty;     // TRUE if ruler shows 0-1 (empty line)
 3448 #endif
 3449 
 3450     int     w_alt_fnum;     // alternate file (for # and CTRL-^)
 3451 
 3452     alist_T *w_alist;       // pointer to arglist for this window
 3453     int     w_arg_idx;      // current index in argument list (can be
 3454                     // out of range!)
 3455     int     w_arg_idx_invalid;  // editing another file than w_arg_idx
 3456 
 3457     char_u  *w_localdir;        // absolute path of local directory or
 3458                     // NULL
 3459     char_u  *w_prevdir;     // previous directory
 3460 #ifdef FEAT_MENU
 3461     vimmenu_T   *w_winbar;      // The root of the WinBar menu hierarchy.
 3462     winbar_item_T *w_winbar_items;  // list of items in the WinBar
 3463     int     w_winbar_height;    // 1 if there is a window toolbar
 3464 #endif
 3465 
 3466     /*
 3467      * Options local to a window.
 3468      * They are local because they influence the layout of the window or
 3469      * depend on the window layout.
 3470      * There are two values: w_onebuf_opt is local to the buffer currently in
 3471      * this window, w_allbuf_opt is for all buffers in this window.
 3472      */
 3473     winopt_T    w_onebuf_opt;
 3474     winopt_T    w_allbuf_opt;
 3475 
 3476     // A few options have local flags for P_INSECURE.
 3477 #ifdef FEAT_STL_OPT
 3478     long_u  w_p_stl_flags;      // flags for 'statusline'
 3479 #endif
 3480 #ifdef FEAT_EVAL
 3481     long_u  w_p_fde_flags;      // flags for 'foldexpr'
 3482     long_u  w_p_fdt_flags;      // flags for 'foldtext'
 3483 #endif
 3484 #ifdef FEAT_SYN_HL
 3485     int     *w_p_cc_cols;       // array of columns to highlight or NULL
 3486     char_u  w_p_culopt_flags;   // flags for cursorline highlighting
 3487 #endif
 3488     long    w_p_siso;       // 'sidescrolloff' local value
 3489     long    w_p_so;         // 'scrolloff' local value
 3490 
 3491 #ifdef FEAT_LINEBREAK
 3492     int     w_briopt_min;       // minimum width for breakindent
 3493     int     w_briopt_shift;     // additional shift for breakindent
 3494     int     w_briopt_sbr;       // sbr in 'briopt'
 3495 #endif
 3496 
 3497     // transform a pointer to a "onebuf" option into a "allbuf" option
 3498 #define GLOBAL_WO(p)    ((char *)p + sizeof(winopt_T))
 3499 
 3500     long    w_scbind_pos;
 3501 
 3502 #ifdef FEAT_EVAL
 3503     dictitem_T  w_winvar;   // variable for "w:" Dictionary
 3504     dict_T  *w_vars;    // internal variables, local to window
 3505 #endif
 3506 
 3507     /*
 3508      * The w_prev_pcmark field is used to check whether we really did jump to
 3509      * a new line after setting the w_pcmark.  If not, then we revert to
 3510      * using the previous w_pcmark.
 3511      */
 3512     pos_T   w_pcmark;   // previous context mark
 3513     pos_T   w_prev_pcmark;  // previous w_pcmark
 3514 
 3515 #ifdef FEAT_JUMPLIST
 3516     /*
 3517      * the jumplist contains old cursor positions
 3518      */
 3519     xfmark_T    w_jumplist[JUMPLISTSIZE];
 3520     int     w_jumplistlen;      // number of active entries
 3521     int     w_jumplistidx;      // current position
 3522 
 3523     int     w_changelistidx;    // current position in b_changelist
 3524 #endif
 3525 
 3526 #ifdef FEAT_SEARCH_EXTRA
 3527     matchitem_T *w_match_head;      // head of match list
 3528     int     w_next_match_id;    // next match ID
 3529 #endif
 3530 
 3531     /*
 3532      * the tagstack grows from 0 upwards:
 3533      * entry 0: older
 3534      * entry 1: newer
 3535      * entry 2: newest
 3536      */
 3537     taggy_T w_tagstack[TAGSTACKSIZE];   // the tag stack
 3538     int     w_tagstackidx;          // idx just below active entry
 3539     int     w_tagstacklen;          // number of tags on stack
 3540 
 3541     /*
 3542      * w_fraction is the fractional row of the cursor within the window, from
 3543      * 0 at the top row to FRACTION_MULT at the last row.
 3544      * w_prev_fraction_row was the actual cursor row when w_fraction was last
 3545      * calculated.
 3546      */
 3547     int     w_fraction;
 3548     int     w_prev_fraction_row;
 3549 
 3550 #ifdef FEAT_GUI
 3551     scrollbar_T w_scrollbars[2];    // vert. Scrollbars for this window
 3552 #endif
 3553 #ifdef FEAT_LINEBREAK
 3554     linenr_T    w_nrwidth_line_count;   // line count when ml_nrwidth_width
 3555                     // was computed.
 3556     long    w_nuw_cached;       // 'numberwidth' option cached
 3557     int     w_nrwidth_width;    // nr of chars to print line count.
 3558 #endif
 3559 
 3560 #ifdef FEAT_QUICKFIX
 3561     qf_info_T   *w_llist;       // Location list for this window
 3562     /*
 3563      * Location list reference used in the location list window.
 3564      * In a non-location list window, w_llist_ref is NULL.
 3565      */
 3566     qf_info_T   *w_llist_ref;
 3567 #endif
 3568 
 3569 #ifdef FEAT_MZSCHEME
 3570     void    *w_mzscheme_ref;    // The MzScheme value for this window
 3571 #endif
 3572 
 3573 #ifdef FEAT_PERL
 3574     void    *w_perl_private;
 3575 #endif
 3576 
 3577 #ifdef FEAT_PYTHON
 3578     void    *w_python_ref;      // The Python value for this window
 3579 #endif
 3580 
 3581 #ifdef FEAT_PYTHON3
 3582     void    *w_python3_ref;     // The Python value for this window
 3583 #endif
 3584 
 3585 #ifdef FEAT_TCL
 3586     void    *w_tcl_ref;
 3587 #endif
 3588 
 3589 #ifdef FEAT_RUBY
 3590     void    *w_ruby_ref;
 3591 #endif
 3592 };
 3593 
 3594 /*
 3595  * Arguments for operators.
 3596  */
 3597 typedef struct oparg_S
 3598 {
 3599     int     op_type;    // current pending operator type
 3600     int     regname;    // register to use for the operator
 3601     int     motion_type;    // type of the current cursor motion
 3602     int     motion_force;   // force motion type: 'v', 'V' or CTRL-V
 3603     int     use_reg_one;    // TRUE if delete uses reg 1 even when not
 3604                 // linewise
 3605     int     inclusive;  // TRUE if char motion is inclusive (only
 3606                 // valid when motion_type is MCHAR
 3607     int     end_adjusted;   // backuped b_op_end one char (only used by
 3608                 // do_format())
 3609     pos_T   start;      // start of the operator
 3610     pos_T   end;        // end of the operator
 3611     pos_T   cursor_start;   // cursor position before motion for "gw"
 3612 
 3613     long    line_count; // number of lines from op_start to op_end
 3614                 // (inclusive)
 3615     int     empty;      // op_start and op_end the same (only used by
 3616                 // do_change())
 3617     int     is_VIsual;  // operator on Visual area
 3618     int     block_mode; // current operator is Visual block mode
 3619     colnr_T start_vcol; // start col for block mode operator
 3620     colnr_T end_vcol;   // end col for block mode operator
 3621     long    prev_opcount;   // ca.opcount saved for K_CURSORHOLD
 3622     long    prev_count0;    // ca.count0 saved for K_CURSORHOLD
 3623 } oparg_T;
 3624 
 3625 /*
 3626  * Arguments for Normal mode commands.
 3627  */
 3628 typedef struct cmdarg_S
 3629 {
 3630     oparg_T *oap;       // Operator arguments
 3631     int     prechar;    // prefix character (optional, always 'g')
 3632     int     cmdchar;    // command character
 3633     int     nchar;      // next command character (optional)
 3634     int     ncharC1;    // first composing character (optional)
 3635     int     ncharC2;    // second composing character (optional)
 3636     int     extra_char; // yet another character (optional)
 3637     long    opcount;    // count before an operator
 3638     long    count0;     // count before command, default 0
 3639     long    count1;     // count before command, default 1
 3640     int     arg;        // extra argument from nv_cmds[]
 3641     int     retval;     // return: CA_* values
 3642     char_u  *searchbuf; // return: pointer to search pattern or NULL
 3643 } cmdarg_T;
 3644 
 3645 // values for retval:
 3646 #define CA_COMMAND_BUSY     1   // skip restarting edit() once
 3647 #define CA_NO_ADJ_OP_END    2   // don't adjust operator end
 3648 
 3649 #ifdef CURSOR_SHAPE
 3650 /*
 3651  * struct to store values from 'guicursor' and 'mouseshape'
 3652  */
 3653 // Indexes in shape_table[]
 3654 #define SHAPE_IDX_N 0   // Normal mode
 3655 #define SHAPE_IDX_V 1   // Visual mode
 3656 #define SHAPE_IDX_I 2   // Insert mode
 3657 #define SHAPE_IDX_R 3   // Replace mode
 3658 #define SHAPE_IDX_C 4   // Command line Normal mode
 3659 #define SHAPE_IDX_CI    5   // Command line Insert mode
 3660 #define SHAPE_IDX_CR    6   // Command line Replace mode
 3661 #define SHAPE_IDX_O 7   // Operator-pending mode
 3662 #define SHAPE_IDX_VE    8   // Visual mode with 'selection' exclusive
 3663 #define SHAPE_IDX_CLINE 9   // On command line
 3664 #define SHAPE_IDX_STATUS 10 // A status line
 3665 #define SHAPE_IDX_SDRAG 11  // dragging a status line
 3666 #define SHAPE_IDX_VSEP  12  // A vertical separator line
 3667 #define SHAPE_IDX_VDRAG 13  // dragging a vertical separator line
 3668 #define SHAPE_IDX_MORE  14  // Hit-return or More
 3669 #define SHAPE_IDX_MOREL 15  // Hit-return or More in last line
 3670 #define SHAPE_IDX_SM    16  // showing matching paren
 3671 #define SHAPE_IDX_COUNT 17
 3672 
 3673 #define SHAPE_BLOCK 0   // block cursor
 3674 #define SHAPE_HOR   1   // horizontal bar cursor
 3675 #define SHAPE_VER   2   // vertical bar cursor
 3676 
 3677 #define MSHAPE_NUMBERED 1000    // offset for shapes identified by number
 3678 #define MSHAPE_HIDE 1   // hide mouse pointer
 3679 
 3680 #define SHAPE_MOUSE 1   // used for mouse pointer shape
 3681 #define SHAPE_CURSOR    2   // used for text cursor shape
 3682 
 3683 typedef struct cursor_entry
 3684 {
 3685     int     shape;      // one of the SHAPE_ defines
 3686     int     mshape;     // one of the MSHAPE defines
 3687     int     percentage; // percentage of cell for bar
 3688     long    blinkwait;  // blinking, wait time before blinking starts
 3689     long    blinkon;    // blinking, on time
 3690     long    blinkoff;   // blinking, off time
 3691     int     id;     // highlight group ID
 3692     int     id_lm;      // highlight group ID for :lmap mode
 3693     char    *name;      // mode name (fixed)
 3694     char    used_for;   // SHAPE_MOUSE and/or SHAPE_CURSOR
 3695 } cursorentry_T;
 3696 #endif // CURSOR_SHAPE
 3697 
 3698 #ifdef FEAT_MENU
 3699 
 3700 // Indices into vimmenu_T->strings[] and vimmenu_T->noremap[] for each mode
 3701 #define MENU_INDEX_INVALID  -1
 3702 #define MENU_INDEX_NORMAL   0
 3703 #define MENU_INDEX_VISUAL   1
 3704 #define MENU_INDEX_SELECT   2
 3705 #define MENU_INDEX_OP_PENDING   3
 3706 #define MENU_INDEX_INSERT   4
 3707 #define MENU_INDEX_CMDLINE  5
 3708 #define MENU_INDEX_TERMINAL 6
 3709 #define MENU_INDEX_TIP      7
 3710 #define MENU_MODES      8
 3711 
 3712 // Menu modes
 3713 #define MENU_NORMAL_MODE    (1 << MENU_INDEX_NORMAL)
 3714 #define MENU_VISUAL_MODE    (1 << MENU_INDEX_VISUAL)
 3715 #define MENU_SELECT_MODE    (1 << MENU_INDEX_SELECT)
 3716 #define MENU_OP_PENDING_MODE    (1 << MENU_INDEX_OP_PENDING)
 3717 #define MENU_INSERT_MODE    (1 << MENU_INDEX_INSERT)
 3718 #define MENU_CMDLINE_MODE   (1 << MENU_INDEX_CMDLINE)
 3719 #define MENU_TERMINAL_MODE  (1 << MENU_INDEX_TERMINAL)
 3720 #define MENU_TIP_MODE       (1 << MENU_INDEX_TIP)
 3721 #define MENU_ALL_MODES      ((1 << MENU_INDEX_TIP) - 1)
 3722 // note MENU_INDEX_TIP is not a 'real' mode
 3723 
 3724 // Start a menu name with this to not include it on the main menu bar
 3725 #define MNU_HIDDEN_CHAR     ']'
 3726 
 3727 struct VimMenu
 3728 {
 3729     int     modes;          // Which modes is this menu visible for?
 3730     int     enabled;        // for which modes the menu is enabled
 3731     char_u  *name;          // Name of menu, possibly translated
 3732     char_u  *dname;         // Displayed Name ("name" without '&')
 3733 #ifdef FEAT_MULTI_LANG
 3734     char_u  *en_name;       // "name" untranslated, NULL when "name"
 3735                     // was not translated
 3736     char_u  *en_dname;      // "dname" untranslated, NULL when "dname"
 3737                     // was not translated
 3738 #endif
 3739     int     mnemonic;       // mnemonic key (after '&')
 3740     char_u  *actext;        // accelerator text (after TAB)
 3741     int     priority;       // Menu order priority
 3742 #ifdef FEAT_GUI
 3743     void    (*cb)(vimmenu_T *); // Call-back function
 3744 #endif
 3745 #ifdef FEAT_TOOLBAR
 3746     char_u  *iconfile;      // name of file for icon or NULL
 3747     int     iconidx;        // icon index (-1 if not set)
 3748     int     icon_builtin;       // icon names is BuiltIn{nr}
 3749 #endif
 3750     char_u  *strings[MENU_MODES]; // Mapped string for each mode
 3751     int     noremap[MENU_MODES]; // A REMAP_ flag for each mode
 3752     char    silent[MENU_MODES]; // A silent flag for each mode
 3753     vimmenu_T   *children;      // Children of sub-menu
 3754     vimmenu_T   *parent;        // Parent of menu
 3755     vimmenu_T   *next;          // Next item in menu
 3756 #ifdef FEAT_GUI_X11
 3757     Widget  id;         // Manage this to enable item
 3758     Widget  submenu_id;     // If this is submenu, add children here
 3759 #endif
 3760 #ifdef FEAT_GUI_GTK
 3761     GtkWidget   *id;            // Manage this to enable item
 3762     GtkWidget   *submenu_id;        // If this is submenu, add children here
 3763 # if defined(GTK_CHECK_VERSION) && !GTK_CHECK_VERSION(3,4,0)
 3764     GtkWidget   *tearoff_handle;
 3765 # endif
 3766     GtkWidget   *label;         // Used by "set wak=" code.
 3767 #endif
 3768 #ifdef FEAT_GUI_MOTIF
 3769     int     sensitive;      // turn button on/off
 3770     char    **xpm;          // pixmap data
 3771     char    *xpm_fname;     // file with pixmap data
 3772 #endif
 3773 #ifdef FEAT_GUI_ATHENA
 3774     Pixmap  image;          // Toolbar image
 3775 #endif
 3776 #ifdef FEAT_BEVAL_TIP
 3777     BalloonEval *tip;           // tooltip for this menu item
 3778 #endif
 3779 #ifdef FEAT_GUI_MSWIN
 3780     UINT    id;         // Id of menu item
 3781     HMENU   submenu_id;     // If this is submenu, add children here
 3782     HWND    tearoff_handle;     // hWnd of tearoff if created
 3783 #endif
 3784 #if FEAT_GUI_HAIKU
 3785     BMenuItem  *id;         // Id of menu item
 3786     BMenu  *submenu_id;         // If this is submenu, add children here
 3787 # ifdef FEAT_TOOLBAR
 3788     BPictureButton *button;
 3789 # endif
 3790 #endif
 3791 #ifdef FEAT_GUI_MAC
 3792 //  MenuHandle  id;
 3793 //  short   index;          // the item index within the father menu
 3794     short   menu_id;        // the menu id to which this item belongs
 3795     short   submenu_id;     // the menu id of the children (could be
 3796                     // get through some tricks)
 3797     MenuHandle  menu_handle;
 3798     MenuHandle  submenu_handle;
 3799 #endif
 3800 #ifdef FEAT_GUI_PHOTON
 3801     PtWidget_t  *id;
 3802     PtWidget_t  *submenu_id;
 3803 #endif
 3804 };
 3805 #else
 3806 // For generating prototypes when FEAT_MENU isn't defined.
 3807 typedef int vimmenu_T;
 3808 
 3809 #endif // FEAT_MENU
 3810 
 3811 /*
 3812  * Struct to save values in before executing autocommands for a buffer that is
 3813  * not the current buffer.
 3814  */
 3815 typedef struct
 3816 {
 3817     buf_T   *save_curbuf;   // saved curbuf
 3818     int     use_aucmd_win;  // using aucmd_win
 3819     win_T   *save_curwin;   // saved curwin
 3820     win_T   *new_curwin;    // new curwin
 3821     win_T   *save_prevwin;  // saved prevwin
 3822     bufref_T    new_curbuf; // new curbuf
 3823     char_u  *globaldir; // saved value of globaldir
 3824 } aco_save_T;
 3825 
 3826 /*
 3827  * Generic option table item, only used for printer at the moment.
 3828  */
 3829 typedef struct
 3830 {
 3831     const char  *name;
 3832     int     hasnum;
 3833     long    number;
 3834     char_u  *string;    // points into option string
 3835     int     strlen;
 3836     int     present;
 3837 } option_table_T;
 3838 
 3839 /*
 3840  * Structure to hold printing color and font attributes.
 3841  */
 3842 typedef struct
 3843 {
 3844     long_u  fg_color;
 3845     long_u  bg_color;
 3846     int     bold;
 3847     int     italic;
 3848     int     underline;
 3849     int     undercurl;
 3850 } prt_text_attr_T;
 3851 
 3852 /*
 3853  * Structure passed back to the generic printer code.
 3854  */
 3855 typedef struct
 3856 {
 3857     int     n_collated_copies;
 3858     int     n_uncollated_copies;
 3859     int     duplex;
 3860     int     chars_per_line;
 3861     int     lines_per_page;
 3862     int     has_color;
 3863     prt_text_attr_T number;
 3864 #ifdef FEAT_SYN_HL
 3865     int     modec;
 3866     int     do_syntax;
 3867 #endif
 3868     int     user_abort;
 3869     char_u  *jobname;
 3870 #ifdef FEAT_POSTSCRIPT
 3871     char_u  *outfile;
 3872     char_u  *arguments;
 3873 #endif
 3874 } prt_settings_T;
 3875 
 3876 #define PRINT_NUMBER_WIDTH 8
 3877 
 3878 /*
 3879  * Used for popup menu items.
 3880  */
 3881 typedef struct
 3882 {
 3883     char_u  *pum_text;  // main menu text
 3884     char_u  *pum_kind;  // extra kind text (may be truncated)
 3885     char_u  *pum_extra; // extra menu text (may be truncated)
 3886     char_u  *pum_info;  // extra info
 3887 } pumitem_T;
 3888 
 3889 /*
 3890  * Structure used for get_tagfname().
 3891  */
 3892 typedef struct
 3893 {
 3894     char_u  *tn_tags;   // value of 'tags' when starting
 3895     char_u  *tn_np;     // current position in tn_tags
 3896     int     tn_did_filefind_init;
 3897     int     tn_hf_idx;
 3898     void    *tn_search_ctx;
 3899 } tagname_T;
 3900 
 3901 typedef struct {
 3902   UINT32_T total[2];
 3903   UINT32_T state[8];
 3904   char_u   buffer[64];
 3905 } context_sha256_T;
 3906 
 3907 /*
 3908  * types for expressions.
 3909  */
 3910 typedef enum
 3911 {
 3912     EXPR_UNKNOWN = 0,
 3913     EXPR_EQUAL,     // ==
 3914     EXPR_NEQUAL,    // !=
 3915     EXPR_GREATER,   // >
 3916     EXPR_GEQUAL,    // >=
 3917     EXPR_SMALLER,   // <
 3918     EXPR_SEQUAL,    // <=
 3919     EXPR_MATCH,     // =~
 3920     EXPR_NOMATCH,   // !~
 3921     EXPR_IS,        // is
 3922     EXPR_ISNOT,     // isnot
 3923     // used with ISN_OPNR
 3924     EXPR_ADD,       // +
 3925     EXPR_SUB,       // -
 3926     EXPR_MULT,      // *
 3927     EXPR_DIV,       // /
 3928     EXPR_REM,       // %
 3929 } exptype_T;
 3930 
 3931 /*
 3932  * Structure used for reading in json_decode().
 3933  */
 3934 struct js_reader
 3935 {
 3936     char_u  *js_buf;    // text to be decoded
 3937     char_u  *js_end;    // NUL in js_buf
 3938     int     js_used;    // bytes used from js_buf
 3939     int     (*js_fill)(struct js_reader *);
 3940                 // function to fill the buffer or NULL;
 3941                 // return TRUE when the buffer was filled
 3942     void    *js_cookie; // can be used by js_fill
 3943     int     js_cookie_arg;  // can be used by js_fill
 3944 };
 3945 typedef struct js_reader js_read_T;
 3946 
 3947 // Maximum number of commands from + or -c arguments.
 3948 #define MAX_ARG_CMDS 10
 3949 
 3950 // values for "window_layout"
 3951 #define WIN_HOR     1       // "-o" horizontally split windows
 3952 #define WIN_VER     2       // "-O" vertically split windows
 3953 #define WIN_TABS    3       // "-p" windows on tab pages
 3954 
 3955 // Struct for various parameters passed between main() and other functions.
 3956 typedef struct
 3957 {
 3958     int     argc;
 3959     char    **argv;
 3960 
 3961     char_u  *fname;         // first file to edit
 3962 
 3963     int     evim_mode;      // started as "evim"
 3964     char_u  *use_vimrc;     // vimrc from -u argument
 3965     int     clean;          // --clean argument
 3966 
 3967     int     n_commands;          // no. of commands from + or -c
 3968     char_u  *commands[MAX_ARG_CMDS];     // commands from + or -c arg.
 3969     char_u  cmds_tofree[MAX_ARG_CMDS];   // commands that need free()
 3970     int     n_pre_commands;          // no. of commands from --cmd
 3971     char_u  *pre_commands[MAX_ARG_CMDS]; // commands from --cmd argument
 3972 
 3973     int     edit_type;      // type of editing to do
 3974     char_u  *tagname;       // tag from -t argument
 3975 #ifdef FEAT_QUICKFIX
 3976     char_u  *use_ef;        // 'errorfile' from -q argument
 3977 #endif
 3978 
 3979     int     want_full_screen;
 3980     int     not_a_term;     // no warning for missing term?
 3981     int     tty_fail;       // exit if not a tty
 3982     char_u  *term;          // specified terminal name
 3983 #ifdef FEAT_CRYPT
 3984     int     ask_for_key;        // -x argument
 3985 #endif
 3986     int     no_swap_file;       // "-n" argument used
 3987 #ifdef FEAT_EVAL
 3988     int     use_debug_break_level;
 3989 #endif
 3990     int     window_count;       // number of windows to use
 3991     int     window_layout;      // 0, WIN_HOR, WIN_VER or WIN_TABS
 3992 
 3993 #ifdef FEAT_CLIENTSERVER
 3994     int     serverArg;      // TRUE when argument for a server
 3995     char_u  *serverName_arg;    // cmdline arg for server name
 3996     char_u  *serverStr;     // remote server command
 3997     char_u  *serverStrEnc;      // encoding of serverStr
 3998     char_u  *servername;        // allocated name for our server
 3999 #endif
 4000 #if !defined(UNIX)
 4001 # define EXPAND_FILENAMES
 4002     int     literal;        // don't expand file names
 4003 #endif
 4004 #ifdef MSWIN
 4005     int     full_path;      // file name argument was full path
 4006 #endif
 4007 #ifdef FEAT_DIFF
 4008     int     diff_mode;      // start with 'diff' set
 4009 #endif
 4010 } mparm_T;
 4011 
 4012 /*
 4013  * Structure returned by get_lval() and used by set_var_lval().
 4014  * For a plain name:
 4015  *  "name"      points to the variable name.
 4016  *  "exp_name"  is NULL.
 4017  *  "tv"        is NULL
 4018  * For a magic braces name:
 4019  *  "name"      points to the expanded variable name.
 4020  *  "exp_name"  is non-NULL, to be freed later.
 4021  *  "tv"        is NULL
 4022  * For an index in a list:
 4023  *  "name"      points to the (expanded) variable name.
 4024  *  "exp_name"  NULL or non-NULL, to be freed later.
 4025  *  "tv"        points to the (first) list item value
 4026  *  "li"        points to the (first) list item
 4027  *  "range", "n1", "n2" and "empty2" indicate what items are used.
 4028  * For an existing Dict item:
 4029  *  "name"      points to the (expanded) variable name.
 4030  *  "exp_name"  NULL or non-NULL, to be freed later.
 4031  *  "tv"        points to the dict item value
 4032  *  "newkey"    is NULL
 4033  * For a non-existing Dict item:
 4034  *  "name"      points to the (expanded) variable name.
 4035  *  "exp_name"  NULL or non-NULL, to be freed later.
 4036  *  "tv"        points to the Dictionary typval_T
 4037  *  "newkey"    is the key for the new item.
 4038  */
 4039 typedef struct lval_S
 4040 {
 4041     char_u  *ll_name;   // start of variable name (can be NULL)
 4042     char_u  *ll_name_end;   // end of variable name (can be NULL)
 4043     type_T  *ll_type;   // type of variable (can be NULL)
 4044     char_u  *ll_exp_name;   // NULL or expanded name in allocated memory.
 4045     typval_T    *ll_tv;     // Typeval of item being used.  If "newkey"
 4046                 // isn't NULL it's the Dict to which to add
 4047                 // the item.
 4048     listitem_T  *ll_li;     // The list item or NULL.
 4049     list_T  *ll_list;   // The list or NULL.
 4050     int     ll_range;   // TRUE when a [i:j] range was used
 4051     int     ll_empty2;  // Second index is empty: [i:]
 4052     long    ll_n1;      // First index for list
 4053     long    ll_n2;      // Second index for list range
 4054     dict_T  *ll_dict;   // The Dictionary or NULL
 4055     dictitem_T  *ll_di;     // The dictitem or NULL
 4056     char_u  *ll_newkey; // New key for Dict in alloc. mem or NULL.
 4057     blob_T  *ll_blob;   // The Blob or NULL
 4058 } lval_T;
 4059 
 4060 // Structure used to save the current state.  Used when executing Normal mode
 4061 // commands while in any other mode.
 4062 typedef struct {
 4063     int     save_msg_scroll;
 4064     int     save_restart_edit;
 4065     int     save_msg_didout;
 4066     int     save_State;
 4067     int     save_insertmode;
 4068     int     save_finish_op;
 4069     int     save_opcount;
 4070     int     save_reg_executing;
 4071     tasave_T    tabuf;
 4072 } save_state_T;
 4073 
 4074 typedef struct {
 4075     varnumber_T vv_prevcount;
 4076     varnumber_T vv_count;
 4077     varnumber_T vv_count1;
 4078 } vimvars_save_T;
 4079 
 4080 // Scope for changing directory
 4081 typedef enum {
 4082     CDSCOPE_GLOBAL, // :cd
 4083     CDSCOPE_TABPAGE,    // :tcd
 4084     CDSCOPE_WINDOW  // :lcd
 4085 } cdscope_T;
 4086 
 4087 // Variable flavor
 4088 typedef enum
 4089 {
 4090     VAR_FLAVOUR_DEFAULT,    // doesn't start with uppercase
 4091     VAR_FLAVOUR_SESSION,    // starts with uppercase, some lower
 4092     VAR_FLAVOUR_VIMINFO     // all uppercase
 4093 } var_flavour_T;
 4094 
 4095 // argument for mouse_find_win()
 4096 typedef enum {
 4097     IGNORE_POPUP,   // only check non-popup windows
 4098     FIND_POPUP,     // also find popup windows
 4099     FAIL_POPUP      // return NULL if mouse on popup window
 4100 } mouse_find_T;
 4101 
 4102 // Symbolic names for some registers.
 4103 #define DELETION_REGISTER   36
 4104 #ifdef FEAT_CLIPBOARD
 4105 # define STAR_REGISTER      37
 4106 #  ifdef FEAT_X11
 4107 #   define PLUS_REGISTER    38
 4108 #  else
 4109 #   define PLUS_REGISTER    STAR_REGISTER       // there is only one
 4110 #  endif
 4111 #endif
 4112 #ifdef FEAT_DND
 4113 # define TILDE_REGISTER     (PLUS_REGISTER + 1)
 4114 #endif
 4115 
 4116 #ifdef FEAT_CLIPBOARD
 4117 # ifdef FEAT_DND
 4118 #  define NUM_REGISTERS     (TILDE_REGISTER + 1)
 4119 # else
 4120 #  define NUM_REGISTERS     (PLUS_REGISTER + 1)
 4121 # endif
 4122 #else
 4123 # define NUM_REGISTERS      37
 4124 #endif
 4125 
 4126 // structure used by block_prep, op_delete and op_yank for blockwise operators
 4127 // also op_change, op_shift, op_insert, op_replace - AKelly
 4128 struct block_def
 4129 {
 4130     int     startspaces;    // 'extra' cols before first char
 4131     int     endspaces;  // 'extra' cols after last char
 4132     int     textlen;    // chars in block
 4133     char_u  *textstart; // pointer to 1st char (partially) in block
 4134     colnr_T textcol;    // index of chars (partially) in block
 4135     colnr_T start_vcol; // start col of 1st char wholly inside block
 4136     colnr_T end_vcol;   // start col of 1st char wholly after block
 4137     int     is_short;   // TRUE if line is too short to fit in block
 4138     int     is_MAX;     // TRUE if curswant==MAXCOL when starting
 4139     int     is_oneChar; // TRUE if block within one character
 4140     int     pre_whitesp;    // screen cols of ws before block
 4141     int     pre_whitesp_c;  // chars of ws before block
 4142     colnr_T end_char_vcols; // number of vcols of post-block char
 4143     colnr_T start_char_vcols; // number of vcols of pre-block char
 4144 };
 4145 
 4146 // Each yank register has an array of pointers to lines.
 4147 typedef struct
 4148 {
 4149     char_u  **y_array;  // pointer to array of line pointers
 4150     linenr_T    y_size;     // number of lines in y_array
 4151     char_u  y_type;     // MLINE, MCHAR or MBLOCK
 4152     colnr_T y_width;    // only set if y_type == MBLOCK
 4153 #ifdef FEAT_VIMINFO
 4154     time_t  y_time_set;
 4155 #endif
 4156 } yankreg_T;
 4157 
 4158 // The offset for a search command is store in a soff struct
 4159 // Note: only spats[0].off is really used
 4160 typedef struct soffset
 4161 {
 4162     int     dir;        // search direction, '/' or '?'
 4163     int     line;       // search has line offset
 4164     int     end;        // search set cursor at end
 4165     long    off;        // line or char offset
 4166 } soffset_T;
 4167 
 4168 // A search pattern and its attributes are stored in a spat struct
 4169 typedef struct spat
 4170 {
 4171     char_u      *pat;   // the pattern (in allocated memory) or NULL
 4172     int         magic;  // magicness of the pattern
 4173     int         no_scs; // no smartcase for this pattern
 4174     soffset_T       off;
 4175 } spat_T;
 4176 
 4177 /*
 4178  * Optional extra arguments for searchit().
 4179  */
 4180 typedef struct
 4181 {
 4182     linenr_T    sa_stop_lnum;   // stop after this line number when != 0
 4183 #ifdef FEAT_RELTIME
 4184     proftime_T  *sa_tm;     // timeout limit or NULL
 4185     int     sa_timed_out;   // set when timed out
 4186 #endif
 4187     int     sa_wrapped; // search wrapped around
 4188 } searchit_arg_T;
 4189 
 4190 
 4191 #define WRITEBUFSIZE    8192    // size of normal write buffer
 4192 
 4193 #define FIO_LATIN1  0x01    // convert Latin1
 4194 #define FIO_UTF8    0x02    // convert UTF-8
 4195 #define FIO_UCS2    0x04    // convert UCS-2
 4196 #define FIO_UCS4    0x08    // convert UCS-4
 4197 #define FIO_UTF16   0x10    // convert UTF-16
 4198 #ifdef MSWIN
 4199 # define FIO_CODEPAGE   0x20    // convert MS-Windows codepage
 4200 # define FIO_PUT_CP(x) (((x) & 0xffff) << 16)   // put codepage in top word
 4201 # define FIO_GET_CP(x)  (((x)>>16) & 0xffff)    // get codepage from top word
 4202 #endif
 4203 #ifdef MACOS_CONVERT
 4204 # define FIO_MACROMAN   0x20    // convert MacRoman
 4205 #endif
 4206 #define FIO_ENDIAN_L    0x80    // little endian
 4207 #define FIO_ENCRYPTED   0x1000  // encrypt written bytes
 4208 #define FIO_NOCONVERT   0x2000  // skip encoding conversion
 4209 #define FIO_UCSBOM  0x4000  // check for BOM at start of file
 4210 #define FIO_ALL -1  // allow all formats
 4211 
 4212 // When converting, a read() or write() may leave some bytes to be converted
 4213 // for the next call.  The value is guessed...
 4214 #define CONV_RESTLEN 30
 4215 
 4216 // We have to guess how much a sequence of bytes may expand when converting
 4217 // with iconv() to be able to allocate a buffer.
 4218 #define ICONV_MULT 8