On Sun, Mar 11, 2018 at 01:09:48PM +0100, j. van den hoff wrote:
> On Sun, 11 Mar 2018 01:41:54 +0100, Thomas Dickey <dic...@his.com> wrote:
> 
> >On Sat, Mar 10, 2018 at 11:09:29PM +0100, j. van den hoff wrote:
> >>On Fri, 09 Mar 2018 22:24:16 +0100, Thomas Dickey <dic...@his.com>
> >>wrote:
> >>
> >>>On Fri, Mar 09, 2018 at 05:37:24PM +0100, j. van den hoff wrote:
> >>>>I have a "tags" file of function definitions in the `R' language
> >>>>(https://www.r-project.org). function names can contain periods, so I
> >>>>have
> >>>>lines such as
> >>>>
> >>>>disp.array      fzrutils/R/disp.array.R /^disp.array <- function ($/;"
> >>>>f
> >>>>
> >>>>in the "tags" file. my `.vilerc' contains
> >>>>
> >>>>set tags {path_to_the_tags_file}
> >>>>set tagrelative
> >>>>
> >>>>`vi -t disp.array' does not work as expected but reacts the same way
> >>it
> >>>>does
> >>>>when a non-existent tag is specified (just reporting the read-in
> >>config
> >>>>files: "Reading ~/vile.rc" etc.). tags not containing a `.'  in the
> >>>>function
> >>>>name work just fine. `vim -t disp.array' does the expected even if the
> >>>>`.'
> >>>>is present in the name.
> >>>>
> >>>>Am I missing something or is this a bug?
> >>>
> >>>When doing ^]], vile's using a function checks only the character
> >>class,
> >>>and stops when a character isn't an "identifier":
> >>>
> >>>int
> >>>screen_to_ident(char *buf, size_t bufn)
> >>>{
> >>>    int rc = FALSE;
> >>>    CHARTYPE mask = vl_ident;
> >>>    int whole_line = adjust_chartype(&mask);
> >>>
> >>>    TRACE((T_CALLED "screen_to_ident\n"));
> >>>    rc = read_by_regex(buf, bufn, b_val_rexp(curbp,
> >>VAL_IDENTIFIER_EXPR),
> >>>whole_line);
> >>>    if (rc == FALSE)
> >>>   rc = read_by_ctype(buf, bufn, mask, whole_line);
> >>>    returnCode(rc);
> >>>}
> >>>
> >>>:show-printable shows that it's not (by default) an "id" character:
> >>>
> >>>45 -        -   -   -   -  -   prn pun -   -  path -   arg -  nsp -   tmp 
> >>>sh
> >>>46 .        -   -   -   -  -   prn pun -   -  path -   arg -  nsp -   tmp 
> >>>sh
> >>>47 /        -   -   -   -  -   prn pun -   -  path -   -   -  nsp -   tmp 
> >>>sh
> >>>48 0        -   -   num -  -   prn -   -   id path -   arg -  nsp qid tmp 
> >>>sh
> >>>49 1        -   -   num -  -   prn -   -   id path -   arg -  nsp qid tmp 
> >>>sh
> >>>
> >>>You could change that with
> >>>
> >>>   set-char-class id=[.]
> >>>45 -        -   -   -   -  -   prn pun -   -  path -   arg -  nsp -   tmp 
> >>>sh
> >>>46 .        -   -   -   -  -   prn pun -   id path -   arg -  nsp -   tmp 
> >>>sh
> >>>47 /        -   -   -   -  -   prn pun -   -  path -   -   -  nsp -   tmp 
> >>>sh
> >>>48 0        -   -   num -  -   prn -   -   id path -   arg -  nsp qid tmp 
> >>>sh
> >>>49 1        -   -   num -  -   prn -   -   id path -   arg -  nsp qid tmp 
> >>>sh
> >>
> >>thank you -- didn't know of the `show-printable' command... anyhow, your
> >>suggested solution does not work for me: I put the
> >>
> >>   set-char-class id=[.]
> >>
> >>into my .vilerc but nothing has changed. `vi -t disp.array' (in my
> >>example)
> >>does still not work.
> >
> >ah... I was answering the scenario that I used for a quick test.
> >
> >The short answer is that there's more than one case used for tags.
> >
> >From the command-line, the -t option adds the value as part of a startup
> >script:
> >
> >                 add_cmdarg(opts_bp, "tag %s\n", GetArgVal(param));
> >so you should get the same result using
> >     :tag disp.array
> 
> ok... but that's exactly what is _not_ happening here... from within the
> editor and when using `:tag disp.array' vile correctly recognizes the tag
> just fine and opens the corresponding file. only when doing `vile -t
> disp.array' (apology for stating previously that I issued `vi -t disp.array'
> -- I admit that I've aliased `vile' to `vi' ;)) vile chokes...
> 
> >
> >Reading from the screen is different.
> 
> you mean when using `^]' or also with `:tag'?

The former: vile has "always" handled `^]' by calling a function which
reads data directly from the screen rather than on the colon-line with `:tag'

> 
> >
> >From a command-line (or script), the code's not limited by the character
> >class exactly - it's ended with whitespace, newline, etc.  It accepts
> >a tab for name-completion of course.
> 
> for me, `:tag disp.array' recognizes the tag but TAB completion on this name
> does not work (due to the `.' it seems). TAB completion only works for names
> w/o the `.'.
> 
> >
> >But I'm puzzled because a few cases that I set up for answering the mail
> >worked for me, e.g.,
> >
> >PACKAGES.arch        package/debian/rules    /^PACKAGES.arch  = vile 
> >vile-filters
> >xvile$/;"    m
> >
> >and now, using your example (and a suitable file for the target of
> >course):
> >
> >disp.array   fzrutils/R/disp.array.R /^disp.array <- function ($/;"  f
> 
> you mean, that example works for you, too?

yes - I made a file with this content -- indented here for clarity
(the extra lines were to verify that it didn't simply read the file):

        #
        #
        disp.array <- function (
        )

> 
> >
> >Perhaps there's something related to your locale settings.  I'm using
> >en_US.UTF-8, and recall that "." is treated differently in the European
> >locales.  But a quick test with de_DE.UTF-8 gives me consistent results.
> 
> in fact, I usually (and right now) use en_US.UTF-8...

There might be something in your ".vilerc" which I'd not considered.

> >>what I _have_ learned in the meantime: when being already in the editor
> >>`:ta
> >>disp.array' works just fine (w/ or w/o the `set-char-class id=[.]' in
> >>`.vilerc'). this is good and suffices as a working solution but I would
> >>of
> >>course be grateful for any further hint how to make `vi -t' work for
> >>`foo.bar' type names.
> >>
> >>another observation: when using `:ta {tagname}' from within `vile', TAB
> >>completion of tagname works, but only for tagnames _not_ containing a
> >>`.'
> >>(again, independent of whether `set-char-class id=[.]' has been issued
> >>or
> >>not).
> >>
> >>>
> >>>>seen with vile version 9.8o for darwin14.3.0.
> >>>>
> >>>>thank you
> >>>>
> >>>>joerg
> >>>>
> >>>>PS: I also presume, there is a small `ctags' bug here. the search
> >>>>pattern
> >>>>probably should backslash-protect the period in order to actually only
> >>>>match
> >>>>`disp.array' verbatim rather than
> >>>>disp{any-single-character}array, no? otherwise one might jump to the
> >>>>wrong
> >>>>tag/file/position.
> >>>
> >>>hmm - I think it's correct, since "magic" is normally set.
> >>
> >>ah., I see. maybe it's time to spend some time with the (really good)
> >>vile
> >>help file again: I was not aware of the 'magic' feature of vi and vile
> >>at
> >>all. sorry for the noise...
> >
> >no problem - actually reading the mail, I made a note to verify whether
> >vile's doing the right thing
> 
> I've played around with this in the meantime and, yes, it seems `vile' does
> what you explained (when using `:tag' I can jump to `foo.bar' and adding a
> further line to the tags file with name `fooabar' before `foo.bar' does not
> confuse the lookup of `foo.bar').
> 
> so to summarize what I still see here:
> 
> * using vile version 9.8s for darwin15.6.0
> 
> * "en_US.UTF-8" locale
> 
> * tags file contains entries of the form `disp.array
> fzrutils/R/disp.array.R /^disp.array <- function ($/;"  f'
> 
> * `vile -t disp.array' does not work from the command line (other tags
> (incidentally there is a `disp' tag as well, e.g.) do work)
>    - `vim -t disp.array', OTOH, works
> 
> * from within vile:
> 
>    - `:tag disp.array' does work
> 
>    - TAB completion on such tag names do _not_ work (TAB completion on tag
> names w/o `.' works fine)
> 
> * the `.' is not really that special: the problem is the same when replacing
> the dot by several other punctuation characters (although those will hardly
> ever be really part of an identifier, I presume...)
> 
> if there is anything else I can try to make it (vi -t foo.bar) work please
> let me know. although I am of course afraid that my locale setup is somehow
> the culprit. but I don't see anything obviously pathological about it ...

If you're able to compile vile, then its debug-trace can be helpful.
In a quick check just now, I did that, e.g.,

        ./configure --with-trace --with-builtin-filters && make

and made an empty ".vilerc" (to keep the trace small), then

        ./vile -t disp.array

went to the file as expected.  That created a trace file "Trace.out",
which I'll attach, as an example.

-- 
Thomas E. Dickey <dic...@invisible-island.net>
https://invisible-island.net
ftp://ftp.invisible-island.net
old_locale 'en_US.UTF-8'
called {{ vl_get_encoding(en_US.UTF-8)
| return }} UTF-8
Checking for UTF-8 suffix of 'en_US.UTF-8'
called {{ vl_narrowed(en_US.UTF-8)
| regparser {/\.\(UTF\|utf\)[-]\?8$//}
| ...regparser {\.\(UTF\|utf\)[-]\?8$}
| regparser {//}
| ...regparser {}
| regcomp("\\.\\(UTF\\|utf\\)[-]\\?8$", magic)
| after regmassage: '\\.(UTF|utf)[-]?8$'
| vl_narrowed match ".UTF-8", replace with ""
| return }} en_US
called {{ vl_init_8bit(en_US.UTF-8, en_US)
| setup mixed-locale(en_US.UTF-8, en_US)
| called {{ vl_get_encoding(en_US.UTF-8)
| | return }} UTF-8
| called {{ vl_get_encoding(en_US)
| | return }} ISO-8859-1
| ...locale encodings(UTF-8, ISO-8859-1)
| try_encoding(from=ISO-8859-1, to=UTF-8) OK
| fixed-up 0 of 256 8bit/utf8 mappings
| assume 256 Latin1 codes
| return }} 
setlocale(en_US) -> 'en_US'
called {{ vl_get_encoding(en_US)
| return }} ISO-8859-1
called {{ vl_ctype_init() lo=0, hi=0
| wide_locale:en_US.UTF-8
| narrow_locale:en_US
| current_locale:en_US
| Forcing printable for [128..min(-1,255)]
| return }} 
called {{ global_val_init()
| regcomp("\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)", 
magic)
| after regmassage: '(\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)'
| regcomp("^\\s*\\(\\(\\s*[#*>]\\)\\|\\(///*\\)\\)\\+", magic)
| after regmassage: '^\\s*((\\s*[#*\\>])|(///*))+'
| regcomp("^\\s*/\\?\\(\\s*[#*>/]\\)\\+/\\?\\s*$", magic)
| after regmassage: '^\\s*/?(\\s*[#*\\>/])+/?\\s*$'
| regcomp("/\\*", magic)
| after regmassage: '/\\*'
| regcomp("^\\s*#\\s*elif\\>", magic)
| after regmassage: '^\\s*#\\s*elif>'
| regcomp("^\\s*#\\s*else\\>", magic)
| after regmassage: '^\\s*#\\s*else>'
| regcomp("\\*/", magic)
| after regmassage: '\\*/'
| regcomp("^\\s*#\\s*endif\\>", magic)
| after regmassage: '^\\s*#\\s*endif>'
| regcomp("^\\s*#\\s*if", magic)
| after regmassage: '^\\s*#\\s*if'
| regcomp("\\w\\+", magic)
| after regmassage: '\\w+'
| regcomp("\\(\\.orig\\|~\\)$", magic)
| after regmassage: '(\\.orig|~)$'
| 
regcomp("^\\.[ILPQ]P\\>\\|^\\.P\\>\\|^\\.LI\\>\\|^\\.[plinb]p\\>\\|^\\.\\?\\s*$",
 magic)
| after regmassage: '^\\.[ILPQ]P>|^\\.P>|^\\.LI>|^\\.[plinb]p>|^\\.?\\s*$'
| regcomp("[[:file:]]\\+", magic)
| after regmassage: '[[:file:]]+'
| 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| after regmassage: '((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| regcomp("^[{^L]\\|^\\.[NS]H\\>\\|^\\.HU\\?\\>\\|^\\.[us]h\\>\\|^+c\\>", magic)
| after regmassage: '^[\\{^L]|^\\.[NS]H>|^\\.HU?>|^\\.[us]h>|^\\+c>'
| regcomp("[.!?][])"']* \\?$\\|[.!?][])"']*  
\\|^\\.[ILPQ]P\\>\\|^\\.P\\>\\|^\\.LI\\>\\|^\\.[plinb]p\\>\\|^\\.\\?\\s*$", 
magic)
| after regmassage: '[.!\\?][]\\)"']* ?$|[.!\\?][]\\)"']*  
|^\\.[ILPQ]P>|^\\.P>|^\\.LI>|^\\.[plinb]p>|^\\.?\\s*$'
| set_state_variable(empty-lines,1)
| ...set_state_variable ->1
| set_state_variable(filename-expr,[[:file:]])
| regcomp("[[:file:]]", magic)
| after regmassage: '[[:file:]]'
| ...set_state_variable ->1
| set_state_variable(helpfile,vile.hlp)
| ...set_state_variable ->1
| 
set_state_variable(latin1-expr,^\(aa\|af\|br\|de\|en\|es\|fr\|fi\|ga\|gb\|gl\|gv\|id\|it\|kl\|ms\|nl\|nn\|om\|pt\|so\|sv\|tl\)_[A-Za-z]\+$)
| 
regcomp("^\\(aa\\|af\\|br\\|de\\|en\\|es\\|fr\\|fi\\|ga\\|gb\\|gl\\|gv\\|id\\|it\\|kl\\|ms\\|nl\\|nn\\|om\\|pt\\|so\\|sv\\|tl\\)_[A-Za-z]\\+$",
 magic)
| after regmassage: 
'^(aa|af|br|de|en|es|fr|fi|ga|gb|gl|gv|id|it|kl|ms|nl|nn|om|pt|so|sv|tl)_[A-Za-z]+$'
| called {{ vl_init_8bit(en_US.UTF-8, en_US)
| | setup mixed-locale(en_US.UTF-8, en_US)
| | called {{ vl_get_encoding(en_US.UTF-8)
| | | return }} UTF-8
| | called {{ vl_get_encoding(en_US)
| | | return }} ISO-8859-1
| | ...locale encodings(UTF-8, ISO-8859-1)
| | try_encoding(from=ISO-8859-1, to=UTF-8) OK
| | fixed-up 0 of 256 8bit/utf8 mappings
| | assume 256 Latin1 codes
| | return }} 
| ...set_state_variable ->1
| set_state_variable(libdir-path,/usr/local/lib/vile)
| ...set_state_variable ->1
| set_state_variable(modeline-format,%-%i%- %b %m:: :%f:is : :%=%F: : 
:%l:(:,:%c::) :%p::% :%C:char ::%S%-%-%|)
| ...set_state_variable ->1
| set_state_variable(position-format,Line %{$curline}d of %{$blines}d, Col 
%{$curcol}d of %{$lcols}d, Char %{$curchar}d of %{$bchars}d (%P%%) char is 
0x%{$char}x or 0%{$char}o)
| ...set_state_variable ->1
| set_state_variable(prompt,: )
| ...set_state_variable ->1
| set_state_variable(replace,)
| ...set_state_variable ->1
| set_state_variable(startup-file,.vilerc)
| ...set_state_variable ->1
| parse_pathlist(/usr/local/share/vile)
| ...parse_pathlist() ->'/usr/local/share/vile'
| find_in_path_list
        <null>
        /usr/local/share/vile
| parse_pathlist(<null>)
| ...parse_pathlist(<null>) ->''
|       -> 0
| file_stat(/usr/local/share/vile) = -1
| parse_pathlist()
| ...parse_pathlist(<null>) ->'/usr/local/share/vile'
| ...append_to_path_list
        <null>
| parse_pathlist(/usr/local/share/vile)
| ...parse_pathlist() ->'/usr/local/share/vile'
| find_in_path_list
        <null>
        /usr/local/share/vile
| parse_pathlist(<null>)
| ...parse_pathlist(<null>) ->''
|       -> 0
| file_stat(/usr/local/share/vile) = -1 cached
| parse_pathlist()
| ...parse_pathlist(<null>) ->'/usr/local/share/vile'
| ...append_to_path_list
        <null>
| called {{ alloc_mode(c,1)
| | extend_VAL_array (nil) item 0 of 1
| | extend_VAL_array (nil) item 0 of 1
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | called {{ compute_majormodes_order(1)
| | | order final: c
| | | checked 1 majormodes
| | | return }} 
| | return }} 1
| called {{ alloc_mode(vile,1)
| | extend_VAL_array 0x1de0ac0 item 1 of 2
| | extend_VAL_array 0x1de0af0 item 1 of 2
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | regcomp("", magic)
| | after regmassage: ''
| | called {{ compute_majormodes_order(2)
| | | order final: c vile
| | | checked 2 majormodes
| | | return }} 
| | return }} 1
| called {{ set_submode_val(c, 52, 8)
| | return }} 
| called {{ set_submode_val(c, 58, 8)
| | return }} 
| called {{ set_submode_val(c, 11, 1)
| | return }} 
| called {{ set_submode_txt(c, 12, :#{}()[])
| | return }} 
| called {{ set_majormode_rexp(c, 6, \.\(\([CchisS]\)\|CC\|cc\|cpp\|cxx\|hxx\)$)
| | regcomp("\\.\\(\\([CchisS]\\)\\|CC\\|cc\\|cpp\\|cxx\\|hxx\\)$", magic)
| | after regmassage: '\\.(([CchisS])|CC|cc|cpp|cxx|hxx)$'
| | return }} 
| return }} 
called {{ winit(0)
| winit creating bminip & wminip
| called {{ bfind(, 1)
| | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | return }} 0x1de8780
| called {{ bfind(      UTF-8, 1)
| | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | return }} 0x1de8ff0
| return }} 
current_directory(/usr/build/vile/vile)
called {{ canonpath '/usr/build/vile/vile/./vile'
| return }} /usr/build/vile/vile/vile
called {{ canonpath '/usr/build/vile/vile/'
| return }} /usr/build/vile/vile
called {{ tcap_open()
| vl_open_mbterm
| ...using vl_mb_getch(locale)
| ...using vl_mb_putch
| called {{ set_colors(8)
| | called {{ set_fsm_choices(fcolor)
| | |    [0] black = 0 (0)
| | |    [1] blue = 4 (0x4)
| | |    [2] cyan = 6 (0x6)
| | |    [3] default = -1 (0xffffffff)
| | |    [4] green = 2 (0x2)
| | |    [5] magenta = 5 (0x5)
| | |    [6] red = 1 (0x1)
| | |    [7] white = 7 (0x7)
| | |    [8] yellow = 3 (0x3)
| | | return }} 
| | called {{ set_fsm_choices(bcolor)
| | |    [0] black = 0 (0)
| | |    [1] blue = 4 (0x4)
| | |    [2] cyan = 6 (0x6)
| | |    [3] default = -1 (0xffffffff)
| | |    [4] green = 2 (0x2)
| | |    [5] magenta = 5 (0x5)
| | |    [6] red = 1 (0x1)
| | |    [7] white = 7 (0x7)
| | |    [8] yellow = 3 (0x3)
| | | return }} 
| | called {{ set_fsm_choices(ccolor)
| | |    [0] black = 0 (0)
| | |    [1] blue = 4 (0x4)
| | |    [2] cyan = 6 (0x6)
| | |    [3] default = -1 (0xffffffff)
| | |    [4] green = 2 (0x2)
| | |    [5] magenta = 5 (0x5)
| | |    [6] red = 1 (0x1)
| | |    [7] white = 7 (0x7)
| | |    [8] yellow = 3 (0x3)
| | | return }} 
| | called {{ set_fsm_choices(visual-matches)
| | |    [0] black = 2048 (0x800)
| | |    [1] blue = 18432 (0x4800)
| | |    [2] bold = 128 (0x80)
| | |    [3] color = 61440 (0xf000)
| | |    [4] cyan = 26624 (0x6800)
| | |    [5] green = 10240 (0x2800)
| | |    [6] italic = 64 (0x40)
| | |    [7] magenta = 22528 (0x5800)
| | |    [8] none = 0 (0)
| | |    [9] red = 6144 (0x1800)
| | |    [10] reverse = 16 (0x10)
| | |    [11] underline = 32 (0x20)
| | |    [12] white = 63488 (0xf800)
| | |    [13] yellow = 47104 (0xb800)
| | | return }} 
| | called {{ set_fsm_choices(mini-hilite)
| | |    [0] black = 2048 (0x800)
| | |    [1] blue = 18432 (0x4800)
| | |    [2] bold = 128 (0x80)
| | |    [3] color = 61440 (0xf000)
| | |    [4] cyan = 26624 (0x6800)
| | |    [5] green = 10240 (0x2800)
| | |    [6] italic = 64 (0x40)
| | |    [7] magenta = 22528 (0x5800)
| | |    [8] none = 0 (0)
| | |    [9] red = 6144 (0x1800)
| | |    [10] reverse = 16 (0x10)
| | |    [11] underline = 32 (0x20)
| | |    [12] white = 63488 (0xf800)
| | |    [13] yellow = 47104 (0xb800)
| | | return }} 
| | return }} 1
| TGETSTR(il) = ^[[%p1%dL
| TGETSTR(dl) = ^[[%p1%dM
| TGETSTR(il1) = ^[[L
| TGETSTR(el) = ^[[K
| TGETSTR(clear) = ^[[H^[[J
| TGETSTR(cup) = ^[[%i%p1%d;%p2%dH
| TGETSTR(csr) = ^[[%i%p1%d;%p2%dr
| TGETSTR(dl1) = ^[[M
| TGETSTR(rmkx) = ^[[?1l^[>
| TGETSTR(smkx) = ^[[?1h^[=
| TGETSTR(rmso) = ^[[23m
| TGETSTR(ind) = ^J
| TGETSTR(smso) = ^[[3m
| TGETSTR(rev) = ^[[7m
| TGETSTR(ri) = ^[M
| TGETSTR(rmcup) = ^[[?1049l
| TGETSTR(smcup) = ^[[?1049h
| TGETSTR(setaf) = ^[[3%p1%dm
| TGETSTR(setab) = ^[[4%p1%dm
| TGETSTR(setf) = <null>
| TGETSTR(setb) = <null>
| TGETSTR(op) = ^[[39;49m
| TGETSTR(flash) = ^[g
| TGETSTR(sgr0) = ^[[m^O
| TGETSTR(bold) = ^[[1m
| TGETSTR(smul) = ^[[4m
| TGETSTR(rmul) = ^[[24m
| TGETSTR(sitm) = <null>
| TGETSTR(ritm) = <null>
| TGETSTR(cnorm) = ^[[34h^[[?25h
| TGETSTR(civis) = ^[[?25l
| set_ctrans(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
| ...ctrans, where not 1-1:
| TGETSTR(kf12) = ^[[24~
| TGETSTR(kf11) = ^[[23~
| TGETSTR(kf10) = ^[[21~
| TGETSTR(kf9) = ^[[20~
| TGETSTR(kf8) = ^[[19~
| TGETSTR(kf7) = ^[[18~
| TGETSTR(kf6) = ^[[17~
| TGETSTR(kf5) = ^[[15~
| TGETSTR(kf4) = ^[OS
| TGETSTR(kf3) = ^[OR
| TGETSTR(kf2) = ^[OQ
| TGETSTR(kf1) = ^[OP
| TGETSTR(kdch1) = ^[[3~
| TGETSTR(kich1) = ^[[2~
| TGETSTR(kpp) = ^[[5~
| TGETSTR(knp) = ^[[6~
| TGETSTR(kcbt) = ^[[Z
| TGETSTR(kend) = ^[[4~
| TGETSTR(khome) = ^[[1~
| TGETSTR(kcub1) = ^[OD
| TGETSTR(kcuf1) = ^[OC
| TGETSTR(kcud1) = ^[OB
| TGETSTR(kcuu1) = ^[OA
| TGETSTR(kf12) = ^[[24~
| TGETSTR(kf11) = ^[[23~
| TGETSTR(kf10) = ^[[21~
| TGETSTR(kf9) = ^[[20~
| TGETSTR(kf8) = ^[[19~
| TGETSTR(kf7) = ^[[18~
| TGETSTR(kf6) = ^[[17~
| TGETSTR(kf5) = ^[[15~
| TGETSTR(kf4) = ^[OS
| TGETSTR(kf3) = ^[OR
| TGETSTR(kf2) = ^[OQ
| TGETSTR(kf1) = ^[OP
| TGETSTR(kdch1) = ^[[3~
| TGETSTR(kich1) = ^[[2~
| TGETSTR(kpp) = ^[[5~
| TGETSTR(knp) = ^[[6~
| TGETSTR(kcbt) = ^[[Z
| TGETSTR(kend) = ^[[4~
| TGETSTR(khome) = ^[[1~
| TGETSTR(kcub1) = ^[OD
| TGETSTR(kcuf1) = ^[OC
| TGETSTR(kcud1) = ^[OB
| TGETSTR(kcuu1) = ^[OA
| return }} 
called {{ bfind([vileinit], 33)
| 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| after regmassage: '((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| return }} 0x1ded490
called {{ bfind([vileopts], 33)
| 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| after regmassage: '((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| return }} 0x1dedd40
called {{ tcap_kopen()
| called {{ xterm_mopen()
| | return }} 
| return }} 
called {{ set_fsm_choices(color-scheme)
|    [0] default = 0 (0)
| return }} 
called {{ winit(1)
| bsizes  unix 1 lines, 1 bytes
| winit delinking bminip, 1 lines, 1 bytes
| return }} 
called {{ bfind([unnamed], 0)
| 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| after regmassage: '((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| bsizes [unnamed] unix 0 lines, 0 bytes
| return }} 0x1df6d50
called {{ swbuffer(bp=0x1df6d50)
| called {{ swbuffer_lfl(bp=0x1df6d50, lockfl=1, this_window=0) 
bname='[unnamed]'
| | swbuffer([unnamed]) nwnd=0
| | called {{ special_formatter %{$progname} - %{$cbufname}
| | | return }} 
| | called {{ suckitin([unnamed], copy)
| | | return }} 1
| | called {{ special_formatter %{$progname} - %{$cbufname}
| | | return }} 
| | return }} 1
| return }} 1
called {{ zotbuf(bp=0x1ded490)
| zotbuf([vileinit])
| called {{ freeundostacks(0x1ded490,1)
| | return }} 
| return }} 1
called {{ do_source(.vilerc, 1, 1)
| called {{ cfg_locate('.vilerc', READABLE CDIR HOME STARTPATH)
| | ffaccess(fn=.vilerc, mode=12) = 1
| | called {{ check_file_access(.vilerc, 0xc) = 1
| | | called {{ canonpath '/usr/build/vile/vile/.vilerc'
| | | | return }} /usr/build/vile/vile/.vilerc
| | | return }} 1
| | return }} .vilerc
| called {{ dofile(.vilerc)
| | called {{ canonpath '/usr/build/vile/vile/.vilerc'
| | | return }} /usr/build/vile/vile/.vilerc
| | makename(.vilerc)
| |  -> '.vilerc'
| | unqname ->.vilerc
| | called {{ bfind(.vilerc, 0)
| | | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | | bsizes .vilerc unix 0 lines, 0 bytes
| | | return }} 0x1ded490
| | called {{ canonpath '/usr/build/vile/vile/.vilerc'
| | | return }} /usr/build/vile/vile/.vilerc
| | file_stat(/usr/build/vile/vile/.vilerc) = 0
| | file_stat(/usr/build/vile/vile/.vilerc) = 0
| | same_fname(
        fname=.vilerc,
        bname=.vilerc,
        lengthen=0)
| | =>0
| | called {{ readin(fname=.vilerc, lockfl=0, bp=0x1ded490, mflg=1)
| | | called {{ freeundostacks(0x1ded490,1)
| | | | return }} 
| | | called {{ canonpath '/usr/build/vile/vile/.vilerc'
| | | | return }} /usr/build/vile/vile/.vilerc
| | | file_stat(/usr/build/vile/vile/.vilerc) = 0 purged
| | | file_stat(/usr/build/vile/vile/.vilerc) = 0
| | | same_fname(
        fname=.vilerc,
        bname=.vilerc,
        lengthen=0)
| | | =>0
| | | ffropen(fn=/usr/build/vile/vile/.vilerc)
| | | file_stat(/usr/build/vile/vile/.vilerc) = 0 cached
| | | file_stat(/usr/build/vile/vile/.vilerc) = 0 cached
| | | ** opened /usr/build/vile/vile/.vilerc for read
| | | mlmsg popup_msgs #1 for '[Reading %s]'
| | | called {{ bfind([Messages], 1)
| | | | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | | | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | | | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | | | bsizes [Messages] unix 0 lines, 0 bytes
| | | | return }} 0x1df7c70
| | | msg:?
| | | called {{ quickreadf(buffer=.vilerc, file=/usr/build/vile/vile/.vilerc)
| | | | ffsize succeeded 0
| | | | return }} 2
| | | called {{ slowreadf(buffer=.vilerc, file=/usr/build/vile/vile/.vilerc)
| | | | return }} 1
| | | ffaccess(fn=/usr/build/vile/vile/.vilerc, mode=2) = 1
| | | ffronly(fn=/usr/build/vile/vile/.vilerc) = 0
| | | shorten '/usr/build/vile/vile/.vilerc'
| | |      -> './.vilerc' shorten
| | | mlmsg popup_msgs #1 for '[%sRead %d line%s from "%s"%s]'
| | | msg:[Reading /usr/build/vile/vile/.vilerc]
| | | ffaccess(fn=/usr/build/vile/vile/.vilerc, mode=2) = 1
| | | ffronly(fn=/usr/build/vile/vile/.vilerc) = 0
| | | called {{ infer_majormode(.vilerc)
| | | | return }} 
| | | called {{ imply_alt(fname=/usr/build/vile/vile/.vilerc, copy=0, lockfl=0)
| | | | called {{ canonpath '/usr/build/vile/vile/.vilerc'
| | | | | return }} /usr/build/vile/vile/.vilerc
| | | | return }} 
| | | return }} 1
| | called {{ dobuf(.vilerc, 1)
| | | called {{ save_arguments(.vilerc) max_args=0
| | | | return }} 1
| | | called {{ perform_dobuf(bp=0x1ded490, whlist=(nil)) buffer '.vilerc'
| | | | return }} 1
| | | restore_arguments(.vilerc)
| | | return }} 1
| | called {{ zotbuf(bp=0x1ded490)
| | | zotbuf(.vilerc)
| | | called {{ freeundostacks(0x1ded490,1)
| | | | return }} 
| | | return }} 1
| | return }} 1
| return }} 1
called {{ run_startup_commands [vileopts]
| called {{ dobuf([vileopts], 1)
| | called {{ save_arguments([vileopts]) max_args=0
| | | return }} 1
| | called {{ perform_dobuf(bp=0x1dedd40, whlist=(nil)) buffer '[vileopts]'
| | | bsizes [vileopts] unix 1 lines, 17 bytes
| | | [vileopts]:1 (0/0):tag 'disp.array'
| | | <<<[vileopts]:0/0 tag 'disp.array'>>>
| | | called {{ docmd(cline=tag 'disp.array', execflag=1, f=0, n=1)
| | | | called {{ execute(execfunc=0x4defa0(func:gototag), f=0, n=1)
| | | | | called {{ kbd_reply(prompt=Tag name: , extbuf=^@, options=0x23)
| | | | | | clexec=1, pushed_back=0
| | | | | | ...getting token from: 'disp.array'
| | | | | | ...got token, result:  'disp.array
| | | | | | called {{ cfg_locate('tags', READABLE CDIR ALWAYS)
| | | | | | | ffaccess(fn=tags, mode=524) = 1
| | | | | | | called {{ check_file_access(tags, 0x20c) = 1
| | | | | | | | return }} 1
| | | | | | | return }} tags
| | | | | | called {{ bfind([Tags 1], 1)
| | | | | | | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | | | | | | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | | | | | | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | | | | | | bsizes [Tags 1] unix 0 lines, 0 bytes
| | | | | | | return }} 0x1df8820
| | | | | | called {{ readin(fname=tags, lockfl=0, bp=0x1df8820, mflg=0)
| | | | | | | called {{ freeundostacks(0x1df8820,1)
| | | | | | | | return }} 
| | | | | | | called {{ canonpath '/usr/build/vile/vile/tags'
| | | | | | | | return }} /usr/build/vile/vile/tags
| | | | | | | file_stat(/usr/build/vile/vile/tags) = 0
| | | | | | | file_stat(/usr/build/vile/vile/tags) = 0
| | | | | | | same_fname(
        fname=tags,
        bname=[Tags 1],
        lengthen=0)
| | | | | | | =>0
| | | | | | | ffropen(fn=/usr/build/vile/vile/tags)
| | | | | | | file_stat(/usr/build/vile/vile/tags) = 0 cached
| | | | | | | file_stat(/usr/build/vile/vile/tags) = 0 cached
| | | | | | | ** opened /usr/build/vile/vile/tags for read
| | | | | | | called {{ quickreadf(buffer=[Tags 1], 
file=/usr/build/vile/vile/tags)
| | | | | | | | ffsize succeeded 555301
| | | | | | | | ffread succeeded 555301
| | | | | | | | called {{ decode_bom([Tags 1]) length 555301
| | | | | | | | | set_byteorder_mark for '[Tags 1]' to none
| | | | | | | | | return }} 0
| | | | | | | | called {{ deduce_charset([Tags 1]) bom:none, encoding:locale
| | | | | | | | | return }} 1
| | | | | | | | guess_recordseparator assume unix, rs=lf CR:0, LF:9454, CRLF:0
| | | | | | | | ...line count = 9454, format=lf
| | | | | | | | bsizes [Tags 1] unix 9454 lines, 555301 bytes
| | | | | | | | return }} 0
| | | | | | | ffaccess(fn=/usr/build/vile/vile/tags, mode=2) = 1
| | | | | | | ffronly(fn=/usr/build/vile/vile/tags) = 0
| | | | | | | called {{ infer_majormode([Tags 1])
| | | | | | | | return }} 
| | | | | | | called {{ imply_alt(fname=/usr/build/vile/vile/tags, copy=0, 
lockfl=0)
| | | | | | | | called {{ canonpath '/usr/build/vile/vile/tags'
| | | | | | | | | return }} /usr/build/vile/vile/tags
| | | | | | | | return }} 
| | | | | | | return }} 1
| | | | | | called {{ find_mode(tagsmode) local
| | | | | | | return }} 0
| | | | | | stored 7923 tags entries
| | | | | | reply1:(status=1, length=11):disp.array^@
| | | | | | return }} 1
| | | | | called {{ canonpath '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | return }} /usr/build/vile/vile/fzrutils/R/disp.array.R
| | | | | same_fname(
        fname=/usr/build/vile/vile/fzrutils/R/disp.array.R,
        bname=[Tags 1],
        lengthen=0)
| | | | | =>0
| | | | | called {{ canonpath '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | return }} /usr/build/vile/vile/fzrutils/R/disp.array.R
| | | | | same_fname(
        fname=/usr/build/vile/vile/fzrutils/R/disp.array.R,
        bname=[Tags 1],
        lengthen=0)
| | | | | =>0
| | | | | makename(/usr/build/vile/vile/fzrutils/R/disp.array.R)
| | | | |  -> 'disp.array.R'
| | | | | called {{ bfind(disp.array.R, 0)
| | | | | | 
set_buf_fname_expr(\(\(\[\([!]\?[[:print:]]\+\)\]\)\|\([[:ident:].-]\+\)\|[[:file:]]\+\))
| | | | | | 
regcomp("\\(\\(\\[\\([!]\\?[[:print:]]\\+\\)\\]\\)\\|\\([[:ident:].-]\\+\\)\\|[[:file:]]\\+\\)",
 magic)
| | | | | | after regmassage: 
'((\\[([!]?[[:print:]]+)\\])|([[:ident:].-]+)|[[:file:]]+)'
| | | | | | bsizes disp.array.R unix 0 lines, 0 bytes
| | | | | | return }} 0x1e93ae0
| | | | | called {{ canonpath '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | return }} /usr/build/vile/vile/fzrutils/R/disp.array.R
| | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | same_fname(
        fname=/usr/build/vile/vile/fzrutils/R/disp.array.R,
        bname=disp.array.R,
        lengthen=0)
| | | | | =>1
| | | | | fileuid_get(/usr/build/vile/vile/fzrutils/R/disp.array.R) discarding 
cache
| | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0 purged
| | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | called {{ swbuffer_lfl(bp=0x1e93ae0, lockfl=1, this_window=0) 
bname='disp.array.R'
| | | | | | swbuffer(disp.array.R) nwnd=0
| | | | | | called {{ special_formatter %{$progname} - %{$cbufname}
| | | | | | | return }} 
| | | | | | called {{ suckitin(disp.array.R, copy)
| | | | | | | called {{ 
readin(fname=/usr/build/vile/vile/fzrutils/R/disp.array.R, lockfl=1, 
bp=0x1e93ae0, mflg=1)
| | | | | | | | called {{ freeundostacks(0x1e93ae0,1)
| | | | | | | | | return }} 
| | | | | | | | called {{ canonpath 
'/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | | | | return }} /usr/build/vile/vile/fzrutils/R/disp.array.R
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0 
purged
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | | | | same_fname(
        fname=/usr/build/vile/vile/fzrutils/R/disp.array.R,
        bname=disp.array.R,
        lengthen=0)
| | | | | | | | =>1
| | | | | | | | fileuid_get(/usr/build/vile/vile/fzrutils/R/disp.array.R) 
discarding cache
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0 
purged
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | | | | ffropen(fn=/usr/build/vile/vile/fzrutils/R/disp.array.R)
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0 
cached
| | | | | | | | file_stat(/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0 
cached
| | | | | | | | ** opened /usr/build/vile/vile/fzrutils/R/disp.array.R for read
| | | | | | | | mlmsg popup_msgs #1 for '[Reading %s]'
| | | | | | | | msg:[Read 0 lines from "./.vilerc"]
| | | | | | | | called {{ quickreadf(buffer=disp.array.R, 
file=/usr/build/vile/vile/fzrutils/R/disp.array.R)
| | | | | | | | | ffsize succeeded 31
| | | | | | | | | ffread succeeded 31
| | | | | | | | | called {{ decode_bom(disp.array.R) length 31
| | | | | | | | | | set_byteorder_mark for 'disp.array.R' to none
| | | | | | | | | | return }} 0
| | | | | | | | | called {{ deduce_charset(disp.array.R) bom:none, 
encoding:locale
| | | | | | | | | | return }} 1
| | | | | | | | | guess_recordseparator assume unix, rs=lf CR:0, LF:4, CRLF:0
| | | | | | | | | ...line count = 4, format=lf
| | | | | | | | | bsizes disp.array.R unix 4 lines, 31 bytes
| | | | | | | | | return }} 0
| | | | | | | | ffaccess(fn=/usr/build/vile/vile/fzrutils/R/disp.array.R, 
mode=2) = 1
| | | | | | | | ffronly(fn=/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | | | | shorten '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | | |      -> './fzrutils/R/disp.array.R' shorten
| | | | | | | | ffaccess(fn=/usr/build/vile/vile/fzrutils/R/disp.array.R, 
mode=2) = 1
| | | | | | | | ffronly(fn=/usr/build/vile/vile/fzrutils/R/disp.array.R) = 0
| | | | | | | | called {{ infer_majormode(disp.array.R)
| | | | | | | | | return }} 
| | | | | | | | called {{ 
imply_alt(fname=/usr/build/vile/vile/fzrutils/R/disp.array.R, copy=0, lockfl=1)
| | | | | | | | | called {{ canonpath 
'/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | | | | | | | | | return }} /usr/build/vile/vile/fzrutils/R/disp.array.R
| | | | | | | | | return }} 
| | | | | | | | return }} 1
| | | | | | | return }} 1
| | | | | | called {{ special_formatter %{$progname} - %{$cbufname}
| | | | | | | return }} 
| | | | | | return }} 1
| | | | | regcomp("^disp.array <- function ($", nomagic)
| | | | | after regmassage: '^disp\\.array\\ \\<-\\ function\\ \\($'
| | | | | cheap_buffer_scan '^disp.array <- function ($' fwd
| | | | | mark_tag_hit disp.array.R:3
| | | | | ... mark_tag_hit FALSE
| | | | | return }} 1
| | | | return }} 1
| | | return }} 1
| | restore_arguments([vileopts])
| | return }} 1
| called {{ zotbuf(bp=0x1df6d50)
| | zotbuf([unnamed])
| | called {{ freeundostacks(0x1df6d50,1)
| | | return }} 
| | return }} 1
| called {{ zotwp([vileopts])
| | called {{ swbuffer(bp=0x1e93ae0)
| | | called {{ swbuffer_lfl(bp=0x1e93ae0, lockfl=1, this_window=0) 
bname='disp.array.R'
| | | | swbuffer(disp.array.R) nwnd=1
| | | | called {{ special_formatter %{$progname} - %{$cbufname}
| | | | | return }} 
| | | | return }} 1
| | | return }} 1
| | return }} 1
| called {{ zotbuf(bp=0x1dedd40)
| | zotbuf([vileopts])
| | called {{ freeundostacks(0x1dedd40,1)
| | | return }} 
| | return }} 1
| return }} 1
called {{ zotwp(null)
| return }} 0
purge_msgs mode:-1, warnings:0
called {{ zotbuf(bp=0x1df7c70)
| zotbuf([Messages])
| called {{ freeundostacks(0x1df7c70,1)
| | return }} 
| return }} 1
called {{ update(0)
| CURSOR OFF
| called {{ update_modeline
| | called {{ special_formatter %-%i%- %b %m:: :%f:is : :%=%F: : :%l:(:,:%c::) 
:%p::% :%C:char ::%S%-%-%|
| | | shorten '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | |      -> 'fzrutils/R/disp.array.R' shorten
| | | shorten '/usr/build/vile/vile/fzrutils/R/disp.array.R'
| | |      -> 'fzrutils/R/disp.array.R' shorten
| | | return }} 
| | return }} 
| called {{ update_garbaged_screen
| | return }} 
| called {{ update_physical_screen(0)
| | return }} 
| CURSOR ON
| return }} 1
called {{ zotwp(null)
| return }} 0
called {{ zotwp(null)
| return }} 0
NULL:39:[Use ^A-h, ^X-h, or :help to get help] 
SHOW:39:[Use ^A-h, ^X-h, or :help to get help] 
called {{ update(0)
| called {{ update_physical_screen(0)
| | return }} 
| return }} 1
vl_mb_getch:0x51
mapped/getc:Q (0x51)
tgetc(unquoted) = Q(0x51)
NULL: 0:
SHOW: 0:
called {{ update(0)
| called {{ update_physical_screen(0)
| | return }} 
| return }} 1
called {{ execute(execfunc=0x4dd120(func:quit), f=0, n=1)
| called {{ tcap_close()
| | vl_close_mbterm
| | return }} 
| called {{ tcap_kclose()
| | called {{ xterm_mclose()
| | | return }} 
| | return }} 

Attachment: signature.asc
Description: Digital signature

_______________________________________________
vile mailing list
vile@nongnu.org
https://lists.nongnu.org/mailman/listinfo/vile

Reply via email to