Attachment #13321 for bug #46325

View | Details | Raw Unified | Return to bug 46325
Collapse All | Expand All

Lines 24-32 Link Here

(-)vis-0.6/.github/workflows/coverity-scan.yml (-2 / +7 lines)
24		24
25	- name: Download Coverity Build Tool	25	- name: Download Coverity Build Tool
26	run: \|	26	run: \|
27	wget -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=$TOKEN&project=martanne/vis" -O cov-analysis-linux64.tar.gz	27	wget -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=$TOKEN&project=martanne/vis" -O coverity_tool.tgz
		28	wget -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=$TOKEN&project=martanne/vis&md5=1" -O coverity_tool.md5
		29	if ! (cat coverity_tool.md5; echo " coverity_tool.tgz") \| md5sum -c --status; then
		30	echo "Download checksum verification failed"
		31	exit 1
		32	fi
28	mkdir cov-analysis-linux64	33	mkdir cov-analysis-linux64
29	tar xzf cov-analysis-linux64.tar.gz --strip 1 -C cov-analysis-linux64	34	tar xzf coverity_tool.tgz --strip 1 -C cov-analysis-linux64
30	env:	35	env:
31	TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}	36	TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
32		37

Lines 49-52 Link Here

(-)vis-0.6/.github/workflows/macos.yml (-1 / +7 lines)
49	env:	49	env:
50	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}	50	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
51	run: \|	51	run: \|
52	bash <(curl -s https://codecov.io/bash)	52	curl -s https://codecov.io/bash > codecov
		53	curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/SHA256SUM > codecov.sha256
		54	if ! sha256sum -c --ignore-missing --status codecov.sha256 ; then
		55	echo "Download checksum verification failed"
		56	exit 1
		57	fi
		58	bash < codecov

Lines 55-58 Link Here

(-)vis-0.6/.github/workflows/ubuntu.yml (-1 / +7 lines)
55	env:	55	env:
56	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}	56	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
57	run: \|	57	run: \|
58	bash <(curl -s https://codecov.io/bash)	58	curl -s https://codecov.io/bash > codecov
		59	curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/SHA256SUM > codecov.sha256
		60	if ! sha256sum -c --ignore-missing --status codecov.sha256 ; then
		61	echo "Download checksum verification failed"
		62	exit 1
		63	fi
		64	bash < codecov




      run: |
        choco install --no-progress --yes --force --source=cygwin gcc-core,libtool,make,wget,pkg-config
        choco install --no-progress --yes --force --source=cygwin lua,lua-devel,lua-lpeg,libncurses-devel
        echo '::add-path::C:\tools\cygwin\bin'

    - name: Setup $PATH
      shell: bash
      run: echo 'C:\tools\cygwin\bin' >> $GITHUB_PATH

    - name: Git configuration
      run: |
        git config --global core.autocrlf input

      shell: bash
      env:
        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
      run: |
        curl -s https://codecov.io/bash > codecov
        curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/SHA256SUM > codecov.sha256
        if ! sha256sum -c --ignore-missing --status codecov.sha256 ; then
          echo "Download checksum verification failed"
          exit 1
        fi
        bash < codecov

Lines 12-16 Link Here

(-)vis-0.6/.gitignore (-2 lines)
12	*.gcov	12	*.gcov
13	*.html	13	*.html
14	*.o	14	*.o
15	*.swo
16	*.swp

Lines 1-5 Link Here

(-)vis-0.6/Dockerfile (-1 / +1 lines)
1	# Run 'make docker' to build a statically linked vis executable!	1	# Run 'make docker' to build a statically linked vis executable!
2	FROM i386/alpine:3.12	2	FROM i386/alpine:3.13
3	RUN apk update && apk add --upgrade --no-cache \	3	RUN apk update && apk add --upgrade --no-cache \
4	acl-dev \	4	acl-dev \
5	acl-static \	5	acl-static \

Lines 1-6 Link Here

(-)vis-0.6/LICENSE (-1 / +1 lines)
1	vis as a whole is licensed under the following standard ISC license:	1	vis as a whole is licensed under the following standard ISC license:
2		2
3	Copyright © 2014-2018 Marc André Tanner, et al.	3	Copyright © 2014-2020 Marc André Tanner, et al.
4		4
5	Permission to use, copy, modify, and/or distribute this software for any	5	Permission to use, copy, modify, and/or distribute this software for any
6	purpose with or without fee is hereby granted, provided that the above	6	purpose with or without fee is hereby granted, provided that the above





REGEX_SRC ?= text-regex.c

SRC = array.c \
	buffer.c \
	libutf.c \
	main.c \
	map.c \
	sam.c \
	text.c \
	text-common.c \
	text-io.c \
	text-iterator.c \
	text-motions.c \
	text-objects.c \
	text-util.c \
	ui-terminal.c \
	view.c \
	vis.c \
	vis-lua.c \
	vis-marks.c \
	vis-modes.c \
	vis-motions.c \
	vis-operators.c \
	vis-prompt.c \
	vis-registers.c \
	vis-text-objects.c \
	$(REGEX_SRC)

ELF = vis vis-menu vis-digraph
EXECUTABLES = $(ELF) vis-clipboard vis-complete vis-open


DOCUMENTATION = LICENSE README.md

VERSION = 0.8

CONFIG_HELP ?= 1
CONFIG_CURSES ?= 1

	[ -e test/Makefile ] || $(MAKE) test-update
	@$(MAKE) -C test

testclean:
	@echo cleaning the test artifacts
	[ ! -e test/Makefile ] || $(MAKE) -C test clean

clean:
	@echo cleaning
	@rm -f $(ELF) vis-single vis-single-payload.inc vis-*.tar.gz *.gcov *.gcda *.gcno

distclean: clean testclean
	@echo cleaning build configuration
	@rm -f config.h config.mk

dist: distclean
	@echo creating dist tarball
	@git archive --prefix=vis-${VERSION}/ -o vis-${VERSION}.tar.gz HEAD


	@echo removing support files from ${DESTDIR}${SHAREPREFIX}/vis
	@rm -rf ${DESTDIR}${SHAREPREFIX}/vis

.PHONY: all clean testclean dist distclean install install-strip uninstall debug profile coverage test test-update luadoc luadoc-all luacheck man docker-kill docker docker-clean




# Vis - Combining Modal Editing with Structural Regular Expressions

[![builds.sr.ht status](https://builds.sr.ht/~martanne/vis/commits.svg)](https://builds.sr.ht/~martanne/vis/commits?)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/3939/badge.svg)](https://scan.coverity.com/projects/3939)
[![codecov](https://codecov.io/gh/martanne/vis/branch/master/graph/badge.svg)](https://codecov.io/gh/martanne/vis)
[![Documentation Status](https://readthedocs.org/projects/vis/badge/?version=master)](http://vis.readthedocs.io/en/master/?badge=master)
[![#vis-editor on libera](https://img.shields.io/badge/IRC-%23vis--editor-blue.svg)](ircs://irc.libera.chat:6697/vis-editor)

Vis aims to be a modern, legacy-free, simple yet efficient editor,
combining the strengths of both vi(m) and sam.

    $ ./configure && make && sudo make install

By default the `configure` script will try to auto detect support for
Lua using `pkg-config(1)`. See `configure --help` for a list of supported
options. You can also manually tweak the generated `config.mk` file.

Or simply use one of the
[distribution provided packages](https://github.com/martanne/vis/wiki/Distribution-Packages).


Checkout the [Developer Overview](https://github.com/martanne/vis/wiki/Developer-Overview)
to get started and do not hesitate to ask question in the `#vis-editor`
IRC channel on libera ([join via your browser](https://web.libera.chat/#vis-editor)).




	array_init_sized(arr, sizeof(void*));
}

void array_init_from(Array *arr, const Array *from) {
	array_init_sized(arr, from->elem_size);
}


		memset(arr->items, 0, arr->count * arr->elem_size);
}

void *array_get(const Array *arr, size_t idx) {
	if (idx >= arr->len) {
		errno = EINVAL;
		return NULL;

	return arr->items + (idx * arr->elem_size);
}

void *array_get_ptr(const Array *arr, size_t idx) {
	if (arr->elem_size != sizeof(void*)) {
		errno = ENOTSUP;
		return NULL;

	return true;
}

size_t array_length(const Array *arr) {
	return arr->len;
}

size_t array_capacity(const Array *arr) {
	return arr->count;
}


	return item;
}

void *array_peek(const Array *arr) {
	if (arr->len == 0)
		return NULL;
	return array_get(arr, arr->len - 1);




 */
void array_init_sized(Array*, size_t elem_size);
/** Initialize Array by using the same element size as in ``from``. */
void array_init_from(Array*, const Array *from);
/** Release storage space. Reinitializes Array object. */
void array_release(Array*);
/**

 *              of new elements) might invalidate the pointer.
 * @endrst
 */
void *array_get(const Array*, size_t idx);
/**
 * Set array element.
 * @rst

 */
bool array_set(Array*, size_t idx, void *item);
/** Dereference pointer stored in array element. */
void *array_get_ptr(const Array*, size_t idx);
/** Store the address to which ``item`` points to into the array. */
bool array_set_ptr(Array*, size_t idx, void *item);
/** Add element to the end of the array. */

 */
bool array_remove(Array*, size_t idx);
/** Number of elements currently stored in the array. */
size_t array_length(const Array*);
/** Number of elements which can be stored without enlarging the array. */
size_t array_capacity(const Array*);
/** Remove all elements with index greater or equal to ``length``, keep allocated memory. */
bool array_truncate(Array*, size_t length);
/**
 * Change length.
 * @rst
 * .. note:: Has to be less or equal than the capacity.
 *           Newly accessible elements preserve their previous values.
 * @endrst
 */
bool array_resize(Array*, size_t length);

 * .. warning:: The same ownership rules as for ``array_get`` apply.
 * @endrst
 */
void *array_peek(const Array*);

#endif




bool buffer_insert0(Buffer*, size_t pos, const char *data);
/** Append further content to the end. */
bool buffer_append(Buffer*, const void *data, size_t len);
/** Append NUL-terminated data. */
bool buffer_append0(Buffer*, const char *data);
/** Insert ``len`` bytes of ``data`` at the start. */
bool buffer_prepend(Buffer*, const void *data, size_t len);
/** Insert NUL-terminated data at the start. */
bool buffer_prepend0(Buffer*, const char *data);
/** Set formatted buffer content, ensures NUL termination on success. */
bool buffer_printf(Buffer*, const char *fmt, ...) __attribute__((format(printf, 2, 3)));

/**
 * Borrow underlying buffer data.
 * @rst
 * .. warning:: The caller is responsible to ``free(3)`` it.
 * @endrst
 */
char *buffer_move(Buffer*);




	{ ",",                  ACTION(TOTILL_REVERSE)                      },
	{ "+",                  ALIAS("j^")                                 },
	{ "-",                  ALIAS("k^")                                 },
	{ " ",                  ALIAS("<Space>")                            },
	{ "<Space>",            ALIAS("l")                                  },
	{ "<Backspace>",        ALIAS("h")                                  },
	{ "B",                  ACTION(CURSOR_LONGWORD_START_PREV)          },
	{ "b",                  ACTION(CURSOR_WORD_START_PREV)              },
	{ "<C-h>",              ALIAS("<Backspace>")                        },
	{ "<C-j>",              ALIAS("j")                                  },
	{ "<C-n>",              ALIAS("j")                                  },
	{ "<C-p>",              ALIAS("k")                                  },
	{ "E",                  ACTION(CURSOR_LONGWORD_END_NEXT)            },
	{ "e",                  ACTION(CURSOR_WORD_END_NEXT)                },
	{ "F",                  ACTION(TO_LINE_LEFT)                        },
	{ "f",                  ACTION(TO_LINE_RIGHT)                       },
	{ "f",                  ACTION(TO_RIGHT)                            },
	{ "go",                 ACTION(CURSOR_BYTE)                         },
	{ "gH",                 ACTION(CURSOR_BYTE_LEFT)                    },
	{ "gL",                 ACTION(CURSOR_BYTE_RIGHT)                   },

	{ "M",                  ACTION(CURSOR_WINDOW_LINE_MIDDLE)           },
	{ "n",                  ACTION(CURSOR_SEARCH_REPEAT_FORWARD)        },
	{ "N",                  ACTION(CURSOR_SEARCH_REPEAT_BACKWARD)       },
	{ "T",                  ACTION(TILL_LINE_LEFT)                      },
	{ "t",                  ACTION(TILL_LINE_RIGHT)                     },
	{ "W",                  ACTION(CURSOR_LONGWORD_START_NEXT)          },
	{ "w",                  ACTION(CURSOR_WORD_START_NEXT)              },
	{ 0 /* empty last element, array terminator */                      },

	{ "a}",                 ALIAS("a{")                                 },
	{ "ab",                 ALIAS("a(")                                 },
	{ "aB",                 ALIAS("a{")                                 },
	{ "ae",                 ACTION(TEXT_OBJECT_ENTIRE_OUTER)            },
	{ "al",                 ACTION(TEXT_OBJECT_LINE_OUTER)              },
	{ "ap",                 ACTION(TEXT_OBJECT_PARAGRAPH_OUTER)         },
	{ "as",                 ACTION(TEXT_OBJECT_SENTENCE)                },

	{ "i}",                 ALIAS("i{")                                 },
	{ "ib",                 ALIAS("i(")                                 },
	{ "iB",                 ALIAS("i{")                                 },
	{ "ie",                 ACTION(TEXT_OBJECT_ENTIRE_INNER)            },
	{ "il",                 ACTION(TEXT_OBJECT_LINE_INNER)              },
	{ "ip",                 ACTION(TEXT_OBJECT_PARAGRAPH)               },
	{ "is",                 ACTION(TEXT_OBJECT_SENTENCE)                },

	{ "M",                  ACTION(SELECTIONS_RESTORE)                  },
	{ "|",                  ACTION(SELECTIONS_UNION)                    },
	{ "&",                  ACTION(SELECTIONS_INTERSECT)                },
	{ "~",                  ACTION(SELECTIONS_COMPLEMENT)               },
	{ "\\",                 ACTION(SELECTIONS_MINUS)                    },
	{ "z|",                 ACTION(SELECTIONS_COMBINE_UNION)            },
	{ "z&",                 ACTION(SELECTIONS_COMBINE_INTERSECT)        },
	{ "z+",                 ACTION(SELECTIONS_COMBINE_LONGER)           },
	{ "z-",                 ACTION(SELECTIONS_COMBINE_SHORTER)          },
	{ "z<",                 ACTION(SELECTIONS_COMBINE_LEFTMOST)         },
	{ "z>",                 ACTION(SELECTIONS_COMBINE_RIGHTMOST)        },
//	{ "-",                  ACTION(SELECTIONS_ROTATE_LEFT)              },
//	{ "+",                  ACTION(SELECTIONS_ROTATE_RIGHT)             },
	{ "_",                  ACTION(SELECTIONS_TRIM)                     },
	{ "<S-Tab>",            ACTION(SELECTIONS_ALIGN_INDENT_RIGHT)       },
	{ "<Tab>",              ACTION(SELECTIONS_ALIGN_INDENT_LEFT)        },

	{ "7",                  ACTION(COUNT)                               },
	{ "8",                  ACTION(COUNT)                               },
	{ "9",                  ACTION(COUNT)                               },
	{ "~",                  ALIAS("g~")                                 },
	{ "=",                  ALIAS(":|fmt<Enter>")                       },
	{ "<",                  ACTION(OPERATOR_SHIFT_LEFT)                 },
	{ ">",                  ACTION(OPERATOR_SHIFT_RIGHT)                },

	{ "<C-j>",              ACTION(SELECTIONS_NEW_LINE_BELOW)           },
	{ "<C-k>",              ACTION(SELECTIONS_NEW_LINE_ABOVE)           },
	{ "<C-l>",              ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT)     },
	{ "<C-n>",              ALIAS("viw")                                },
	{ "<C-p>",              ACTION(SELECTIONS_REMOVE_LAST)              },
	{ "<C-r>",              ACTION(REDO)                                },
	{ "<C-u>",              ACTION(SELECTIONS_PREV)                     },
	{ "<C-w><Backspace>",   ALIAS("<C-w>k")                             },
	{ "<C-w>c",             ALIAS(":q<Enter>")                          },
	{ "<C-w><C-h>",         ALIAS("<C-w>k")                             },
	{ "<C-w><C-j>",         ALIAS("<C-w>j")                             },
	{ "<C-w><C-k>",         ALIAS("<C-w>k")                             },
	{ "<C-w><C-l>",         ALIAS("<C-w>j")                             },
	{ "<C-w><C-w>",         ALIAS("<C-w>j")                             },
	{ "<C-w>h",             ALIAS("<C-w>k")                             },
	{ "<C-w>j",             ACTION(WINDOW_NEXT)                         },
	{ "<C-w>k",             ACTION(WINDOW_PREV)                         },

	{ "<C-w>n",             ALIAS(":open<Enter>")                       },
	{ "<C-w>s",             ALIAS(":split<Enter>")                      },
	{ "<C-w>v",             ALIAS(":vsplit<Enter>")                     },
	{ "<C-w>w",             ALIAS("<C-w>j")                             },
	{ "<C-y>",              ACTION(WINDOW_SLIDE_DOWN)                   },
	{ "D",                  ALIAS("d$")                                 },
	{ "<Delete>",           ALIAS("x")                                  },
	{ "<Escape>",           ACTION(MODE_NORMAL_ESCAPE)                  },
	{ "<F1>",               ALIAS(":help<Enter>")                       },
	{ "ga",                 ACTION(UNICODE_INFO)                        },

	{ "+",                  ACTION(SELECTIONS_ROTATE_RIGHT)             },
	{ "<",                  ALIAS("<vis-operator-shift-left>gv")        },
	{ ">",                  ALIAS("<vis-operator-shift-right>gv")       },
	{ "<C-a>",              ACTION(SELECTIONS_NEW_MATCH_ALL)            },
	{ "<C-b>",              ALIAS("<PageUp>")                           },
	{ "<C-c>",              ACTION(SELECTIONS_REMOVE_COLUMN)            },
	{ "<C-d>",              ACTION(SELECTIONS_NEXT)                     },
	{ "<C-f>",              ALIAS("<PageDown>")                         },
	{ "<C-h>",              ALIAS("<Backspace>")                        },
	{ "<C-j>",              ALIAS("<C-d>")                              },
	{ "<C-k>",              ALIAS("<C-u>")                              },
	{ "<C-l>",              ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT)     },

	{ "<C-p>",              ACTION(SELECTIONS_REMOVE_LAST)              },
	{ "<C-u>",              ACTION(SELECTIONS_PREV)                     },
	{ "<C-x>",              ACTION(SELECTIONS_NEW_MATCH_SKIP)           },
	{ "<Delete>",           ALIAS("<Backspace>")                        },
	{ "<Escape>",           ACTION(MODE_VISUAL_ESCAPE)                  },
	{ "I",                  ACTION(SELECTIONS_NEW_LINES_BEGIN)          },
	{ "J",                  ACTION(JOIN_LINES)                          },

	{ "<C-u>",              ACTION(DELETE_LINE_BEGIN)                   },
	{ "<C-v>",              ACTION(INSERT_VERBATIM)                     },
	{ "<C-w>",              ACTION(DELETE_WORD_PREV)                    },
	{ "<C-e>",              ACTION(CURSOR_LINE_END)                     },
	{ "<C-a>",              ACTION(CURSOR_LINE_START)                   },
	{ "<Delete>",           ACTION(DELETE_CHAR_NEXT)                    },
	{ "<Escape>",           ACTION(MODE_NORMAL)                         },
	{ 0 /* empty last element, array terminator */                      },





case "$OS" in
FreeBSD|DragonFly) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE -D__BSD_VISIBLE=1" ;;
NetBSD)  CFLAGS_STD="$CFLAGS_STD -D_NETBSD_SOURCE" ;;
*BSD)    CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE" ;;
Darwin)  CFLAGS_STD="$CFLAGS_STD -D_DARWIN_C_SOURCE" ;;
AIX)     CFLAGS_STD="$CFLAGS_STD -D_ALL_SOURCE" ;;

}
EOF

	for libcurses in ncursesw ncurses curses; do
		printf " checking for %s... " "$libcurses"

		if test "$have_pkgconfig" = "yes" ; then

}
EOF

	for liblua in lua lua5.4 lua5.3 lua5.2 lua-5.3 lua-5.2 lua54 lua53 lua52; do
		printf " checking for %s... " "$liblua"

		if test "$have_pkgconfig" = "yes" ; then

	test "$lua" = "yes" -a $CONFIG_LUA -ne 1 && fail "$0: cannot find liblua"

	if test $CONFIG_LUA -eq 1; then
		CFLAGS_LUA="$CFLAGS_LUA -DLUA_COMPAT_5_1 -DLUA_COMPAT_5_2 -DLUA_COMPAT_5_3 -DLUA_COMPAT_ALL"
	fi
fi


}
EOF

if $CC $CFLAGS $CFLAGS_STD "$tmpc" $LDFLAGS -o "$tmpo" >/dev/null 2>&1; then
	HAVE_MEMRCHR=1
	printf "%s\n" "yes"
else




# Doxyfile 1.8.18

# This file describes the settings to be used by the documentation system
# doxygen (www.doxygen.org) for a project.

# Project related configuration options
#---------------------------------------------------------------------------

# This tag specifies the encoding used for all characters in the configuration
# file that follow. The default is UTF-8 which is also the encoding used for all
# text before the first occurrence of this tag. Doxygen uses libiconv (or the
# iconv built into libc) for the transcoding. See
# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
# The default value is: UTF-8.

DOXYFILE_ENCODING      = UTF-8

# could be handy for archiving the generated documentation or if some version
# control system is used.

PROJECT_NUMBER         = 0.8

# Using the PROJECT_BRIEF tag one can provide an optional one line description
# for a project that appears at the top of each page and should give viewer a


OUTPUT_LANGUAGE        = English

# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
# documentation generated by doxygen is written. Doxygen will use this
# information to generate all generated output in the proper direction.
# Possible values are: None, LTR, RTL and Context.
# The default value is: None.

OUTPUT_TEXT_DIRECTION  = None

# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
# descriptions after the members that are listed in the file and class
# documentation (similar to Javadoc). Set to NO to disable this.


JAVADOC_AUTOBRIEF      = YES

# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
# such as
# /***************
# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
# Javadoc-style will behave just like regular comments and it will not be
# interpreted by doxygen.
# The default value is: NO.

JAVADOC_BANNER         = NO

# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
# line (until the first dot) of a Qt-style comment as the brief description. If
# set to NO, the Qt-style will behave just like regular Qt-style comments (thus

# will allow you to put the command \sideeffect (or @sideeffect) in the
# documentation, which will result in a user-defined paragraph with heading
# "Side Effects:". You can put \n's in the value part of an alias to insert
# newlines (in the resulting output). You can put ^^ in the value part of an
# alias to insert a newline as if a physical newline was in the original file.
# When you need a literal { or } or , in the value part of an alias you have to
# escape them by means of a backslash (\), this can lead to conflicts with the
# commands \{ and \} for these it is advised to use the version @{ and @} or use
# a double escape (\\{ and \\})

ALIASES                = "rst=\verbatim embed:rst:leading-asterisk" \
                         "endrst=\endverbatim"

# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding "class=itcl::class"
# will allow you to use the command class in the itcl::class meaning.

TCL_SUBST              =

# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
# only. Doxygen will then generate output that is more tailored for C. For
# instance, some of the names that are used will be different. The list of all


OPTIMIZE_OUTPUT_VHDL   = NO

# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
# sources only. Doxygen will then generate output that is more tailored for that
# language. For instance, namespaces will be presented as modules, types will be
# separated into more groups, etc.
# The default value is: NO.

OPTIMIZE_OUTPUT_SLICE  = NO

# Doxygen selects the parser to use depending on the extension of the files it
# parses. With this tag you can assign which parser to use for a given
# extension. Doxygen has a built-in mapping, but you can override or extend it
# using this tag. The format is ext=language, where ext is a file extension, and
# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
# tries to guess whether the code is fixed or free formatted code, this is the
# default for Fortran type files). For instance to make doxygen treat .inc files
# as Fortran files (default is PHP), and .f files as C (default is Fortran),
# use: inc=Fortran f=C.
#
# Note: For files without extension you can use no_extension as a placeholder.
#


# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
# according to the Markdown format, which allows for more readable
# documentation. See https://daringfireball.net/projects/markdown/ for details.
# The output of markdown processing is further processed by doxygen, so you can
# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
# case of backward compatibilities issues.

# to that level are automatically included in the table of contents, even if
# they do not have an id attribute.
# Note: This feature currently applies only to Markdown headings.
# Minimum value: 0, maximum value: 99, default value: 5.
# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.

TOC_INCLUDE_HEADINGS   = 0

CPP_CLI_SUPPORT        = NO

# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
# will parse them like normal C++ but will assume all classes use public instead
# of private inheritance when no explicit protection keyword is present.
# The default value is: NO.


EXTRACT_PRIVATE        = NO

# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
# methods of a class will be included in the documentation.
# The default value is: NO.

EXTRACT_PRIV_VIRTUAL   = NO

# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
# scope will be included in the documentation.
# The default value is: NO.

HIDE_UNDOC_CLASSES     = NO

# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
# declarations. If set to NO, these declarations will be included in the
# documentation.
# The default value is: NO.

HIDE_FRIEND_COMPOUNDS  = NO

# names in lower-case letters. If set to YES, upper-case letters are also
# allowed. This is useful if you have classes or files whose names only differ
# in case and if your file system supports case sensitive file names. Windows
# (including Cygwin) ands Mac users are advised to set this option to NO.
# The default value is: system dependent.

CASE_SENSE_NAMES       = YES

# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
# the reference definitions. This must be a list of .bib files. The .bib
# extension is automatically appended if omitted. This requires the bibtex tool
# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
# For LaTeX the style of the bibliography can be controlled using
# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
# search path. See also \cite for info how to create references.

# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
# are documented, but have no documentation for their parameters or return
# value. If set to NO, doxygen will only warn about wrong or incomplete
# parameter documentation, but not about the absence of documentation. If
# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
# The default value is: NO.

WARN_NO_PARAMDOC       = NO

# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
# possible encodings.
# The default value is: UTF-8.


# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen
# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd,
# *.vhdl, *.ucf, *.qsf and *.ice.

FILE_PATTERNS          = *.c \
                         *.cc \

STRIP_CODE_COMMENTS    = YES

# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
# entity all documented functions referencing it will be listed.
# The default value is: NO.

REFERENCED_BY_RELATION = NO

# If the USE_HTAGS tag is set to YES then the references to source code will
# point to the HTML generated by the htags(1) tool instead of doxygen built-in
# source browser. The htags tool is part of GNU's global source tagging system
# (see https://www.gnu.org/software/global/global.html). You will need version
# 4.8.6 or higher.
#
# To use it do the following:
# - Install the latest version of global
# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
# - Make sure the INPUT points to the root of the source tree
# - Run doxygen as normal
#

# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
# will adjust the colors in the style sheet and background images according to
# this color. Hue is specified as an angle on a colorwheel, see
# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
# purple, and 360 is red again.
# Minimum value: 0, maximum value: 359, default value: 220.


HTML_TIMESTAMP         = NO

# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
# documentation will contain a main index with vertical navigation menus that
# are dynamically created via JavaScript. If disabled, the navigation index will
# consists of multiple levels of tabs that are statically embedded in every HTML
# page. Disable this option to support browsers that do not have JavaScript,
# like the Qt help browser.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.

HTML_DYNAMIC_MENUS     = YES

# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
# documentation will contain sections that can be hidden and shown after the
# page has loaded.


# If the GENERATE_DOCSET tag is set to YES, additional index files will be
# generated that can be used as input for Apple's Xcode 3 integrated development
# environment (see: https://developer.apple.com/xcode/), introduced with OSX
# 10.5 (Leopard). To create a documentation set, doxygen will generate a
# Makefile in the HTML output directory. Running make will produce the docset in
# that directory and running make install will install the docset in
# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
# genXcode/_index.html for more information.
# The default value is: NO.
# This tag requires that the tag GENERATE_HTML is set to YES.


# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
# Windows.
#
# The HTML Help Workshop contains a compiler that can convert all HTML output


# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
# Project output. For more information please see Qt Help Project / Namespace
# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
# The default value is: org.doxygen.Project.
# This tag requires that the tag GENERATE_QHP is set to YES.



# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
# Help Project output. For more information please see Qt Help Project / Virtual
# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
# folders).
# The default value is: doc.
# This tag requires that the tag GENERATE_QHP is set to YES.


# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
# filter to add. For more information please see Qt Help Project / Custom
# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
# filters).
# This tag requires that the tag GENERATE_QHP is set to YES.



# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
# custom filter to add. For more information please see Qt Help Project / Custom
# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
# filters).
# This tag requires that the tag GENERATE_QHP is set to YES.



# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
# project's filter section matches. Qt Help Project / Filter Attributes (see:
# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
# This tag requires that the tag GENERATE_QHP is set to YES.

QHP_SECT_FILTER_ATTRS  =


EXT_LINKS_IN_WINDOW    = NO

# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
# the HTML output. These images will generally look nicer at scaled resolutions.
# Possible values are: png The default and svg Looks nicer but requires the
# pdf2svg tool.
# The default value is: png.
# This tag requires that the tag GENERATE_HTML is set to YES.

HTML_FORMULA_FORMAT    = png

# Use this tag to change the font size of LaTeX formulas included as images in
# the HTML documentation. When you change the font size after a successful
# doxygen run you need to manually remove any form_*.png images from the HTML


FORMULA_FONTSIZE       = 10

# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are not
# supported properly for IE 6.0, but are supported on all modern browsers.
#


FORMULA_TRANSPARENT    = YES

# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
# to create new LaTeX commands to be used in formulas as building blocks. See
# the section "Including formulas" for details.

FORMULA_MACROFILE      =

# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
# https://www.mathjax.org) which uses client side JavaScript for the rendering
# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
# installed or if you want to formulas look prettier in the HTML output. When
# enabled you may also need to install MathJax separately and configure the path

# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
# Content Delivery Network so you can quickly see the result without installing
# MathJax. However, it is strongly recommended to install a local copy of
# MathJax from https://www.mathjax.org before deployment.
# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
# This tag requires that the tag USE_MATHJAX is set to YES.

MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest

SEARCHENGINE           = YES

# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
# implemented using a web server instead of a web client using JavaScript. There
# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
# setting. When disabled, doxygen will generate a PHP script for searching and
# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing

#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: https://xapian.org/).
#
# See the section "External Indexing and Searching" for details.
# The default value is: NO.

#
# Doxygen ships with an example indexer (doxyindexer) and search engine
# (doxysearch.cgi) which are based on the open source search engine library
# Xapian (see: https://xapian.org/). See the section "External Indexing and
# Searching" for details.
# This tag requires that the tag SEARCHENGINE is set to YES.


# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
# invoked.
#
# Note that when not enabling USE_PDFLATEX the default is latex when enabling
# USE_PDFLATEX the default is pdflatex and when in the later case latex is
# chosen this is overwritten by pdflatex. For specific output languages the
# default can have been set differently, this depends on the implementation of
# the output language.
# This tag requires that the tag GENERATE_LATEX is set to YES.

LATEX_CMD_NAME         = latex

# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
# index for LaTeX.
# Note: This tag is used in the Makefile / make.bat.
# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
# (.tex).
# The default file is: makeindex.
# This tag requires that the tag GENERATE_LATEX is set to YES.

MAKEINDEX_CMD_NAME     = makeindex

# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
# generate index for LaTeX. In case there is no backslash (\) as first character
# it will be automatically added in the LaTeX code.
# Note: This tag is used in the generated output file (.tex).
# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
# The default value is: makeindex.
# This tag requires that the tag GENERATE_LATEX is set to YES.

LATEX_MAKEINDEX_CMD    = makeindex

# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
# documents. This may be useful for small projects and may help to save some
# trees in general.


# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
# bibliography, e.g. plainnat, or ieeetr. See
# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
# The default value is: plain.
# This tag requires that the tag GENERATE_LATEX is set to YES.



LATEX_TIMESTAMP        = NO

# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
# path from which the emoji images will be read. If a relative path is entered,
# it will be relative to the LATEX_OUTPUT directory. If left blank the
# LATEX_OUTPUT directory will be used.
# This tag requires that the tag GENERATE_LATEX is set to YES.

LATEX_EMOJI_DIRECTORY  =

#---------------------------------------------------------------------------
# Configuration options related to the RTF output
#---------------------------------------------------------------------------


RTF_HYPERLINKS         = NO

# Load stylesheet definitions from file. Syntax is similar to doxygen's
# configuration file, i.e. a series of assignments. You only have to provide
# replacements, missing definitions are set to their default value.
#
# See also section "Doxygen usage" for information on how to generate the
# default style sheet that doxygen normally uses.

RTF_STYLESHEET_FILE    =

# Set optional variables used in the generation of an RTF document. Syntax is
# similar to doxygen's configuration file. A template extensions file can be
# generated using doxygen -e rtf extensionFile.
# This tag requires that the tag GENERATE_RTF is set to YES.

RTF_EXTENSIONS_FILE    =


XML_PROGRAMLISTING     = YES

# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
# namespace members in file scope as well, matching the HTML output.
# The default value is: NO.
# This tag requires that the tag GENERATE_XML is set to YES.

XML_NS_MEMB_FILE_SCOPE = NO

#---------------------------------------------------------------------------
# Configuration options related to the DOCBOOK output
#---------------------------------------------------------------------------

#---------------------------------------------------------------------------

# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
# the structure of the code including all documentation. Note that this feature
# is still experimental and incomplete at the moment.
# The default value is: NO.

GENERATE_AUTOGEN_DEF   = NO


EXTERNAL_PAGES         = YES

# The PERL_PATH should be the absolute path and name of the perl script
# interpreter (i.e. the result of 'which perl').
# The default file (with absolute path) is: /usr/bin/perl.

PERL_PATH              = /usr/bin/perl

#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------

# The default value is: YES.

CLASS_DIAGRAMS         = YES

# You can define message sequence charts within doxygen comments using the \msc
# command. Doxygen will then run the mscgen tool (see:
# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
# documentation. The MSCGEN_PATH tag allows you to specify the directory where
# the mscgen tool resides. If left empty the tool is assumed to be found in the
# default search path.

MSCGEN_PATH            =

# You can include diagrams made with dia in doxygen documentation. Doxygen will
# then run dia to produce the diagram and insert it in the documentation. The

Lines 59-65 Link Here

(-)vis-0.6/doc/conf.py (-4 / +7 lines)
59		59
60	# General information about the project.	60	# General information about the project.
61	project = 'Vis Editor'	61	project = 'Vis Editor'
62	copyright = '2017, Marc André Tanner'	62	copyright = '2014-2020 Marc André Tanner, et al.'
63	author = 'Marc André Tanner'	63	author = 'Marc André Tanner'
64		64
65	# The version info for the project you're documenting, acts as replacement for	65	# The version info for the project you're documenting, acts as replacement for
Lines 67-75 Link Here
67	# built documents.	67	# built documents.
68	#	68	#
69	# The short X.Y version.	69	# The short X.Y version.
70	version = '0.6'	70	version = '0.8'
71	# The full version, including alpha/beta/rc tags.	71	# The full version, including alpha/beta/rc tags.
72	release = '0.6'	72	release = '0.8'
73		73
74	# The language for content autogenerated by Sphinx. Refer to documentation	74	# The language for content autogenerated by Sphinx. Refer to documentation
75	# for a list of supported languages.	75	# for a list of supported languages.
Lines 86-95 Link Here
86	# The name of the Pygments (syntax highlighting) style to use.	86	# The name of the Pygments (syntax highlighting) style to use.
87	pygments_style = 'sphinx'	87	pygments_style = 'sphinx'
88		88
		89	primary_domain = 'c'
		90	highlight_language = 'c'
		91
89	# If true, `todo` and `todoList` produce output, else they produce nothing.	92	# If true, `todo` and `todoList` produce output, else they produce nothing.
90	todo_include_todos = False	93	todo_include_todos = False
91		94
92	default_role = "any"	95	default_role = "c"
93		96
94	# -- Options for HTML output ----------------------------------------------	97	# -- Options for HTML output ----------------------------------------------
95		98




The core text management data structure which supports efficient
modifications and provides a byte string interface. Text positions
are represented as ``size_t``.  Valid addresses are in range ``[0,
text_size(txt)]``. An invalid position is denoted by ``EPOS``. Access to
the non-contigiuos pieces is available by means of an iterator interface
or a copy mechanism. Text revisions are tracked in an history graph.


.. note:: The grapheme cluster boundaries are currently not implemented
          according to `UAX#29 rules <http://unicode.org/reports/tr29>`_.
          Instead a base character followed by arbitrarily many combining
          character as reported by ``wcwidth(3)`` are skipped.

.. doxygengroup:: iterator_char
   :content-only:

all marks placed after the modification point. Reverting to an older text
state will hide all affected marks, redoing the changes will restore them.

.. warning:: Due to an optimization cached modifications (i.e. no ``text_snaphot``
             was performed between setting the mark and issuing the changes) might
             not adjust mark positions accurately.





local dq_str = l.delimited_range('"')
local ex_str = l.delimited_range('`')
local heredoc = '<<' * P(function(input, index)
  local s, e, minus, _, delimiter =
    input:find('(-?)(["\']?)([%a_][%w_]*)%2[\n\r\f;]+', index)
  if s == index and delimiter then
    -- If the starting delimiter of a here-doc begins with "-", then
    -- spaces are allowed to come before the closing delimiter.
    local close_pattern
    if minus == '-' then
      close_pattern = '[\n\r\f%s]+'..delimiter..'\n'
    else
      close_pattern = '[\n\r\f]+'..delimiter..'\n'
    end
    local _, e = input:find(close_pattern, e)
    return e and e + 1 or #input + 1
  end
end)

Lines 1-4 Link Here

(-)vis-0.6/lua/lexers/git-rebase.lua (-1 / +2 lines)
1	-- Copyright 2017 Marc André Tanner	1	-- Copyright 2017-2021 Marc André Tanner
2	-- git-rebase(1) LPeg lexer.	2	-- git-rebase(1) LPeg lexer.
3		3
4	local l = require('lexer')	4	local l = require('lexer')
Lines 22-27 Link Here
22	'f', 'fixup',	22	'f', 'fixup',
23	'x', 'exec',	23	'x', 'exec',
24	'd', 'drop',	24	'd', 'drop',
		25	'b', 'break',
25	'l', 'label',	26	'l', 'label',
26	't', 'reset',	27	't', 'reset',
27	'm', 'merge',	28	'm', 'merge',




-- Copyright 2017-2021 Marc André Tanner. See LICENSE.
-- strace(1) output lexer

local l = require('lexer')
local token, word_match = l.token, l.word_match
local S, B = lpeg.S, lpeg.B

local M = {_NAME = 'strace'}


local constant = token(l.CONSTANT, (l.upper + '_') * (l.upper + l.digit + '_')^0)
local syscall = token(l.KEYWORD, l.starts_line(l.word))
local operator = token(l.OPERATOR, S('+-/*%<>~!=^&|?~:;,.()[]{}'))
local comment = token(l.COMMENT, l.nested_pair('/*', '*/') + (l.delimited_range('()') * l.newline))
local result = token(l.TYPE, B(' = ') * l.integer)
local identifier = token(l.IDENTIFIER, l.word)

M._rules = {
  {'whitespace', ws},
  {'syscall', syscall},
  {'constant', constant},
  {'string', string},
  {'comment', comment},
  {'result', result},
  {'identifier', identifier},
  {'number', number},
  {'operator', operator},
}

Lines 13-19 Link Here

(-)vis-0.6/lua/plugins/complete-filename.lua (-1 / +1 lines)
13	local prefix = file:content(range)	13	local prefix = file:content(range)
14	if not prefix then return end	14	if not prefix then return end
15	-- Strip leading delimiters for some languages	15	-- Strip leading delimiters for some languages
16	i, j = string.find(prefix, "[[(<'\"]+")	16	local _, j = string.find(prefix, "[[(<'\"]+")
17	if j then prefix = prefix:sub(j + 1) end	17	if j then prefix = prefix:sub(j + 1) end
18	local cmd = string.format("vis-complete --file '%s'", prefix:gsub("'", "'\\''"))	18	local cmd = string.format("vis-complete --file '%s'", prefix:gsub("'", "'\\''"))
19	local status, out, err = vis:pipe(file, { start = 0, finish = 0 }, cmd)	19	local status, out, err = vis:pipe(file, { start = 0, finish = 0 }, cmd)

Lines 40-46 Link Here

(-)vis-0.6/lua/plugins/filetype.lua (-9 / +30 lines)
40	ext = { "%.awk$" },	40	ext = { "%.awk$" },
41	},	41	},
42	bash = {	42	bash = {
43	ext = { "%.bash$", "%.csh$", "%.sh$", "%.zsh$" },	43	ext = { "%.bash$", "%.csh$", "%.sh$", "%.zsh$" ,"^APKBUILD$", "%.ebuild$"},
44	mime = { "text/x-shellscript", "application/x-shellscript" },	44	mime = { "text/x-shellscript", "application/x-shellscript" },
45	},	45	},
46	batch = {	46	batch = {
Lines 149-154 Link Here
149	gap = {	149	gap = {
150	ext = { "%.g$", "%.gd$", "%.gi$", "%.gap$" },	150	ext = { "%.g$", "%.gd$", "%.gi$", "%.gap$" },
151	},	151	},
		152	gemini = {
		153	ext = { "%.gmi" },
		154	mime = { "text/gemini" },
		155	},
152	gettext = {	156	gettext = {
153	ext = { "%.po$", "%.pot$" },	157	ext = { "%.po$", "%.pot$" },
154	},	158	},
Lines 172-178 Link Here
172	ext = { "%.go$" },	176	ext = { "%.go$" },
173	},	177	},
174	groovy = {	178	groovy = {
175	ext = { "%.groovy$", "%.gvy$" },	179	ext = { "%.groovy$", "%.gvy$", "^Jenkinsfile$" },
176	},	180	},
177	gtkrc = {	181	gtkrc = {
178	ext = { "%.gtkrc$" },	182	ext = { "%.gtkrc$" },
Lines 204-210 Link Here
204	ext = { "%.bsh$", "%.java$" },	208	ext = { "%.bsh$", "%.java$" },
205	},	209	},
206	javascript = {	210	javascript = {
207	ext = { "%.js$", "%.jsfl$" },	211	ext = { "%.cjs$", "%.js$", "%.jsfl$", "%.mjs$", "%.ts$" },
208	},	212	},
209	json = {	213	json = {
210	ext = { "%.json$" },	214	ext = { "%.json$" },
Lines 227-233 Link Here
227	ext = { "%.less$" },	231	ext = { "%.less$" },
228	},	232	},
229	lilypond = {	233	lilypond = {
230	ext = { "%.lily$", "%.ly$" },	234	ext = { "%.ily$", "%.ly$" },
231	},	235	},
232	lisp = {	236	lisp = {
233	ext = { "%.cl$", "%.el$", "%.lisp$", "%.lsp$" },	237	ext = { "%.cl$", "%.el$", "%.lisp$", "%.lsp$" },
Lines 246-251 Link Here
246	makefile = {	250	makefile = {
247	ext = { "%.iface$", "%.mak$", "%.mk$", "GNUmakefile", "makefile", "Makefile" },	251	ext = { "%.iface$", "%.mak$", "%.mk$", "GNUmakefile", "makefile", "Makefile" },
248	mime = { "text/x-makefile" },	252	mime = { "text/x-makefile" },
		253	detect = function(_, data)
		254	return data:match("^#!/usr/bin/make")
		255	end
249	},	256	},
250	man = {	257	man = {
251	ext = {	258	ext = {
Lines 258-263 Link Here
258	ext = { "%.md$", "%.markdown$" },	265	ext = { "%.md$", "%.markdown$" },
259	mime = { "text/x-markdown" },	266	mime = { "text/x-markdown" },
260	},	267	},
		268	meson = {
		269	ext = { "^meson%.build$" },
		270	},
261	moonscript = {	271	moonscript = {
262	ext = { "%.moon$" },	272	ext = { "%.moon$" },
263	mime = { "text/x-moon" },	273	mime = { "text/x-moon" },
Lines 343-348 Link Here
343	rhtml = {	353	rhtml = {
344	ext = { "%.erb$", "%.rhtml$" },	354	ext = { "%.erb$", "%.rhtml$" },
345	},	355	},
		356	routeros = {
		357	ext = { "%.rsc" },
		358	detect = function(_, data)
		359	return data:match("^#.* by RouterOS")
		360	end
		361	},
346	rstats = {	362	rstats = {
347	ext = { "%.R$", "%.Rout$", "%.Rhistory$", "%.Rt$", "Rout.save", "Rout.fail" },	363	ext = { "%.R$", "%.Rout$", "%.Rhistory$", "%.Rt$", "Rout.save", "Rout.fail" },
348	},	364	},
Lines 363-369 Link Here
363	mime = { "text/x-scala" },	379	mime = { "text/x-scala" },
364	},	380	},
365	scheme = {	381	scheme = {
366	ext = { "%.sch$", "%.scm$", "%.sld$", "%.sls$", "%.ss$" },	382	ext = { "%.rkt$", "%.sch$", "%.scm$", "%.sld$", "%.sls$", "%.ss$" },
367	},	383	},
368	smalltalk = {	384	smalltalk = {
369	ext = { "%.changes$", "%.st$", "%.sources$" },	385	ext = { "%.changes$", "%.st$", "%.sources$" },
Lines 381-387 Link Here
381	ext = { "%.ddl$", "%.sql$" },	397	ext = { "%.ddl$", "%.sql$" },
382	},	398	},
383	strace = {	399	strace = {
384	detect = function(file, data)	400	detect = function(_, data)
385	return data:match("^execve%(")	401	return data:match("^execve%(")
386	end	402	end
387	},	403	},
Lines 403-409 Link Here
403	},	419	},
404	text = {	420	text = {
405	ext = { "%.txt$" },	421	ext = { "%.txt$" },
406	mime = { "text/plain" },	422	-- Do not list mime "text/plain" here, it is covered below,
		423	-- see 'try text lexer as a last resort'
407	},	424	},
408	toml = {	425	toml = {
409	ext = { "%.toml$" },	426	ext = { "%.toml$" },
Lines 422-428 Link Here
422	ext = { "%.vcf$", "%.vcard$" },	439	ext = { "%.vcf$", "%.vcard$" },
423	},	440	},
424	verilog = {	441	verilog = {
425	ext = { "%.v$", "%.ver$" },	442	ext = { "%.v$", "%.ver$", "%.sv$" },
426	},	443	},
427	vhdl = {	444	vhdl = {
428	ext = { "%.vh$", "%.vhd$", "%.vhdl$" },	445	ext = { "%.vh$", "%.vhd$", "%.vhdl$" },
Lines 443-448 Link Here
443	ext = { "%.yaml$", "%.yml$" },	460	ext = { "%.yaml$", "%.yml$" },
444	mime = { "text/x-yaml" },	461	mime = { "text/x-yaml" },
445	},	462	},
		463	zig = {
		464	ext = { "%.zig$" },
		465	},
446	}	466	}
447		467
448	vis.events.subscribe(vis.events.WIN_OPEN, function(win)	468	vis.events.subscribe(vis.events.WIN_OPEN, function(win)
Lines 484-493 Link Here
484	end	504	end
485		505
486	-- run file(1) to determine mime type	506	-- run file(1) to determine mime type
		507	local mime
487	if name ~= nil then	508	if name ~= nil then
488	local file = io.popen(string.format("file -bL --mime-type -- '%s'", name:gsub("'", "'\\''")))	509	local file = io.popen(string.format("file -bL --mime-type -- '%s'", name:gsub("'", "'\\''")))
489	if file then	510	if file then
490	local mime = file:read('*all')	511	mime = file:read('*all')
491	file:close()	512	file:close()
492	if mime then	513	if mime then
493	mime = mime:gsub('%s*$', '')	514	mime = mime:gsub('%s*$', '')




-- Checks whether a subsequent @{require} call will succeed.
-- @tparam string name the module name to check
-- @treturn bool whether the module was found
vis.module_exist = function(_, name)
	for _, searcher in ipairs(package.searchers or package.loaders) do
		local loader = searcher(name)
		if type(loader) == 'function' then

	WIN_HIGHLIGHT = "Event::WIN_HIGHLIGHT", -- see @{win_highlight}
	WIN_OPEN = "Event::WIN_OPEN", -- see @{win_open}
	WIN_STATUS = "Event::WIN_STATUS", -- see @{win_status}
	TERM_CSI = "Event::TERM_CSI", -- see @{term_csi}
}

events.file_close = function(...) events.emit(events.FILE_CLOSE, ...) end

events.win_highlight = function(...) events.emit(events.WIN_HIGHLIGHT, ...) end
events.win_open = function(...) events.emit(events.WIN_OPEN, ...) end
events.win_status = function(...) events.emit(events.WIN_STATUS, ...) end
events.term_csi = function(...) events.emit(events.TERM_CSI, ...) end

local handlers = {}





static const char *selections_remove_column_except(Vis*, const char *keys, const Arg *arg);
/* move to the previous (arg->i < 0) or next (arg->i > 0) selection */
static const char *selections_navigate(Vis*, const char *keys, const Arg *arg);
/* select the word the selection is currently over */
static const char *selections_match_word(Vis*, const char *keys, const Arg *arg);
/* select the next region matching the current selection */
static const char *selections_match_next(Vis*, const char *keys, const Arg *arg);
/* clear current selection but select next match */

static const char *selections_complement(Vis*, const char *keys, const Arg *arg);
/* subtract selections from mark */
static const char *selections_minus(Vis*, const char *keys, const Arg *arg);
/* pairwise combine selections from mark */
static const char *selections_combine(Vis*, const char *keys, const Arg *arg);
static Filerange combine_union(const Filerange*, const Filerange*);
static Filerange combine_intersect(const Filerange*, const Filerange*);
static Filerange combine_longer(const Filerange*, const Filerange*);
static Filerange combine_shorter(const Filerange*, const Filerange*);
static Filerange combine_leftmost(const Filerange*, const Filerange*);
static Filerange combine_rightmost(const Filerange*, const Filerange*);
/* adjust current used count according to keys */
static const char *count(Vis*, const char *keys, const Arg *arg);
/* move to the count-th line or if not given either to the first (arg->i < 0)

/* make the current action use the operator indicated by arg->i */
static const char *operator(Vis*, const char *keys, const Arg *arg);
/* blocks to read a key and performs movement indicated by arg->i which
 * should be one of VIS_MOVE_{TO,TILL}_{,LINE}_{RIGHT,LEFT}*/
static const char *movement_key(Vis*, const char *keys, const Arg *arg);
/* perform the movement as indicated by arg->i */
static const char *movement(Vis*, const char *keys, const Arg *arg);

	VIS_ACTION_PROMPT_SEARCH_BACKWARD,
	VIS_ACTION_TILL_LEFT,
	VIS_ACTION_TILL_RIGHT,
	VIS_ACTION_TILL_LINE_LEFT,
	VIS_ACTION_TILL_LINE_RIGHT,
	VIS_ACTION_TO_LEFT,
	VIS_ACTION_TO_RIGHT,
	VIS_ACTION_TO_LINE_LEFT,
	VIS_ACTION_TO_LINE_RIGHT,
	VIS_ACTION_REGISTER,
	VIS_ACTION_OPERATOR_CHANGE,
	VIS_ACTION_OPERATOR_DELETE,

	VIS_ACTION_WINDOW_SLIDE_DOWN,
	VIS_ACTION_PUT_AFTER,
	VIS_ACTION_PUT_BEFORE,
	VIS_ACTION_SELECTIONS_MATCH_WORD,
	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE,
	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE_FIRST,
	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW,
	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW_LAST,
	VIS_ACTION_SELECTIONS_NEW_LINES_BEGIN,
	VIS_ACTION_SELECTIONS_NEW_LINES_END,
	VIS_ACTION_SELECTIONS_NEW_MATCH_ALL,
	VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT,
	VIS_ACTION_SELECTIONS_NEW_MATCH_SKIP,
	VIS_ACTION_SELECTIONS_ALIGN,

	VIS_ACTION_SELECTIONS_INTERSECT,
	VIS_ACTION_SELECTIONS_COMPLEMENT,
	VIS_ACTION_SELECTIONS_MINUS,
	VIS_ACTION_SELECTIONS_COMBINE_UNION,
	VIS_ACTION_SELECTIONS_COMBINE_INTERSECT,
	VIS_ACTION_SELECTIONS_COMBINE_LONGER,
	VIS_ACTION_SELECTIONS_COMBINE_SHORTER,
	VIS_ACTION_SELECTIONS_COMBINE_LEFTMOST,
	VIS_ACTION_SELECTIONS_COMBINE_RIGHTMOST,
	VIS_ACTION_TEXT_OBJECT_WORD_OUTER,
	VIS_ACTION_TEXT_OBJECT_WORD_INNER,
	VIS_ACTION_TEXT_OBJECT_LONGWORD_OUTER,

	VIS_ACTION_TEXT_OBJECT_SINGLE_QUOTE_INNER,
	VIS_ACTION_TEXT_OBJECT_BACKTICK_OUTER,
	VIS_ACTION_TEXT_OBJECT_BACKTICK_INNER,
	VIS_ACTION_TEXT_OBJECT_ENTIRE_OUTER,
	VIS_ACTION_TEXT_OBJECT_ENTIRE_INNER,
	VIS_ACTION_TEXT_OBJECT_LINE_OUTER,
	VIS_ACTION_TEXT_OBJECT_LINE_INNER,
	VIS_ACTION_TEXT_OBJECT_INDENTATION,

	[VIS_ACTION_TILL_LEFT] = {
		"vis-motion-till-left",
		VIS_HELP("Till after the occurrence of character to the left")
		movement_key, { .i = VIS_MOVE_TILL_LEFT }
	},
	[VIS_ACTION_TILL_RIGHT] = {
		"vis-motion-till-right",
		VIS_HELP("Till before the occurrence of character to the right")
		movement_key, { .i = VIS_MOVE_TILL_RIGHT }
	},
	[VIS_ACTION_TILL_LINE_LEFT] = {
		"vis-motion-till-line-left",
		VIS_HELP("Till after the occurrence of character to the left on the current line")
		movement_key, { .i = VIS_MOVE_TILL_LINE_LEFT }
	},
	[VIS_ACTION_TILL_LINE_RIGHT] = {
		"vis-motion-till-line-right",
		VIS_HELP("Till before the occurrence of character to the right on the current line")
		movement_key, { .i = VIS_MOVE_TILL_LINE_RIGHT }
	},
	[VIS_ACTION_TO_LEFT] = {
		"vis-motion-to-left",
		VIS_HELP("To the first occurrence of character to the left")
		movement_key, { .i = VIS_MOVE_TO_LEFT }
	},
	[VIS_ACTION_TO_RIGHT] = {
		"vis-motion-to-right",
		VIS_HELP("To the first occurrence of character to the right")
		movement_key, { .i = VIS_MOVE_TO_RIGHT }
	},
	[VIS_ACTION_TO_LINE_LEFT] = {
		"vis-motion-to-line-left",
		VIS_HELP("To the first occurrence of character to the left on the current line")
		movement_key, { .i = VIS_MOVE_TO_LINE_LEFT }
	},
	[VIS_ACTION_TO_LINE_RIGHT] = {
		"vis-motion-to-line-right",
		VIS_HELP("To the first occurrence of character to the right on the current line")
		movement_key, { .i = VIS_MOVE_TO_LINE_RIGHT }
	},
	[VIS_ACTION_REGISTER] = {
		"vis-register",
		VIS_HELP("Use given register for next operator")

		VIS_HELP("Put text before the cursor")
		operator, { .i = VIS_OP_PUT_BEFORE }
	},
	[VIS_ACTION_SELECTIONS_MATCH_WORD] = {
		"vis-selections-select-word",
		VIS_HELP("Select word under cursor")
		selections_match_word,
	},
	[VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE] = {
		"vis-selection-new-lines-above",
		VIS_HELP("Create a new selection on the line above")

		VIS_HELP("Create a new selection at the end of every line covered by selection")
		operator, { .i = VIS_OP_CURSOR_EOL }
	},
	[VIS_ACTION_SELECTIONS_NEW_MATCH_ALL] = {
		"vis-selection-new-match-all",
		VIS_HELP("Select all regions matching the current selection")
		selections_match_next, { .b = true }
	},
	[VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT] = {
		"vis-selection-new-match-next",
		VIS_HELP("Select the next region matching the current selection")

		VIS_HELP("Subtract selections from mark")
		selections_minus
	},
	[VIS_ACTION_SELECTIONS_COMBINE_UNION] = {
		"vis-selections-combine-union",
		VIS_HELP("Pairwise union with selections from mark")
		selections_combine, { .combine = combine_union }
	},
	[VIS_ACTION_SELECTIONS_COMBINE_INTERSECT] = {
		"vis-selections-combine-intersect",
		VIS_HELP("Pairwise intersect with selections from mark")
		selections_combine, { .combine = combine_intersect }
	},
	[VIS_ACTION_SELECTIONS_COMBINE_LONGER] = {
		"vis-selections-combine-longer",
		VIS_HELP("Pairwise combine: take longer")
		selections_combine, { .combine = combine_longer }
	},
	[VIS_ACTION_SELECTIONS_COMBINE_SHORTER] = {
		"vis-selections-combine-shorter",
		VIS_HELP("Pairwise combine: take shorter")
		selections_combine, { .combine = combine_shorter }
	},
	[VIS_ACTION_SELECTIONS_COMBINE_LEFTMOST] = {
		"vis-selections-combine-leftmost",
		VIS_HELP("Pairwise combine: leftmost")
		selections_combine, { .combine = combine_leftmost }
	},
	[VIS_ACTION_SELECTIONS_COMBINE_RIGHTMOST] = {
		"vis-selections-combine-rightmost",
		VIS_HELP("Pairwise combine: rightmost")
		selections_combine, { .combine = combine_rightmost }
	},
	[VIS_ACTION_TEXT_OBJECT_WORD_OUTER] = {
		"vis-textobject-word-outer",
		VIS_HELP("A word leading and trailing whitespace included")

		VIS_HELP("A backtick delimited string (inner variant)")
		textobj, { .i = VIS_TEXTOBJECT_INNER_BACKTICK }
	},
	[VIS_ACTION_TEXT_OBJECT_ENTIRE_OUTER] = {
		"vis-textobject-entire-outer",
		VIS_HELP("The whole text content")
		textobj, { .i = VIS_TEXTOBJECT_OUTER_ENTIRE }
	},
	[VIS_ACTION_TEXT_OBJECT_ENTIRE_INNER] = {
		"vis-textobject-entire-inner",
		VIS_HELP("The whole text content, except for leading and trailing empty lines")
		textobj, { .i = VIS_TEXTOBJECT_INNER_ENTIRE }
	},
	[VIS_ACTION_TEXT_OBJECT_LINE_OUTER] = {
		"vis-textobject-line-outer",
		VIS_HELP("The whole line")

	return keys;
}

static Selection *selection_new(View *view, Filerange *r, bool isprimary) {
	Text *txt = vis_text(vis);
	View *view = vis_view(vis);
	for (Selection *s = view_selections(view); s; s = view_selections_next(s)) {
		Filerange word = text_object_word(txt, view_cursors_pos(s));
		if (text_range_valid(&word))
			view_selections_set(s, &word);
	}
	vis_mode_switch(vis, VIS_MODE_VISUAL);
	return keys;
}

static const Selection *selection_new_primary(View *view, Filerange *r) {
	Text *txt = view_text(view);
	size_t pos = text_char_prev(txt, r->end);
	Selection *s = view_selections_new(view, pos);

		return NULL;
	view_selections_set(s, r);
	view_selections_anchor(s, true);
	if (isprimary)
		view_selections_primary_set(s);
	return s;
}

static const char *selections_match_next_literal(Vis *vis, const char *keys, const Arg *arg) {
	Text *txt = vis_text(vis);
	View *view = vis_view(vis);
	Selection *s = view_selections_primary_get(view);
	Filerange sel = view_selections_get(s);
	size_t len = text_range_size(&sel);
	if (!len)
		return keys;

	char *buf = text_bytes_alloc0(txt, sel.start, len);
	if (!buf)
		return keys;

	size_t start = text_find_next(txt, sel.end, buf);
	Filerange match = text_range_new(start, start+len);
	if (start != sel.end && selection_new_primary(view, &match))
		goto out;

	sel = view_selections_get(view_selections(view));
	start = text_find_prev(txt, sel.start, buf);
	if (start == sel.start)
		goto out;

	match = text_range_new(start, start+len);
	selection_new_primary(view, &match);

out:
	free(buf);
	return keys;
}

static const char *selections_match_next(Vis *vis, const char *keys, const Arg *arg) {
	Text *txt = vis_text(vis);
	View *view = vis_view(vis);

	if (!text_range_valid(&sel))
		return keys;

	static bool match_word;
	if (!text_range_equal(&sel, &word))
		return selections_match_next_literal(vis, keys, arg);

	if (view_selections_count(view) == 1) {
		Filerange word = text_object_word(txt, view_cursors_pos(s));
		match_word = text_range_equal(&sel, &word);
	}

	Filerange (*find_next)(Text *, size_t, const char *) = text_object_word_find_next;
	Filerange (*find_prev)(Text *, size_t, const char *) = text_object_word_find_prev;
	if (!match_word) {
		find_next = text_object_find_next;
		find_prev = text_object_find_prev;
	}

	char *buf = text_bytes_alloc0(txt, sel.start, text_range_size(&sel));
	if (!buf)
		return keys;

	bool match_all = arg->b;
	Filerange primary = sel;
		goto out;

	for (;;) {
		sel = find_next(txt, sel.end, buf);
		if (!text_range_valid(&sel))
			break;
		if (selection_new(view, &sel, !match_all) && !match_all)
			goto out;
	}

	sel = primary;

	for (;;) {
		sel = find_prev(txt, sel.start, buf);
		if (!text_range_valid(&sel))
			break;
		if (selection_new(view, &sel, !match_all) && !match_all)
			break;
	}

out:
	free(buf);
	return keys;

	return keys;
}

static Filerange combine_union(const Filerange *r1, const Filerange *r2) {
	if (!r1)
		return *r2;
	if (!r2)
		return *r1;
	return text_range_union(r1, r2);
}

static Filerange combine_intersect(const Filerange *r1, const Filerange *r2) {
	if (!r1 || !r2)
		return text_range_empty();
	return text_range_intersect(r1, r2);
}

static Filerange combine_longer(const Filerange *r1, const Filerange *r2) {
	if (!r1)
		return *r2;
	if (!r2)
		return *r1;
	size_t l1 = text_range_size(r1);
	size_t l2 = text_range_size(r2);
	return l1 < l2 ? *r2 : *r1;
}

static Filerange combine_shorter(const Filerange *r1, const Filerange *r2) {
	if (!r1)
		return *r2;
	if (!r2)
		return *r1;
	size_t l1 = text_range_size(r1);
	size_t l2 = text_range_size(r2);
	return l1 < l2 ? *r1 : *r2;
}

static Filerange combine_leftmost(const Filerange *r1, const Filerange *r2) {
	if (!r1)
		return *r2;
	if (!r2)
		return *r1;
	return r1->start < r2->start || (r1->start == r2->start && r1->end < r2->end) ? *r1 : *r2;
}

static Filerange combine_rightmost(const Filerange *r1, const Filerange *r2) {
	if (!r1)
		return *r2;
	if (!r2)
		return *r1;
	return r1->start < r2->start || (r1->start == r2->start && r1->end < r2->end) ? *r2 : *r1;
}

static const char *selections_combine(Vis *vis, const char *keys, const Arg *arg) {
	Win *win = vis_window(vis);
	View *view = vis_view(vis);
	enum VisMark mark = vis_mark_used(vis);
	Array a = view_selections_get_all(view);
	Array b = vis_mark_get(win, mark);
	Array sel;
	array_init_from(&sel, &a);

	Filerange *r1 = array_get(&a, 0), *r2 = array_get(&b, 0);
	for (size_t i = 0, j = 0; r1 || r2; r1 = array_get(&a, ++i), r2 = array_get(&b, ++j)) {
		Filerange new = arg->combine(r1, r2);
		if (text_range_valid(&new))
			array_add(&sel, &new);
	}

	vis_mark_normalize(&sel);
	selections_set(vis, view, &sel);
	vis_cancel(vis);

	array_release(&a);
	array_release(&b);
	array_release(&sel);

	return keys;
}

static const char *replace(Vis *vis, const char *keys, const Arg *arg) {
	if (!keys[0]) {
		vis_keymap_disable(vis);

			vis_motion(vis, VIS_MOVE_LINE_BEGIN);
			vis_keys_feed(vis, "<vis-motion-line-begin>");
		}
		vis_keys_feed(vis, "<Enter><vis-motion-line-up>");
	}
	return keys;
}

		.win_close = vis_lua_win_close,
		.win_highlight = vis_lua_win_highlight,
		.win_status = vis_lua_win_status,
		.term_csi = vis_lua_term_csi,
	};

	vis = vis_new(ui_term_new(), &event);

Lines 12-20 Link Here

(-)vis-0.6/man/vis-clipboard.1 (+4 lines)
12	.Pp	12	.Pp
13	.Nm vis-clipboard	13	.Nm vis-clipboard
14	.Fl -copy	14	.Fl -copy
		15	.Op Fl -selection Ar selection
15	.Pp	16	.Pp
16	.Nm vis-clipboard	17	.Nm vis-clipboard
17	.Fl -paste	18	.Fl -paste
		19	.Op Fl -selection Ar selection
18	.	20	.
19	.Sh DESCRIPTION	21	.Sh DESCRIPTION
20	.Nm vis-clipboard	22	.Nm vis-clipboard
Lines 50-55 Link Here
50	.Nm vis-clipboard	52	.Nm vis-clipboard
51	reads the content of the system clipboard,	53	reads the content of the system clipboard,
52	and writes it to standard output.	54	and writes it to standard output.
		55	.It Fl -selection Ar selection
		56	specify which selection to use, options are "primary" or "clipboard"
53	.El	57	.El
54	.	58	.
55	.Sh ENVIRONMENT	59	.Sh ENVIRONMENT

Lines 123-129 Link Here

(-)vis-0.6/man/vis.1 (-33 / +29 lines)
123	.Ss Marks	123	.Ss Marks
124	.	124	.
125	A mark associates a symbolic name to a set of selections.	125	A mark associates a symbolic name to a set of selections.
126	A stored selection becomes invalid when its delimiting boundaries changes	126	A stored selection becomes invalid when its delimiting boundaries change
127	in the underlying buffer.	127	in the underlying buffer.
128	If said changes are later undone the mark becomes valid again.	128	If said changes are later undone the mark becomes valid again.
129	.Ic m	129	.Ic m
Lines 769-784 Link Here
769	.	769	.
770	.Ss Operators	770	.Ss Operators
771	.	771	.
772	Operators perform a certain operation an a text range indicated by either a	772	Operators perform a certain operation on a text range indicated by either a
773	motion, a text object or an existing selection.	773	motion, a text object or an existing selection.
774	.Pp	774	.Pp
		775	When used in normal mode, the following operators wait for a motion, putting
		776	vis into operator pending mode.
775	.Bl -tag -width XXXXXXXXXX -compact	777	.Bl -tag -width XXXXXXXXXX -compact
776	.It Ic c	778	.It Ic c
777	change, delete range and enter insert mode	779	change, delete range and enter insert mode
778	.	780	.
779	.It Ic d	781	.It Ic d
780	delete range	782	delete, cut range to register
781	.	783	.
		784	.It Ic <
		785	shift-left, decrease indent
		786	.
		787	.It Ic >
		788	shift-right, increase indent
		789	.
		790	.It Ic y
		791	yank, copy range to register
		792	.El
		793	.Pp
		794	When used in normal mode, the following actions take effect immediately.
		795	.Bl -tag -width XXXXXXXXXX -compact
782	.It Ic =	796	.It Ic =
783	format, filter range through	797	format, filter range through
784	.Xr fmt 1	798	.Xr fmt 1
Lines 789-794 Link Here
789	.It Ic gU	803	.It Ic gU
790	make uppercase	804	make uppercase
791	.	805	.
		806	.It Ic g~
		807	swap case
		808	.
792	.It Ic J	809	.It Ic J
793	join lines, insert spaces in between	810	join lines, insert spaces in between
794	.	811	.
Lines 796-814 Link Here
796	join lines remove any delimiting white spaces	813	join lines remove any delimiting white spaces
797	.	814	.
798	.It Ic p	815	.It Ic p
799	put, insert register content	816	put register content after cursor
800	.	817	.
801	.It Ic <	818	.It Ic P
802	shift-left, decrease indent	819	put register content before cursor
803	.	820	.
804	.It Ic >
805	shift-right, increase indent
806	.
807	.It Ic ~
808	swap case
809	.
810	.It Ic y
811	yank, copy range to register
812	.El	821	.El
813	.	822	.
814	.Ss Motions	823	.Ss Motions
Lines 1026-1037 Link Here
1026	.It Ic gN	1035	.It Ic gN
1027	matches the last used search term in backward direction	1036	matches the last used search term in backward direction
1028	.	1037	.
1029	.It Ic ae
1030	entire file content
1031	.
1032	.It Ic ie
1033	entire file content except for leading and trailing empty lines
1034	.
1035	.It Ic al	1038	.It Ic al
1036	current line	1039	current line
1037	.	1040	.
Lines 1103-1108 Link Here
1103	.It Aq Ic S-Tab	1106	.It Aq Ic S-Tab
1104	right align selections by inserting spaces	1107	right align selections by inserting spaces
1105	.	1108	.
		1109	.It Aq Ic C-a
		1110	create new selections everywhere matching current word or selection
		1111	.
1106	.It Aq Ic C-n	1112	.It Aq Ic C-n
1107	create new selection and select next word matching current selection	1113	create new selection and select next word matching current selection
1108	.	1114	.
Lines 1160-1179 Link Here
1160	set intersection	1166	set intersection
1161	.It Ic \e	1167	.It Ic \e
1162	set minus	1168	set minus
1163	.It Ic \&!	1169	.It Ic ~
1164	set complement	1170	set complement
1165	.It Ic z\&\|
1166	pairwise union
1167	.It Ic z&
1168	pairwise intersection
1169	.It Ic z+
1170	pairwise combine, choose longer
1171	.It Ic z-
1172	pairwise combine, choose shorter
1173	.It Ic z<
1174	pairwise combine, choose leftmost
1175	.It Ic z>
1176	pairwise combine, choose rightmost
1177	.El	1171	.El
1178	.	1172	.
1179	.Sh VI(M) COMMANDS	1173	.Sh VI(M) COMMANDS
Lines 1427-1432 Link Here
1427	WARNING: modifying a memory mapped file in-place will cause data loss.	1421	WARNING: modifying a memory mapped file in-place will cause data loss.
1428	.It Ic layout Op Do v Dc or Do h Dc	1422	.It Ic layout Op Do v Dc or Do h Dc
1429	Whether to use vertical or horizontal layout.	1423	Whether to use vertical or horizontal layout.
		1424	.It Cm ignorecase , Cm ic Op Cm off
		1425	Whether to ignore case when searching.
1430	.El	1426	.El
1431	.	1427	.
1432	.Sh COMMAND and SEARCH PROMPT	1428	.Sh COMMAND and SEARCH PROMPT




	return !map_empty(map_prefix(map, prefix));
}

static bool leaf(const char *key, void *value, void *data)
{
	int *nodes = data;
	return (*nodes)++ < 1;
}

bool map_leaf(const Map *map, const char *prefix)
{
	int nodes = 0;
	map_iterate(map_prefix(map, prefix), leaf, &nodes);
	return nodes == 1;
}

bool map_put(Map *map, const char *k, const void *value)
{
	size_t len = strlen(k);

Lines 35-45 Link Here

(-)vis-0.6/map.h (-5 lines)
35	*/	35	*/
36	bool map_contains(const Map, const char prefix);	36	bool map_contains(const Map, const char prefix);
37	/**	37	/**
38	* Check whether the given prefix can be extended to exactly one map element.
39	* True iff the prefix map contains exactly one element.
40	*/
41	bool map_leaf(const Map, const char prefix);
42	/**
43	* Store a key value pair in the map.	38	* Store a key value pair in the map.
44	* @return False if we run out of memory (``errno = ENOMEM``), or if the key	39	* @return False if we run out of memory (``errno = ENOMEM``), or if the key
45	* already appears in the map (``errno = EEXIST``).	40	* already appears in the map (``errno = EEXIST``).




 * Heavily inspired (and partially based upon) the X11 version of
 * Rob Pike's sam text editor originally written for Plan 9.
 *
 *  Copyright © 2016-2020 Marc André Tanner <mat at brain-dump.org>
 *  Copyright © 1998 by Lucent Technologies
 *
 * Permission to use, copy, modify, and distribute this software for any

#include <errno.h>
#include <unistd.h>
#include <limits.h>
#include <fcntl.h>
#include "sam.h"
#include "vis-core.h"
#include "buffer.h"


static const CommandDef cmds[] = {
	//      name            help
	//      flags, default command, implementation
	{
		"a",            VIS_HELP("Append text after range")
		CMD_TEXT, NULL, cmd_append

	const char *names[3];            /* name and optional alias */
	enum VisOption flags;            /* option type, etc. */
	VIS_HELP_DECL(const char *help;) /* short, one line help text */
	VisOptionFunction *func;         /* option handler, NULL for builtins */
	void *context;                   /* context passed to option handler function */
} OptionDef;


	OPTION_LOAD_METHOD,
	OPTION_CHANGE_256COLORS,
	OPTION_LAYOUT,
	OPTION_IGNORECASE,
};

static const OptionDef options[] = {

		VIS_OPTION_TYPE_STRING,
		VIS_HELP("Vertical or horizontal window layout")
	},
	[OPTION_IGNORECASE] = {
		{ "ignorecase", "ic" },
		VIS_OPTION_TYPE_BOOL,
		VIS_HELP("Ignore case when searching")
	},
};

bool sam_init(Vis *vis) {

	size_t start = range->start, end = range->end, line;
	if (sign > 0) {
		char c;
		if (start < end && text_byte_get(txt, end-1, &c) && c == '\n')
			end--;
		line = text_lineno_by_pos(txt, end);
		line = text_pos_by_lineno(txt, line + offset);

	Text *txt = win->file->text;

	if (cmd->regex) {
		size_t start = range->start, end = range->end;
		size_t last_start = argv[0][0] == 'x' ? EPOS : start;
		size_t nsub = 1 + text_regex_nsub(cmd->regex);
		if (nsub > MAX_REGEX_SUB)
			nsub = MAX_REGEX_SUB;
		RegexMatch match[MAX_REGEX_SUB];
		while (start <= end) {
			trailing_match = false;
			char c;
			int flags = start > range->start &&
			            text_byte_get(txt, start - 1, &c) && c != '\n' ?

				if (argv[0][0] == 'x')
					r = text_range_new(match[0].start, match[0].end);
				else
					r = text_range_new(last_start, match[0].start);
				if (match[0].start == match[0].end) {
					if (last_start == match[0].start) {
						start++;

					 * matches the zero-length string immediately after a
					 * newline. Try filtering out the last such match at EOF.
					 */
					if (end == match[0].start && start > range->start &&
					    text_byte_get(txt, end-1, &c) && c == '\n')
						break;
					start = match[0].end + 1;
				} else {
					start = match[0].end;
				}
				start = match[0].end;
				if (start == end)
					trailing_match = true;
			} else {
				if (argv[0][0] == 'y')
					r = text_range_new(start, end);
				start = end + 1;
			}

			if (text_range_valid(&r)) {

						Register *reg = &vis->registers[VIS_REG_AMPERSAND+i];
						register_put_range(vis, reg, txt, &match[i]);
					}
					last_start = match[0].end;
				} else {
					last_start = start;
				}
				if (simulate)
					count++;
				else
					ret &= sam_execute(vis, win, cmd->cmd, NULL, &r);
				last_start = start;
			}
		}
	} else {

		if (write_entire_file)
			*r = text_range_new(0, text_size(text));

		TextSave *ctx = text_save_begin(text, AT_FDCWD, path, file->save_method);
		if (!ctx) {
			const char *msg = errno ? strerror(errno) : "try changing `:set savemethod`";
			vis_info_show(vis, "Can't write `%s': %s", path, msg);

Lines 287-292 Link Here

(-)vis-0.6/text-motions.c (+2 lines)
287	size_t text_line_down(Text *txt, size_t pos) {	287	size_t text_line_down(Text *txt, size_t pos) {
288	int width = text_line_width_get(txt, pos);	288	int width = text_line_width_get(txt, pos);
289	size_t next = text_line_next(txt, pos);	289	size_t next = text_line_next(txt, pos);
		290	if (next == text_size(txt))
		291	return pos;
290	return text_line_width_set(txt, next, width);	292	return text_line_width_set(txt, next, width);
291	}	293	}
292		294




#ifndef TEXT_MOTIONS_H
#define TEXT_MOTIONS_H

/* these functions all take a position in bytes from the start of the file,
 * perform a certain movement and return the new postion. If the movement
 * is not possible the original position is returned unchanged. */

#include <stddef.h>

size_t text_codepoint_prev(Text*, size_t pos);

/* find the given substring either in forward or backward direction.
 * does not wrap around at file start / end. If no match is found return
 * original position */
size_t text_find_next(Text*, size_t pos, const char *s);
size_t text_find_prev(Text*, size_t pos, const char *s);

/*
 * A longword consists of a sequence of non-blank characters, separated with
 * white space. TODO?: An empty line is also considered to be a word.
 * This is equivalent to a WORD in vim terminology.
 */
size_t text_longword_end_next(Text*, size_t pos);
size_t text_longword_end_prev(Text*, size_t pos);

 * A word consists of a sequence of letters, digits and underscores, or a
 * sequence of other non-blank characters, separated with white space.
 * TODO?: An empty line is also considered to be a word.
 * This is equivalent to a word (lowercase) in vim terminology.
 */
size_t text_word_end_next(Text*, size_t pos);
size_t text_word_end_prev(Text*, size_t pos);

size_t text_block_end(Text*, size_t pos);
size_t text_parenthesis_start(Text*, size_t pos);
size_t text_parenthesis_end(Text*, size_t pos);
/* search corresponding '(', ')', '{', '}', '[', ']', '>', '<', '"', ''' */
size_t text_bracket_match(Text*, size_t pos, const Filerange *limits);
/* same as above but explicitly specify symbols to match */
size_t text_bracket_match_symbol(Text*, size_t pos, const char *symbols, const Filerange *limits);

/* search the given regex pattern in either forward or backward direction,
 * starting from pos. Does wrap around if no match was found. */
size_t text_search_forward(Text *txt, size_t pos, Regex *regex);
size_t text_search_backward(Text *txt, size_t pos, Regex *regex);





	return text_range_new(0, text_size(txt));
}

Filerange text_object_entire_inner(Text *txt, size_t pos) {
	char c;
	Filerange r = text_object_entire(txt, pos);
	Iterator it = text_iterator_get(txt, r.start);
	if (text_iterator_byte_get(&it, &c) && c == '\n')
		while (text_iterator_byte_next(&it, &c) && c == '\n');
	r.start = it.pos;
	it = text_iterator_get(txt, r.end);
	while (text_iterator_char_prev(&it, &c) && c == '\n');
	r.end = it.pos;
	return text_range_linewise(txt, &r);
}

static Filerange text_object_customword(Text *txt, size_t pos, int (*isboundary)(int)) {
	Filerange r;
	char c, prev = '0', next = '0';

	if (space(c)) {
		r.start = text_char_next(txt, text_customword_end_prev(txt, pos, isboundary));
		r.end = text_customword_start_next(txt, pos, isboundary);
	} else if (boundary(c)) {
		if (boundary(prev) && !space(prev))
			r.start = text_customword_start_prev(txt, pos, isboundary);
		else
		} else {
			/* on a single character */
			r.start = pos;

		if (boundary(next) && !space(next))
			r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
		else
			r.end = text_char_next(txt, pos);
		}
	} else if (boundary(prev)) {
		/* at start of a word */
		r.start = pos;
		r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
	} else if (boundary(next)) {
		/* at end of a word */
		r.start = text_customword_start_prev(txt, pos, isboundary);
		r.end = text_char_next(txt, pos);
	} else {
		if (boundary(prev))
			r.start = pos;
		else
			r.start = text_customword_start_prev(txt, pos, isboundary);

		if (boundary(next))
			r.end = text_char_next(txt, pos);
		else
			r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
	}

	return r;

			return text_range_empty();
		}
	}
}

Filerange text_object_find_next(Text *txt, size_t pos, const char *search) {
	size_t start = text_find_next(txt, pos, search);
	if (start == pos)
		return text_range_empty();
	return text_range_new(start, start+strlen(search));
}

Filerange text_object_find_prev(Text *txt, size_t pos, const char *search) {
	size_t start = text_find_prev(txt, pos, search);
	if (start == pos)
		return text_range_empty();
	return text_range_new(start, start+strlen(search));
}

Filerange text_object_line(Text *txt, size_t pos) {




#ifndef TEXT_OBJECTS_H
#define TEXT_OBJECTS_H

/* these functions all take a file position. If this position is part of the
 * respective text-object, a corresponding range is returned. If there is no
 * such text-object at the given location, an empty range is returned.
 */



/* return range covering the entire text */
Filerange text_object_entire(Text*, size_t pos);
/* entire document except leading and trailing empty lines */
Filerange text_object_entire_inner(Text*, size_t pos);
/* word which happens to be at pos without any neighbouring white spaces */
Filerange text_object_word(Text*, size_t pos);
/* includes trailing white spaces. If at pos happens to be a white space
 * include all neighbouring leading white spaces and the following word. */
Filerange text_object_word_outer(Text*, size_t pos);
/* find next occurence of `word' (as word not substring) in forward/backward direction */
Filerange text_object_word_find_next(Text*, size_t pos, const char *word);
Filerange text_object_word_find_prev(Text*, size_t pos, const char *word);
/* find next occurence of a literal string (not regex) in forward/backward direction */
Filerange text_object_find_next(Text *txt, size_t pos, const char *search);
Filerange text_object_find_prev(Text *txt, size_t pos, const char *search);
/* same semantics as above but for a longword (i.e. delimited by white spaces) */
Filerange text_object_longword(Text*, size_t pos);
Filerange text_object_longword_outer(Text*, size_t pos);

/* match a search term in either forward or backward direction */
Filerange text_object_search_forward(Text*, size_t pos, Regex*);
Filerange text_object_search_backward(Text*, size_t pos, Regex*);
/* match all lines with same indentation level as the current one */
Filerange text_object_indentation(Text*, size_t pos);

/* extend a range to cover whole lines */




#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* memrchr(3) is non-standard */
#endif
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#if CONFIG_ACL
#include <sys/acl.h>
#endif
#if CONFIG_SELINUX
#include <selinux/selinux.h>
#endif

#include "text.h"
#include "text-util.h"
#include "text-motions.h"
#include "util.h"
#include "array.h"
#include "text-internal.h"

/* Allocate blocks holding the actual file content in junks of size: */
#ifndef BLOCK_SIZE
#define BLOCK_SIZE (1 << 20)
#endif
/* Files smaller than this value are copied on load, larger ones are mmap(2)-ed
 * directely. Hence the former can be truncated, while doing so on the latter
 * results in havoc. */
#define BLOCK_MMAP_SIZE (1 << 26)

/* Block holding the file content, either readonly mmap(2)-ed from the original
 * file or heap allocated to store the modifications.
 */
typedef struct Block Block;
struct Block {
	size_t size;               /* maximal capacity */
	size_t len;                /* current used length / insertion position */
	char *data;                /* actual data */
	enum {                     /* type of allocation */
		MMAP_ORIG,         /* mmap(2)-ed from an external file */
		MMAP,              /* mmap(2)-ed from a temporary file only known to this process */
		MALLOC,            /* heap allocated block using malloc(3) */
	} type;
	Block *next;               /* next junk */
};

/* A piece holds a reference (but doesn't itself store) a certain amount of data.
 * All active pieces chained together form the whole content of the document.
 * At the beginning there exists only one piece, spanning the whole document.
 * Upon insertion/deletion new pieces will be created to represent the changes.
 * Generally pieces are never destroyed, but kept around to perform undo/redo
 * operations.
 */
struct Piece {


/* The main struct holding all information of a given file */
struct Text {
	Array blocks;           /* blocks which hold text content */
	Block *blocks;          /* all blocks which have been allocated to hold insertion data */
	Piece *pieces;          /* all pieces which have been allocated, used to free them */
	Piece *cache;           /* most recently modified piece */
	Piece begin, end;       /* sentinel nodes which always exists but don't hold any data */

	LineCache lines;        /* mapping between absolute pos in bytes and logical line breaks */
};

struct TextSave {                  /* used to hold context between text_save_{begin,commit} calls */
	Text *txt;                 /* text to operate on */
	char *filename;            /* filename to save to as given to text_save_begin */
	char *tmpname;             /* temporary name used for atomic rename(2) */
	int fd;                    /* file descriptor to write data to using text_save_write */
	enum TextSaveMethod type;  /* method used to save file */
};

/* block management */
static Block *block_alloc(Text*, size_t size);
static Block *block_read(Text*, size_t size, int fd);
static Block *block_mmap(Text*, size_t size, int fd, off_t offset);
static void block_free(Block*);
static bool block_capacity(Block*, size_t len);
static const char *block_append(Block*, const char *data, size_t len);
static bool block_insert(Block*, size_t pos, const char *data, size_t len);
static bool block_delete(Block*, size_t pos, size_t len);
static const char *block_store(Text*, const char *data, size_t len);
/* cache layer */
static void cache_piece(Text *txt, Piece *p);

static void piece_free(Piece *p);
static void piece_init(Piece *p, Piece *prev, Piece *next, const char *data, size_t len);
static Location piece_get_intern(Text *txt, size_t pos);
static Location piece_get_extern(const Text *txt, size_t pos);
/* span management */
static void span_init(Span *span, Piece *start, Piece *end);
static void span_swap(Text *txt, Span *old, Span *new);

static size_t lines_skip_forward(Text *txt, size_t pos, size_t lines, size_t *lines_skiped);
static size_t lines_count(Text *txt, size_t pos, size_t len);

/* stores the given data in a block, allocates a new one if necessary. Returns
 * a pointer to the storage location or NULL if allocation failed. */
static const char *block_store(Text *txt, const char *data, size_t len) {
	Block *blk = array_get_ptr(&txt->blocks, array_length(&txt->blocks)-1);
	if (!blk || !block_capacity(blk, len)) {
		blk = block_alloc(len);
		if (!blk)
			return NULL;
		if (!array_add_ptr(&txt->blocks, blk)) {
			break;
		}
		rem -= written;
		buf += written;
	}
	return count - rem;
}

/* allocate a new block of MAX(size, BLOCK_SIZE) bytes */
static Block *block_alloc(Text *txt, size_t size) {
	Block *blk = calloc(1, sizeof *blk);
	if (!blk)
		return NULL;
	if (BLOCK_SIZE > size)
		size = BLOCK_SIZE;
	if (!(blk->data = malloc(size))) {
		free(blk);
		return NULL;
	}
	blk->type = MALLOC;
	blk->size = size;
	blk->next = txt->blocks;
	txt->blocks = blk;
	return blk;
}

static Block *block_read(Text *txt, size_t size, int fd) {
	Block *blk = block_alloc(txt, size);
	if (!blk)
		return NULL;
	while (size > 0) {
		char data[4096];
		ssize_t len = read(fd, data, MIN(sizeof(data), size));
		if (len == -1) {
			txt->blocks = blk->next;
			block_free(blk);
			return NULL;
		} else if (len == 0) {
			break;
		} else {
			block_append(blk, data, len);
			size -= len;
		}
	}
	return blk;
}

static Block *block_mmap(Text *txt, size_t size, int fd, off_t offset) {
	Block *blk = calloc(1, sizeof *blk);
	if (!blk)
		return NULL;
	if (size) {
		blk->data = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, offset);
		if (blk->data == MAP_FAILED) {
			free(blk);
			return NULL;
		}
	}
	blk->type = MMAP_ORIG;
	blk->size = size;
	blk->len = size;
	blk->next = txt->blocks;
	txt->blocks = blk;
	return blk;
}

static void block_free(Block *blk) {
	if (!blk)
		return;
	if (blk->type == MALLOC)
		free(blk->data);
	else if ((blk->type == MMAP_ORIG || blk->type == MMAP) && blk->data)
		munmap(blk->data, blk->size);
	free(blk);
}

/* check whether block has enough free space to store len bytes */
static bool block_capacity(Block *blk, size_t len) {
	return blk->size - blk->len >= len;
}

/* append data to block, assumes there is enough space available */
static const char *block_append(Block *blk, const char *data, size_t len) {
	char *dest = memcpy(blk->data + blk->len, data, len);
	blk->len += len;
	return dest;
}

/* stores the given data in a block, allocates a new one if necessary. returns
 * a pointer to the storage location or NULL if allocation failed. */
static const char *block_store(Text *txt, const char *data, size_t len) {
	Block *blk = txt->blocks;
	if ((!blk || !block_capacity(blk, len)) && !(blk = block_alloc(txt, len)))
		return NULL;
	return block_append(blk, data, len);
}

/* insert data into block at an arbitrary position, this should only be used with
 * data of the most recently created piece. */
static bool block_insert(Block *blk, size_t pos, const char *data, size_t len) {
	if (pos > blk->len || !block_capacity(blk, len))
		return false;
	if (blk->len == pos)
		return block_append(blk, data, len);
	char *insert = blk->data + pos;
	memmove(insert + len, insert, blk->len - pos);
	memcpy(insert, data, len);
	blk->len += len;
	return true;
}

/* delete data from a block at an arbitrary position, this should only be used with
 * data of the most recently created piece. */
static bool block_delete(Block *blk, size_t pos, size_t len) {
	size_t end;
	if (!addu(pos, len, &end) || end > blk->len)
		return false;
	if (blk->len == pos) {
		blk->len -= len;
		return true;
	}
	char *delete = blk->data + pos;
	memmove(delete, delete + len, blk->len - pos - len);
	blk->len -= len;
	return true;
}

/* cache the given piece if it is the most recently changed one */
static void cache_piece(Text *txt, Piece *p) {
	Block *blk = array_get_ptr(&txt->blocks, array_length(&txt->blocks)-1);
	if (!blk || p->data < blk->data || p->data + p->len != blk->data + blk->len)
		return;
	txt->cache = p;


/* check whether the given piece was the most recently modified one */
static bool cache_contains(Text *txt, Piece *p) {
	Block *blk = array_get_ptr(&txt->blocks, array_length(&txt->blocks)-1);
	Revision *rev = txt->current_revision;
	if (!blk || !txt->cache || txt->cache != p || !rev || !rev->change)
		return false;

	return found && p->data + p->len == blk->data + blk->len;
}

/* try to insert a chunk of data at a given piece offset. The insertion is only
 * performed if the piece is the most recently changed one. The length of the
 * piece, the span containing it and the whole text is adjusted accordingly */
static bool cache_insert(Text *txt, Piece *p, size_t off, const char *data, size_t len) {
	if (!cache_contains(txt, p))
		return false;
	Block *blk = array_get_ptr(&txt->blocks, array_length(&txt->blocks)-1);
	size_t bufpos = p->data + off - blk->data;
	if (!block_insert(blk, bufpos, data, len))
		return false;

	return true;
}

/* try to delete a chunk of data at a given piece offset. The deletion is only
 * performed if the piece is the most recently changed one and the whole
 * affected range lies within it. The length of the piece, the span containing it
 * and the whole text is adjusted accordingly */
static bool cache_delete(Text *txt, Piece *p, size_t off, size_t len) {
	if (!cache_contains(txt, p))
		return false;
	Block *blk = array_get_ptr(&txt->blocks, array_length(&txt->blocks)-1);
	size_t end;
	size_t bufpos = p->data + off - blk->data;
	if (!addu(off, len, &end) || end > p->len || !block_delete(blk, bufpos, len))

	p->len = len;
}

/* returns the piece holding the text at byte offset pos. If pos happens to
 * be at a piece boundary i.e. the first byte of a piece then the previous piece
 * to the left is returned with an offset of piece->len. This is convenient for
 * modifications to the piece chain where both pieces (the returned one and the
 * one following it) are needed, but unsuitable as a public interface.
 *

	return (Location){ 0 };
}

/* similiar to piece_get_intern but usable as a public API. Returns the piece
 * holding the text at byte offset pos. Never returns a sentinel piece.
 * it pos is the end of file (== text_size()) and the file is not empty then
 * the last piece holding data is returned.
 */
static Location piece_get_extern(const Text *txt, size_t pos) {
	size_t cur = 0;
	Piece *p;


		span_init(&c->new, new, new);
		span_init(&c->old, NULL, NULL);
	} else {
		/* insert into middle of an existing piece, therefore split the old
		 * piece. That is we have 3 new pieces one containing the content
		 * before the insertion point then one holding the newly inserted
		 * text and one holding the content after the insertion point.
		 */

	return true;
}

static bool text_vprintf(Text *txt, size_t pos, const char *format, va_list ap) {
	va_list ap_save;
	va_copy(ap_save, ap);
	int len = vsnprintf(NULL, 0, format, ap);
	if (len == -1) {
		va_end(ap_save);
		return false;
	}
	char *buf = malloc(len+1);
	bool ret = buf && (vsnprintf(buf, len+1, format, ap_save) == len) && text_insert(txt, pos, buf, len);
	free(buf);
	va_end(ap_save);
	return ret;
}

bool text_appendf(Text *txt, const char *format, ...) {
	va_list ap;
	va_start(ap, format);
	bool ret = text_vprintf(txt, text_size(txt), format, ap);
	va_end(ap);
	return ret;
}

bool text_printf(Text *txt, size_t pos, const char *format, ...) {
	va_list ap;
	va_start(ap, format);
	bool ret = text_vprintf(txt, pos, format, ap);
	va_end(ap);
	return ret;
}

static size_t revision_undo(Text *txt, Revision *rev) {
	size_t pos = EPOS;
	for (Change *c = rev->change; c; c = c->next) {

	return history_traverse_to(txt, rev);
}

time_t text_state(const Text *txt) {
	return txt->history->time;
}

Text *text_loadat_method(int dirfd, const char *filename, enum TextLoadMethod method) {
#if CONFIG_ACL
	acl_t acl = acl_get_fd(src);
	if (!acl)
		return errno == ENOTSUP ? true : false;
	if (acl_set_fd(dest, acl) == -1) {
		acl_free(acl);
		return false;
	}
	acl_free(acl);
#endif /* CONFIG_ACL */
	return true;
}

static bool preserve_selinux_context(int src, int dest) {
#if CONFIG_SELINUX
	char *context = NULL;
	if (!is_selinux_enabled())
		return true;
	if (fgetfilecon(src, &context) == -1)
		return errno == ENOTSUP ? true : false;
	if (fsetfilecon(dest, context) == -1) {
		freecon(context);
		return false;
	}
	freecon(context);
#endif /* CONFIG_SELINUX */
	return true;
}

/* Create a new file named `.filename.vis.XXXXXX` (where `XXXXXX` is a
 * randomly generated, unique suffix) and try to preserve all important
 * meta data. After the file content has been written to this temporary
 * file, text_save_commit_atomic will atomically move it to  its final
 * (possibly already existing) destination using rename(2).
 *
 * This approach does not work if:
 *
 *   - the file is a symbolic link
 *   - the file is a hard link
 *   - file ownership can not be preserved
 *   - file group can not be preserved
 *   - directory permissions do not allow creation of a new file
 *   - POSXI ACL can not be preserved (if enabled)
 *   - SELinux security context can not be preserved (if enabled)
 */
static bool text_save_begin_atomic(TextSave *ctx) {
	int oldfd, saved_errno;
	if ((oldfd = open(ctx->filename, O_RDONLY)) == -1 && errno != ENOENT)
		goto err;
	struct stat oldmeta = { 0 };
	if (oldfd != -1 && lstat(ctx->filename, &oldmeta) == -1)
		goto err;
	if (oldfd != -1) {
		if (S_ISLNK(oldmeta.st_mode)) /* symbolic link */
			goto err;
		if (oldmeta.st_nlink > 1) /* hard link */
			goto err;
	}

	char suffix[] = ".vis.XXXXXX";
	size_t len = strlen(ctx->filename) + sizeof("./.") + sizeof(suffix);
	char *dir = strdup(ctx->filename);
	char *base = strdup(ctx->filename);

	if (!(ctx->tmpname = malloc(len)) || !dir || !base) {
		free(dir);
		free(base);
		goto err;
	}

	snprintf(ctx->tmpname, len, "%s/.%s%s", dirname(dir), basename(base), suffix);
	free(dir);
	free(base);

	if ((ctx->fd = mkstemp(ctx->tmpname)) == -1)
		goto err;

	if (oldfd == -1) {
		mode_t mask = umask(0);
		umask(mask);
		if (fchmod(ctx->fd, 0666 & ~mask) == -1)
			goto err;
	} else {
		if (fchmod(ctx->fd, oldmeta.st_mode) == -1)
			goto err;
		if (!preserve_acl(oldfd, ctx->fd) || !preserve_selinux_context(oldfd, ctx->fd))
			goto err;
		/* change owner if necessary */
		if (oldmeta.st_uid != getuid() && fchown(ctx->fd, oldmeta.st_uid, (uid_t)-1) == -1)
			goto err;
		/* change group if necessary, in case of failure some editors reset
		 * the group permissions to the same as for others */
		if (oldmeta.st_gid != getgid() && fchown(ctx->fd, (uid_t)-1, oldmeta.st_gid) == -1)
			goto err;
		close(oldfd);
	}

	ctx->type = TEXT_SAVE_ATOMIC;
	return true;
err:
	saved_errno = errno;
	if (oldfd != -1)
		close(oldfd);
	if (ctx->fd != -1)
		close(ctx->fd);
	ctx->fd = -1;
	free(ctx->tmpname);
	ctx->tmpname = NULL;
	errno = saved_errno;
	return false;
}

static bool text_save_commit_atomic(TextSave *ctx) {
	if (fsync(ctx->fd) == -1)
		return false;

	struct stat meta = { 0 };
	if (fstat(ctx->fd, &meta) == -1)
		return false;

	bool close_failed = (close(ctx->fd) == -1);
	ctx->fd = -1;
	if (close_failed)
		return false;

	if (rename(ctx->tmpname, ctx->filename) == -1)
		return false;

	free(ctx->tmpname);
	ctx->tmpname = NULL;

	int dir = open(dirname(ctx->filename), O_DIRECTORY|O_RDONLY);
	if (dir == -1)
		return false;

	if (fsync(dir) == -1 && errno != EINVAL) {
		close(dir);
		return false;
	}

	if (close(dir) == -1)
		return false;

	if (meta.st_mtime)
		ctx->txt->info = meta;
	return true;
}

static bool text_save_begin_inplace(TextSave *ctx) {
	Text *txt = ctx->txt;
	struct stat meta = { 0 };
	int newfd = -1, saved_errno;
	if ((ctx->fd = open(ctx->filename, O_CREAT|O_WRONLY, 0666)) == -1)
		goto err;
	if (fstat(ctx->fd, &meta) == -1)
		goto err;
	if (meta.st_dev == txt->info.st_dev && meta.st_ino == txt->info.st_ino &&
	    txt->block && txt->block->type == MMAP_ORIG && txt->block->size) {
		/* The file we are going to overwrite is currently mmap-ed from
		 * text_load, therefore we copy the mmap-ed block to a temporary
		 * file and remap it at the same position such that all pointers
		 * from the various pieces are still valid.
		 */
		size_t size = txt->block->size;
		char tmpname[32] = "/tmp/vis-XXXXXX";
		newfd = mkstemp(tmpname);
		if (newfd == -1)
			goto err;
		if (unlink(tmpname) == -1)
			goto err;
		ssize_t written = write_all(newfd, txt->block->data, size);
		if (written == -1 || (size_t)written != size)
			goto err;
		if (munmap(txt->block->data, size) == -1)
			goto err;

		void *data = mmap(txt->block->data, size, PROT_READ, MAP_SHARED, newfd, 0);
		if (data == MAP_FAILED)
			goto err;
		if (data != txt->block->data) {
			munmap(data, size);
			goto err;
		}
		bool close_failed = (close(newfd) == -1);
		newfd = -1;
		if (close_failed)
			goto err;
		txt->block->data = data;
		txt->block->type = MMAP;
		newfd = -1;
	}
	/* overwrite the existing file content, if something goes wrong
	 * here we are screwed, TODO: make a backup before? */
	if (ftruncate(ctx->fd, 0) == -1)
		goto err;
	ctx->type = TEXT_SAVE_INPLACE;
	return true;
err:
	saved_errno = errno;
	if (newfd != -1)
		close(newfd);
	if (ctx->fd != -1)
		close(ctx->fd);
	ctx->fd = -1;
	errno = saved_errno;
	return false;
}

static bool text_save_commit_inplace(TextSave *ctx) {
	if (fsync(ctx->fd) == -1)
		return false;
	struct stat meta = { 0 };
	if (fstat(ctx->fd, &meta) == -1)
		return false;
	if (close(ctx->fd) == -1)
		return false;
	ctx->txt->info = meta;
	return true;
}

TextSave *text_save_begin(Text *txt, const char *filename, enum TextSaveMethod type) {
	if (!filename)
		return NULL;
	TextSave *ctx = calloc(1, sizeof *ctx);
	if (!ctx)
		return NULL;
	ctx->txt = txt;
	ctx->fd = -1;
	if (!(ctx->filename = strdup(filename)))
		goto err;
	errno = 0;
	if ((type == TEXT_SAVE_AUTO || type == TEXT_SAVE_ATOMIC) && text_save_begin_atomic(ctx))
		return ctx;
	if (errno == ENOSPC)
		goto err;
	if ((type == TEXT_SAVE_AUTO || type == TEXT_SAVE_INPLACE) && text_save_begin_inplace(ctx))
		return ctx;
err:
	text_save_cancel(ctx);
	return NULL;
}

bool text_save_commit(TextSave *ctx) {
	if (!ctx)
		return true;
	bool ret;
	Text *txt = ctx->txt;
	switch (ctx->type) {
	case TEXT_SAVE_ATOMIC:
		ret = text_save_commit_atomic(ctx);
		break;
	case TEXT_SAVE_INPLACE:
		ret = text_save_commit_inplace(ctx);
		break;
	default:
		ret = false;
		break;
	}

	if (ret) {
		txt->saved_revision = txt->history;
		text_snapshot(txt);
	}
	text_save_cancel(ctx);
	return ret;
}

void text_save_cancel(TextSave *ctx) {
	if (!ctx)
		return;
	int saved_errno = errno;
	if (ctx->fd != -1)
		close(ctx->fd);
	if (ctx->tmpname && ctx->tmpname[0])
		unlink(ctx->tmpname);
	free(ctx->tmpname);
	free(ctx->filename);
	free(ctx);
	errno = saved_errno;
}

/* First try to save the file atomically using rename(2) if this does not
 * work overwrite the file in place. However if something goes wrong during
 * this overwrite the original file is permanently damaged.
 */
bool text_save(Text *txt, const char *filename) {
	return text_save_method(txt, filename, TEXT_SAVE_AUTO);
}

bool text_save_method(Text *txt, const char *filename, enum TextSaveMethod method) {
	if (!filename) {
		txt->saved_revision = txt->history;
		text_snapshot(txt);
		return true;
	}
	TextSave *ctx = text_save_begin(txt, filename, method);
	if (!ctx)
		return false;
	Filerange range = (Filerange){ .start = 0, .end = text_size(txt) };
	ssize_t written = text_save_write_range(ctx, &range);
	if (written == -1 || (size_t)written != text_range_size(&range)) {
		text_save_cancel(ctx);
		return false;
	}
	return text_save_commit(ctx);
}

ssize_t text_save_write_range(TextSave *ctx, Filerange *range) {
	return text_write_range(ctx->txt, range, ctx->fd);
}

ssize_t text_write(Text *txt, int fd) {
	Filerange r = (Filerange){ .start = 0, .end = text_size(txt) };
	return text_write_range(txt, &r, fd);
}

ssize_t text_write_range(Text *txt, Filerange *range, int fd) {
	size_t size = text_range_size(range), rem = size;
	for (Iterator it = text_iterator_get(txt, range->start);
	     rem > 0 && text_iterator_valid(&it);
	     text_iterator_next(&it)) {
		size_t prem = it.end - it.text;
		if (prem > rem)
			prem = rem;
		ssize_t written = write_all(fd, it.text, prem);
		if (written == -1)
			return -1;
		rem -= written;
		if ((size_t)written != prem)
			break;
	}
	return size - rem;
}

Text *text_load(const char *filename) {
	return text_load_method(filename, TEXT_LOAD_AUTO);
}

Text *text_load_method(const char *filename, enum TextLoadMethod method) {
	int fd = -1;
	size_t size = 0;
	Text *txt = calloc(1, sizeof *txt);
	if (!txt)
		return NULL;
	Piece *p = piece_alloc(txt);
	if (!p)
		goto out;
	Block *block = NULL;
	array_init(&txt->blocks);
	lineno_cache_invalidate(&txt->lines);
	if (filename) {
		errno = 0;
		block = block_load(dirfd, filename, method, &txt->info);
		if (!block && errno)
			goto out;
		if (block && !array_add_ptr(&txt->blocks, block)) {
			block_free(block);
			goto out;
		if (!S_ISREG(txt->info.st_mode)) {
			errno = S_ISDIR(txt->info.st_mode) ? EISDIR : ENOTSUP;
			goto out;
		}
		// XXX: use lseek(fd, 0, SEEK_END); instead?
		size = txt->info.st_size;
		if (size > 0) {
			if (method == TEXT_LOAD_READ || (method == TEXT_LOAD_AUTO && size < BLOCK_MMAP_SIZE))
				txt->block = block_read(txt, size, fd);
			else
				txt->block = block_mmap(txt, size, fd, 0);
			if (!txt->block)
				goto out;
			piece_init(p, &txt->begin, &txt->end, txt->block->data, txt->block->len);
		}
	}

	if (!block)
		piece_init(p, &txt->begin, &txt->end, "\0", 0);
	else
		piece_init(p, &txt->begin, &txt->end, block->data, block->len);

	piece_init(&txt->begin, NULL, p, NULL, 0);
	piece_init(&txt->end, p, NULL, NULL, 0);

	text_snapshot(txt);
	txt->saved_revision = txt->history;

	if (fd != -1)
		close(fd);
	return txt;
out:
	if (fd != -1)
		close(fd);
	text_free(txt);
	return NULL;
}

struct stat text_stat(const Text *txt) {
	return txt->info;
}

void text_saved(Text *txt, struct stat *meta) {
	if (meta)
		txt->info = *meta;
	txt->saved_revision = txt->history;
	text_snapshot(txt);
}

Block *text_block_mmaped(Text *txt) {
	Block *block = array_get_ptr(&txt->blocks, 0);
	if (block && block->type == BLOCK_TYPE_MMAP_ORIG && block->size)
		return block;
	return NULL;
}

/* A delete operation can either start/stop midway through a piece or at
 * a boundary. In the former case a new piece is created to represent the
 * remaining text before/after the modification point.
 *
 *      /-+ --> +---------+ --> +-----+ --> +-----+ --> +-\

	size_t cur;            /* how much has already been deleted */

	if (off == p->len) {
		/* deletion starts at a piece boundary */
		cur = 0;
		before = p;
		start = p->next;

	}

	if (cur == len) {
		/* deletion stops at a piece boundary */
		end = p;
		after = p->next;
	} else {

	return true;
}

bool text_delete_range(Text *txt, const Filerange *r) {
	if (!text_range_valid(r))
		return false;
	return text_delete(txt, r->start, text_range_size(r));


/* preserve the current text content such that it can be restored by
 * means of undo/redo operations */
bool text_snapshot(Text *txt) {
	if (txt->current_revision)
		txt->last_revision = txt->current_revision;
	txt->current_revision = NULL;
	txt->cache = NULL;
	return true;
}



		piece_free(p);
	}

	for (size_t i = 0, len = array_length(&txt->blocks); i < len; i++)
		block_free(array_get_ptr(&txt->blocks, i));
	array_release(&txt->blocks);
	}

	free(txt);
}

bool text_modified(const Text *txt) {
	return txt->saved_revision != txt->history;
}

bool text_mmaped(const Text *txt, const char *ptr) {
	uintptr_t addr = (uintptr_t)ptr;
	for (size_t i = 0, len = array_length(&txt->blocks); i < len; i++) {
		Block *blk = array_get_ptr(&txt->blocks, i);
		if ((blk->type == BLOCK_TYPE_MMAP_ORIG || blk->type == BLOCK_TYPE_MMAP) &&
		    (uintptr_t)(blk->data) <= addr && addr < (uintptr_t)(blk->data + blk->size))
			return true;
	}
	return false;
}

static bool iterator_init(Iterator *it, size_t pos, Piece *p, size_t off) {
	*it = (Iterator){
		.pos = pos,
		.piece = p,
		.start = p ? p->data : NULL,
		.end = p && p->data ? p->data + p->len : NULL,
		.text = p && p->data ? p->data + off : NULL,
	};
	*it = iter;
	return text_iterator_valid(it);
}

bool text_iterator_init(const Text *txt, Iterator *it, size_t pos) {
	Iterator it;
	Location loc = piece_get_extern(txt, pos);
	return iterator_init(it, pos, loc.piece, loc.off);
	return it;
}

Iterator text_iterator_get(const Text *txt, size_t pos) {
	Iterator it;
	text_iterator_init(txt, &it, pos);
	return it;
			return true;
		} else if (it->pos == it->piece->text->size) { /* EOF */
			*b = '\0';
			return true;
		}
	}
	return false;
}

bool text_iterator_next(Iterator *it) {
	size_t rem = it->end - it->text;
	return iterator_init(it, it->pos+rem, it->piece ? it->piece->next : NULL, 0);
}

bool text_iterator_prev(Iterator *it) {
	size_t off = it->text - it->start;
	size_t len = it->piece && it->piece->prev ? it->piece->prev->len : 0;
	return iterator_init(it, it->pos-off, it->piece ? it->piece->prev : NULL, len);
}

const Text *text_iterator_text(const Iterator *it) {
	return it->piece ? it->piece->text : NULL;
}

bool text_iterator_valid(const Iterator *it) {
	/* filter out sentinel nodes */
	return it->piece && it->piece->text;
}

bool text_iterator_has_next(const Iterator *it) {
	return it->piece && it->piece->next;
		return false;
	bool eof = true;
	if (it->text < it->end) {
		it->text++;
		it->pos++;
		eof = false;
	} else if (!it->piece->prev) {
		eof = false;
	}

	while (it->text == it->end) {
		if (!text_iterator_next(it)) {
			if (eof)
				return false;
			if (b)
				*b = '\0';
			return text_iterator_prev(it);
		}
	}

	if (b)
		*b = *it->text;
	return true;
}

bool text_iterator_has_prev(const Iterator *it) {
	return it->piece && it->piece->prev;
		return false;
	bool eof = !it->piece->next;
	while (it->text == it->start) {
		if (!text_iterator_prev(it)) {
			if (!eof)
				return false;
			if (b)
				*b = '\0';
			return text_iterator_next(it);
		}
	}

	--it->text;
	--it->pos;

	if (b)
		*b = *it->text;
	return true;
}

size_t text_size(const Text *txt) {
	while (it->text) {
		const char *match = memrchr(it->start, b, it->text - it->start);
		if (match) {
			it->pos -= it->text - match;
			it->text = match;
			return true;
		}
		text_iterator_prev(it);
	}
	text_iterator_next(it);
	return false;
}

bool text_iterator_byte_find_next(Iterator *it, char b) {
	while (it->text) {
		const char *match = memchr(it->text, b, it->end - it->text);
		if (match) {
			it->pos += match - it->text;
			it->text = match;
			return true;
		}
		text_iterator_next(it);
	}
	text_iterator_prev(it);
	return false;
}

bool text_iterator_codepoint_next(Iterator *it, char *c) {
	while (text_iterator_byte_next(it, NULL)) {
		if (ISUTF8(*it->text)) {
			if (c)
				*c = *it->text;
			return true;
		}
	}
	return false;
}

bool text_iterator_codepoint_prev(Iterator *it, char *c) {
	while (text_iterator_byte_prev(it, NULL)) {
		if (ISUTF8(*it->text)) {
			if (c)
				*c = *it->text;
			return true;
		}
	}
	return false;
}

bool text_iterator_char_next(Iterator *it, char *c) {
	if (!text_iterator_codepoint_next(it, c))
		return false;
	mbstate_t ps = { 0 };
	for (;;) {
		char buf[MB_LEN_MAX];
		size_t len = text_bytes_get(it->piece->text, it->pos, sizeof buf, buf);
		wchar_t wc;
		size_t wclen = mbrtowc(&wc, buf, len, &ps);
		if (wclen == (size_t)-1 && errno == EILSEQ) {
			return true;
		} else if (wclen == (size_t)-2) {
			return false;
		} else if (wclen == 0) {
			return true;
		} else {
			int width = wcwidth(wc);
			if (width != 0)
				return true;
			if (!text_iterator_codepoint_next(it, c))
				return false;
		}
	}
	return true;
}

bool text_iterator_char_prev(Iterator *it, char *c) {
	if (!text_iterator_codepoint_prev(it, c))
		return false;
	for (;;) {
		char buf[MB_LEN_MAX];
		size_t len = text_bytes_get(it->piece->text, it->pos, sizeof buf, buf);
		wchar_t wc;
		mbstate_t ps = { 0 };
		size_t wclen = mbrtowc(&wc, buf, len, &ps);
		if (wclen == (size_t)-1 && errno == EILSEQ) {
			return true;
		} else if (wclen == (size_t)-2) {
			return false;
		} else if (wclen == 0) {
			return true;
		} else {
			int width = wcwidth(wc);
			if (width != 0)
				return true;
			if (!text_iterator_codepoint_prev(it, c))
				return false;
		}
	}
	return true;
}

bool text_byte_get(Text *txt, size_t pos, char *byte) {
	return text_bytes_get(txt, pos, 1, byte);
}

size_t text_bytes_get(Text *txt, size_t pos, size_t len, char *buf) {
	if (!buf)
		return 0;
	char *cur = buf;
	size_t rem = len;
	for (Iterator it = text_iterator_get(txt, pos);
	     text_iterator_valid(&it);
	     text_iterator_next(&it)) {
		if (rem == 0)
			break;
		size_t piece_len = it.end - it.text;
		if (piece_len > rem)
			piece_len = rem;
		if (piece_len) {
			memcpy(cur, it.text, piece_len);
			cur += piece_len;
			rem -= piece_len;
		}
	}
	return len - rem;
}

char *text_bytes_alloc0(Text *txt, size_t pos, size_t len) {
	if (len == SIZE_MAX)
		return NULL;
	char *buf = malloc(len+1);
	if (!buf)
		return NULL;
	len = text_bytes_get(txt, pos, len, buf);
	buf[len] = '\0';
	return buf;
}

size_t text_size(Text *txt) {
	return txt->size;
}


	return (Mark)(loc.piece->data + loc.off);
}

size_t text_mark_get(const Text *txt, Mark mark) {
	size_t cur = 0;

	if (mark == EMARK)




/** A mark. */
typedef uintptr_t Mark;

/** An invalid mark, lookup of which will yield ``EPOS``. */
#define EMARK ((Mark)0)
/** An invalid position. */
#define EPOS ((size_t)-1)

	 */
	TEXT_LOAD_READ,
	/**
	 * Memory map the file from disk. Use file system / virtual memory
	 * subsystem as a caching layer.
	 * @rst
	 * .. note:: Load time is (almost) independent of the file size.
	 * .. warning:: Inplace modifications of the underlying file
	 *              will be reflected in the current text content.
	 *              In particular, truncation will raise ``SIGBUS``
	 *              and result in data loss.
	 * @endrst
	 */

 * @endrst
 */
Text *text_load(const char *filename);
Text *text_loadat(int dirfd, const char *filename);
/**
 * Create a text instance populated with the given file content.
 *

 * @endrst
 */
Text *text_load_method(const char *filename, enum TextLoadMethod);
Text *text_loadat_method(int dirfd, const char *filename, enum TextLoadMethod);
/** Release all resources associated with this text instance. */
void text_free(Text*);
/**
 * @}

 * @{
 */
/** Return the size in bytes of the whole text. */
size_t text_size(const Text*);
/**
 * Get file information at time of load or last save, whichever happened more
 * recently.

 * @endrst
 * @return See ``stat(2)`` for details.
 */
struct stat text_stat(const Text*);
/** Query whether the text contains any unsaved modifications. */
bool text_modified(const Text*);
/**
 * @}
 * @defgroup modify

 * @return Whether the deletion succeeded.
 */
bool text_delete(Text*, size_t pos, size_t len);
bool text_delete_range(Text*, const Filerange*);
bool text_printf(Text*, size_t pos, const char *format, ...) __attribute__((format(printf, 3, 4)));
bool text_appendf(Text*, const char *format, ...) __attribute__((format(printf, 2, 3)));
/**

 * @{
 */
/**
 * Create a text snapshot, that is a vertex in the history graph.
 */
bool text_snapshot(Text*);
/**
 * Revert to previous snapshot along the main branch.
 * @rst

 * .. note:: TODO: This is currently not the same as the time of the last snapshot.
 * @endrst
 */
time_t text_state(const Text*);
/**
 * @}
 * @defgroup lines

 *           return an artificial NUL byte at EOF.
 * @endrst
 */
bool text_byte_get(const Text*, size_t pos, char *byte);
/**
 * Store at most ``len`` bytes starting from ``pos`` into ``buf``.
 * @param pos The absolute starting position.
 * @param len The length in bytes.
 * @param buf The destination buffer.

 * .. warning:: ``buf`` will not be NUL terminated.
 * @endrst
 */
size_t text_bytes_get(const Text*, size_t pos, size_t len, char *buf);
/**
 * Fetch text range into newly allocate memory region.
 * @param pos The absolute starting position.
 * @param len The length in bytes.
 * @return A contiguous NUL terminated buffer holding the requested range, or
 *         ``NULL`` in error case.
 * @rst
 * .. warning:: The returned pointer must be freed by the caller.
 * @endrst
 */
char *text_bytes_alloc0(const Text*, size_t pos, size_t len);
/**
 * @}
 * @defgroup iterator
 * @{
 */
Iterator text_iterator_get(const Text*, size_t pos);
bool text_iterator_init(const Text*, Iterator*, size_t pos);
const Text *text_iterator_text(const Iterator*);
bool text_iterator_valid(const Iterator*);
bool text_iterator_has_next(const Iterator*);
bool text_iterator_has_prev(const Iterator*);
bool text_iterator_next(Iterator*);
bool text_iterator_prev(Iterator*);
/**

 * @defgroup iterator_byte
 * @{
 */
bool text_iterator_byte_get(const Iterator*, char *b);
bool text_iterator_byte_prev(Iterator*, char *b);
bool text_iterator_byte_next(Iterator*, char *b);
bool text_iterator_byte_find_prev(Iterator*, char b);

/**
 * Set a mark.
 * @rst
 * .. note:: Setting a mark to ``text_size`` will always return the
 *           current text size upon lookup.
 * @endrst
 * @param pos The position at which to store the mark.
 * @return The mark or ``EMARK`` if an invalid position was given.
 */
Mark text_mark_set(Text*, size_t pos);
/**
 * Lookup a mark.
 * @param mark The mark to look up.
 * @return The byte position or ``EPOS`` for an invalid mark.
 */
size_t text_mark_get(const Text*, Mark);
/**
 * @}
 * @defgroup save

	/** Automatically chose best option. */
	TEXT_SAVE_AUTO,
	/**
	 * Save file atomically using ``rename(2)``.
	 *
	 * Creates a temporary file, restores all important meta data,
	 * before moving it atomically to its final (possibly already
	 * existing) destination using ``rename(2)``. For new files,
	 * permissions are set to ``0666 & ~umask``.
	 *
	 * @rst
	 * .. warning:: This approach does not work if:

	 *   - File ownership can not be preserved.
	 *   - File group can not be preserved.
	 *   - Directory permissions do not allow creation of a new file.
	 *   - POSIX ACL can not be preserved (if enabled).
	 *   - SELinux security context can not be preserved (if enabled).
	 * @endrst
	 */


/**
 * Save the whole text to the given file name.
 */
bool text_save(Text*, const char *filename);
/**
 * Save the whole text to the given file name, using the specified method.
 *
 * @rst
 * .. note:: Equivalent to ``text_save_method(filename, TEXT_SAVE_AUTO)``.
 * @endrst
 */
bool text_save(Text*, const char *filename);
bool text_saveat(Text*, int dirfd, const char *filename);
/**
 * Save the whole text to the given file name, using the specified method.
 */
bool text_save_method(Text*, const char *filename, enum TextSaveMethod);
bool text_saveat_method(Text*, int dirfd, const char *filename, enum TextSaveMethod);

/**
 * Setup a sequence of write operations.
 *
 * The returned ``TextSave`` pointer can be used to write multiple, possibly
 * non-contiguous, file ranges.
 * @rst
 * .. warning:: For every call to ``text_save_begin`` there must be exactly
 *              one matching call to either ``text_save_commit`` or
 *              ``text_save_cancel`` to release the underlying resources.
 * @endrst
 */
TextSave *text_save_begin(Text*, int dirfd, const char *filename, enum TextSaveMethod);
/**
 * Write file range.
 * @return The number of bytes written or ``-1`` in case of an error.
 */
ssize_t text_save_write_range(TextSave*, const Filerange*);
/**
 * Commit changes to disk.
 * @return Whether changes have been saved.
 * @rst
 * .. note:: Releases the underlying resources and frees the given ``TextSave``
 *           pointer which must no longer be used.
 * @endrst
 */

 * @rst
 * .. note:: Does not guarantee to undo the previous writes (they might have been
 *           performed in-place). However, it releases the underlying resources and
 *           frees the given ``TextSave`` pointer which must no longer be used.
 * @endrst
 */
void text_save_cancel(TextSave*);

 * Write whole text content to file descriptor.
 * @return The number of bytes written or ``-1`` in case of an error.
 */
ssize_t text_write(const Text*, int fd);
/**
 * Write file range to file descriptor.
 * @return The number of bytes written or ``-1`` in case of an error.
 */
ssize_t text_write_range(const Text*, const Filerange*, int fd);
/**
 * @}
 * @defgroup misc

 * Check whether ``ptr`` is part of a memory mapped region associated with
 * this text instance.
 */
bool text_mmaped(const Text*, const char *ptr);
/** @} */

#endif

Lines 7-13 Link Here

(-)vis-0.6/ui.h (-1 / +1 lines)
7		7
8	/* enable large file optimization for files larger than: */	8	/* enable large file optimization for files larger than: */
9	#define UI_LARGE_FILE_SIZE (1 << 25)	9	#define UI_LARGE_FILE_SIZE (1 << 25)
10	/* enable large file optimization fo files containing lines longer than: */	10	/* enable large file optimization for files containing lines longer than: */
11	#define UI_LARGE_FILE_LINE_SIZE (1 << 16)	11	#define UI_LARGE_FILE_LINE_SIZE (1 << 16)
12		12
13	typedef struct Ui Ui;	13	typedef struct Ui Ui;

Lines 358-364 Link Here

(-)vis-0.6/view.c (-3 / +6 lines)
358	cell = (Cell){ .data = "\xEF\xBF\xBD", .len = len, .width = 1 };	358	cell = (Cell){ .data = "\xEF\xBF\xBD", .len = len, .width = 1 };
359	} else if (len == (size_t)-2) {	359	} else if (len == (size_t)-2) {
360	/* not enough bytes available to convert to a	360	/* not enough bytes available to convert to a
361	* wide character. advance file position and read	361	* wide character. Advance file position and read
362	* another junk into buffer.	362	* another junk into buffer.
363	*/	363	*/
364	rem = text_bytes_get(view->text, pos+prev_cell.len, size, text);	364	rem = text_bytes_get(view->text, pos+prev_cell.len, size, text);
Lines 1196-1203 Link Here
1196	}	1196	}
1197		1197
1198	void view_selections_dispose_all(View *view) {	1198	void view_selections_dispose_all(View *view) {
1199	for (Selection s = view->selections, next; s; s = next) {	1199	Selection *last = view->selections;
1200	next = s->next;	1200	while (last->next)
		1201	last = last->next;
		1202	for (Selection s = last, prev; s; s = prev) {
		1203	prev = s->prev;
1201	if (s != view->selection)	1204	if (s != view->selection)
1202	selection_free(s);	1205	selection_free(s);
1203	}	1206	}




/**
 * Get window coordinate of text position.
 * @param pos The position to query.
 * @param line Will be updated with screen line on which ``pos`` resides.
 * @param row Will be updaded with zero based window row on which ``pos`` resides.
 * @param col Will be updated with zero based window column on which ``pos`` resides.
 * @return Whether ``pos`` is visible. If not, the pointer arguments are left unmodified.
 */
bool view_coord_get(View*, size_t pos, Line **line, int *row, int *col);
/** Get position at the start of the ``n``-th window line, counting from 1. */
size_t view_screenline_goto(View*, int n);
/** Get first screen line. */
Line *view_lines_first(View*);

/**
 * Dispose an existing selection.
 * @rst
 * .. warning:: Not applicable for the last existing selection.
 * @endrst
 */
bool view_selections_dispose(Selection*);

 * Query state of primary selection.
 *
 * If the primary selection was marked for destruction, return it and
 * clear destruction flag.
 */
Selection *view_selection_disposed(View*);
/** Dispose all but the primary selection. */

void view_selections_normalize(View*);
/**
 * Replace currently active selections.
 * @param array The array of ``Filerange`` objects.
 * @param anchored Whether *all* selection should be anchored.
 */
void view_selections_set_all(View*, Array*, bool anchored);

/**
 * Get selection index.
 * @rst
 * .. note:: Is always in range ``[0, count-1]``.
 * .. warning: The relative order is determined during creation and assumed
 *             to remain the same.
 * @endrst

/**
 * Get zero based index of screen cell on which selection cursor currently resides.
 * @rst
 * .. warning:: Returns ``-1`` if the selection cursor is currently not visible.
 * @endrst
 */
int view_cursors_cell_get(Selection*);

 */
/**
 * Move primary selection cursor to the given position.
 * Makes sure that position is visible.
 * @rst
 * .. note:: If position was not visible before, we attempt to show
 *           surrounding context. The viewport will be adjusted such

Lines 8-17 Link Here

(-)vis-0.6/vis-clipboard (-11 / +46 lines)
8	}	8	}
9		9
10	vc_usage() {	10	vc_usage() {
11	vc_fatal "`basename $0` [--usable\|--copy\|--paste]"	11	vc_fatal "`basename $0` [--selection sel] [--usable\|--copy\|--paste]"
12	}	12	}
13		13
14	vc_determine_command() {	14	vc_determine_command() {
		15	if [ -n "$WAYLAND_DISPLAY" ]; then
		16	for c in wl-copy wl-paste; do
		17	if type "$c" >/dev/null 2>&1; then
		18	echo "wlclipboard"
		19	return 0
		20	fi
		21	done
		22	fi
		23
15	if [ -n "$DISPLAY" ]; then	24	if [ -n "$DISPLAY" ]; then
16	for c in xclip xsel; do	25	for c in xclip xsel; do
17	if type "$c" >/dev/null 2>&1; then	26	if type "$c" >/dev/null 2>&1; then
Lines 21-26 Link Here
21	done	30	done
22	fi	31	fi
23		32
		33	if [ "$sel" = "primary" ]; then
		34	vc_fatal "clipboard primary selection is not supported on your platform"
		35	fi
		36
24	if type pbcopy >/dev/null 2>&1; then	37	if type pbcopy >/dev/null 2>&1; then
25	echo 'mac'	38	echo 'mac'
26	return 0	39	return 0
Lines 66-85 Link Here
66	exit $?	79	exit $?
67	}	80	}
68		81
		82	vc_wlclipboard_copy() {
		83	if [ "$sel" = "primary" ]; then
		84	wl-copy --primary -t TEXT
		85	else
		86	wl-copy -t TEXT
		87	fi
		88	}
		89
		90	vc_wlclipboard_paste() {
		91	if [ "$sel" = "primary" ]; then
		92	wl-paste --primary -t text
		93	else
		94	wl-paste -t text
		95	fi
		96	}
		97
69	vc_xsel_copy() {	98	vc_xsel_copy() {
70	xsel -bi	99	xsel --"$sel" -bi
71	}	100	}
72		101
73	vc_xsel_paste() {	102	vc_xsel_paste() {
74	xsel -bo	103	xsel --"$sel" -bo
75	}	104	}
76		105
77	vc_xclip_copy() {	106	vc_xclip_copy() {
78	xclip -selection clipboard -i >/dev/null 2>&1	107	xclip -selection "$sel" -i >/dev/null 2>&1
79	}	108	}
80		109
81	vc_xclip_paste() {	110	vc_xclip_paste() {
82	xclip -selection clipboard -o	111	xclip -selection "$sel" -o
83	}	112	}
84		113
85	vc_mac_copy() {	114	vc_mac_copy() {
Lines 98-108 Link Here
98	cat /dev/clipboard	127	cat /dev/clipboard
99	}	128	}
100		129
101	case "$1" in	130	while [ $# -gt 0 ]; do
102	--usable) vc_usable;;	131	case "$1" in
103	--copy) vc_copy;;	132	--usable) fn=vc_usable;;
104	--paste) vc_paste;;	133	--copy) fn=vc_copy;;
105	*) ;;	134	--paste) fn=vc_paste;;
106	esac	135	--selection) shift; sel="$1";;
		136	*) ;;
		137	esac
		138	shift
		139	done
		140
		141	sel=${sel:-"clipboard"} $fn
107		142
108	vc_usage	143	vc_usage

Lines 361-366 Link Here

(-)vis-0.6/vis-cmds.c (-1 / +5 lines)
361	windows_arrange(vis, layout);	361	windows_arrange(vis, layout);
362	break;	362	break;
363	}	363	}
		364	case OPTION_IGNORECASE:
		365	vis->ignorecase = toggle ? !vis->ignorecase : arg.b;
		366	break;
364	default:	367	default:
365	if (!opt->func)	368	if (!opt->func)
366	return false;	369	return false;
Lines 616-624 Link Here
616	}	619	}
617	}	620	}
618		621
		622	struct tm tm;
619	time_t state = text_state(txt);	623	time_t state = text_state(txt);
620	char buf[32];	624	char buf[32];
621	strftime(buf, sizeof buf, "State from %H:%M", localtime(&state));	625	strftime(buf, sizeof buf, "State from %H:%M", localtime_r(&state, &tm));
622	vis_info_show(vis, "%s", buf);	626	vis_info_show(vis, "%s", buf);
623		627
624	return pos != EPOS;	628	return pos != EPOS;





/* a mode contains a set of key bindings which are currently valid.
 *
 * each mode can specify one parent mode which is consulted if a given key
 * is not found in the current mode. hence the modes form a tree which is
 * searched from the current mode up towards the root mode until a valid binding
 * is found.

};

typedef struct {
	/* operator logic, returns new cursor position, if EPOS
	 * the cursor is disposed (except if it is the primary one) */
	VisOperatorFunction *func;
	void *context;
} Operator;

typedef struct { /* Motion implementation, takes a cursor position and returns a new one */
	/* TODO: merge types / use union to save space */
	size_t (*cur)(Selection*);
	size_t (*txt)(Text*, size_t pos);

};

struct Win {
	Vis *vis;               /* editor instance to which this window belongs */
	UiWin *ui;              /* ui object handling visual appearance of this window */
	File *file;             /* file being displayed in this window */
	View *view;             /* currently displayed part of underlying text */

};

struct Vis {
	Ui *ui;                              /* user interface responsible for visual appearance */
	File *files;                         /* all files currently managed by this editor instance */
	File *command_file;                  /* special internal file used to store :-command prompt */
	File *search_file;                   /* special internal file used to store /,? search prompt */

	Action action;                       /* current action which is in progress */
	Action action_prev;                  /* last operator action used by the repeat (dot) command */
	Mode *mode;                          /* currently active mode, used to search for keybindings */
	Mode *mode_prev;                     /* previously active user mode */
	bool initialized;                    /* whether UI and Lua integration has been initialized */
	int nesting_level;                   /* parsing state to hold keep track of { } nesting level */
	volatile bool running;               /* exit main loop once this becomes false */
	int exit_status;                     /* exit status when terminating main loop */
	volatile sig_atomic_t interrupted;   /* abort command (SIGINT occured) */
	volatile sig_atomic_t sigbus;        /* one of the memory mapped regions became unavailable (SIGBUS) */
	volatile sig_atomic_t need_resize;   /* need to resize UI (SIGWINCH occured) */
	volatile sig_atomic_t resume;        /* need to resume UI (SIGCONT occured) */
	volatile sig_atomic_t terminate;     /* need to terminate we were being killed by SIGTERM */
	sigjmp_buf sigbus_jmpbuf;            /* used to jump back to a known good state in the mainloop after (SIGBUS) */
	Map *actions;                        /* registered editor actions / special keys commands */
	Array actions_user;                  /* dynamically allocated editor actions */
	lua_State *lua;                      /* lua context used for syntax highlighting */
	enum TextLoadMethod load_method;     /* how existing files should be loaded */
	VisEvent *event;
	Array operators;
	Array motions;
	Array textobjects;
	Array bindings;
	bool ignorecase;                     /* whether to ignore case when searching */
};

enum VisEvents {

	VIS_EVENT_WIN_CLOSE,
	VIS_EVENT_WIN_HIGHLIGHT,
	VIS_EVENT_WIN_STATUS,
	VIS_EVENT_TERM_CSI,
};

bool vis_event_emit(Vis*, enum VisEvents, ...);


typedef MarkDef RegisterDef;

/** stuff used by several of the vis-* files */

extern Mode vis_modes[VIS_MODE_INVALID];
extern const Movement vis_motions[VIS_MOVE_INVALID];




void vis_lua_win_close(Vis *vis, Win *win) { }
void vis_lua_win_highlight(Vis *vis, Win *win) { }
void vis_lua_win_status(Vis *vis, Win *win) { window_status_update(vis, win); }
void vis_lua_term_csi(Vis *vis, const long *csi) { }

#else


	lua_getfield(L, LUA_REGISTRYINDEX, "vis.types");
	lua_getmetatable(L, -2);
	lua_gettable(L, -2);
	// XXX: in theory string might become invalid when popped from stack
	const char *type = lua_tostring(L, -1);
	lua_pop(L, 2);
	return type;

 * @usage
 * local marks = vis.win.marks
 * for name in vis:mark_names() do
 * 	local mark = marks[name]
 * 	for i = 1, #mark do
 * 		-- do somthing with: name, mark[i].start, mark[i].finish
 * 	end
 * end
 */
static int mark_names_iter(lua_State *L);
static int mark_names(lua_State *L) {
	Vis *vis = obj_ref_check(L, 1, "vis");
	lua_pushlightuserdata(L, vis);
	enum VisMark *handle = lua_newuserdata(L, sizeof *handle);
	*handle = 0;
	lua_pushcclosure(L, mark_names_iter, 2);
	return 1;
}

static int mark_names_iter(lua_State *L) {
	Vis *vis = lua_touserdata(L, lua_upvalueindex(1));
	enum VisMark *handle = lua_touserdata(L, lua_upvalueindex(2));
	char mark = vis_mark_to(vis, *handle);
		mark = vis_marks[*handle].name;
	else if (VIS_MARK_a <= *handle && *handle <= VIS_MARK_z)
		mark = 'a' + *handle - VIS_MARK_a;
	if (mark) {
		lua_pushlstring(L, &mark, 1);
		lua_pushstring(L, name);
		(*handle)++;
		return 1;
	}

 */
static int register_names_iter(lua_State *L);
static int register_names(lua_State *L) {
	Vis *vis = obj_ref_check(L, 1, "vis");
	lua_pushlightuserdata(L, vis);
	enum VisRegister *handle = lua_newuserdata(L, sizeof *handle);
	*handle = 0;
	lua_pushcclosure(L, register_names_iter, 2);
	return 1;
}

static int register_names_iter(lua_State *L) {
	Vis *vis = lua_touserdata(L, lua_upvalueindex(1));
	enum VisRegister *handle = lua_touserdata(L, lua_upvalueindex(2));
	char reg = vis_register_to(vis, *handle);
		reg = vis_registers[*handle].name;
	else if (VIS_REG_a <= *handle && *handle <= VIS_REG_z)
		reg = 'a' + *handle - VIS_REG_a;
	if (reg) {
		lua_pushlstring(L, &reg, 1);
		lua_pushstring(L, name);
		(*handle)++;
		return 1;
	}

 * Display a short message.
 *
 * The single line message will be displayed at the bottom of
 * the screen and automatically hidden once a key is pressed.
 *
 * @function info
 * @tparam string message the message to display

 * eventually hands over control to the editor core. The exit status
 * of the most recent call is used.
 *
 * All unsaved changes will be lost!
 *
 * @function exit
 * @tparam int code the exit status returned to the operating system

 *
 * Will trigger redraw events, make sure to avoid recursive events.
 *
 * @function redraw
 */
static int redraw(lua_State *L) {
	Vis *vis = obj_ref_check(L, 1, "vis");

 * Currently unconsumed keys in the input queue.
 * @tfield string input_queue
 */
/***
 * Register name in use.
 * @tfield string register
 */
/***
 * Mark name in use.
 * @tfield string mark
 */
static int vis_index(lua_State *L) {
	Vis *vis = obj_ref_check(L, 1, "vis");


			return 1;
		}

		if (strcmp(key, "register") == 0) {
			char name = vis_register_to(vis, vis_register_used(vis));
			lua_pushlstring(L, &name, 1);
			return 1;
		}

		if (strcmp(key, "registers") == 0) {
			obj_ref_new(L, vis->ui, VIS_LUA_TYPE_REGISTERS);
			return 1;
		}

		if (strcmp(key, "mark") == 0) {
			char name = vis_mark_to(vis, vis_mark_used(vis));
			lua_pushlstring(L, &name, 1);
			return 1;
		}

		if (strcmp(key, "ui") == 0) {
			obj_ref_new(L, vis->ui, VIS_LUA_TYPE_UI);
			return 1;

			vis_window_focus(obj_ref_check(L, 3, VIS_LUA_TYPE_WINDOW));
			return 0;
		}

		if (strcmp(key, "register") == 0) {
			const char *name = luaL_checkstring(L, 3);
			if (strlen(name) == 1)
				vis_register(vis, vis_register_from(vis, name[0]));
			return 0;
		}

		if (strcmp(key, "mark") == 0) {
			const char *name = luaL_checkstring(L, 3);
			if (strlen(name) == 1)
				vis_mark(vis, vis_mark_from(vis, name[0]));
			return 0;
		}
	}
	return newindex_common(L);
}

 * File state.
 * @tfield bool modified whether the file contains unsaved changes
 */
/***
 * File permission.
 * @tfield int permission the file permission bits as of the most recent load/save
 */
static int file_index(lua_State *L) {
	File *file = obj_ref_check(L, 1, VIS_LUA_TYPE_FILE);


			lua_pushboolean(L, text_modified(file->text));
			return 1;
		}

		if (strcmp(key, "permission") == 0) {
			struct stat stat = text_stat(file->text);
			lua_pushunsigned(L, stat.st_mode & 0777);
			return 1;
		}
	}

	return index_common(L);
}

static int file_newindex(lua_State *L) {
	File *file = obj_ref_check(L, 1, VIS_LUA_TYPE_FILE);

	if (lua_isstring(L, 2)) {
		const char *key = lua_tostring(L, 2);

		if (strcmp(key, "modified") == 0) {
			bool modified = lua_isboolean(L, 3) && lua_toboolean(L, 3);
			if (modified) {
				text_insert(file->text, 0, " ", 1);
				text_delete(file->text, 0, 1);
			} else {
				text_save(file->text, NULL);
			}
			return 0;
		}
	}

	return newindex_common(L);
}

/***
 * Insert data at position.
 * @function insert


static const struct luaL_Reg file_funcs[] = {
	{ "__index", file_index },
	{ "__newindex", file_newindex },
	{ "insert", file_insert },
	{ "delete", file_delete },
	{ "lines_iterator", file_lines_iterator },

 * Input key event in either input or replace mode.
 * @function input
 * @tparam string key
 * @treturn bool whether the key was consumed or not
 */
static bool vis_lua_input(Vis *vis, const char *key, size_t len) {
	lua_State *L = vis->lua;

		pcall(vis, L, 1, 0);
	} else {
		window_status_update(vis, win);
	}
	lua_pop(L, 1);
}

/***
 * CSI command received from terminal.
 * @function term_csi
 * @param List of CSI parameters
 */
void vis_lua_term_csi(Vis *vis, const long *csi) {
	lua_State *L = vis->lua;
	if (!L)
		return;
	vis_lua_event_get(L, "term_csi");
	if (lua_isfunction(L, -1)) {
		int nargs = csi[1];
		lua_pushinteger(L, csi[0]);
		for (int i = 0; i < nargs; i++)
			lua_pushinteger(L, csi[2 + i]);
		pcall(vis, L, 1 + nargs, 0);
	}
	lua_pop(L, 1);
}

Lines 37-41 Link Here

(-)vis-0.6/vis-lua.h (+1 lines)
37	void vis_lua_win_close(Vis, Win);	37	void vis_lua_win_close(Vis, Win);
38	void vis_lua_win_highlight(Vis, Win);	38	void vis_lua_win_highlight(Vis, Win);
39	void vis_lua_win_status(Vis, Win);	39	void vis_lua_win_status(Vis, Win);
		40	void vis_lua_term_csi(Vis, const long );
40		41
41	#endif	42	#endif




	return VIS_MARK_INVALID;
}

char vis_mark_to(Vis *vis, enum VisMark mark) {
	if (VIS_MARK_a <= mark && mark <= VIS_MARK_z)
		return 'a' + mark - VIS_MARK_a;

	if (mark < LENGTH(vis_marks))
		return vis_marks[mark].name;

	return '\0';
}

const MarkDef vis_marks[] = {
	[VIS_MARK_DEFAULT]        = { '\'', VIS_HELP("Default mark")    },
	[VIS_MARK_SELECTION]      = { '^',  VIS_HELP("Last selections") },




	                        VIS_MOVE_LONGWORD_END_NEXT, isspace);
}

static size_t to_right(Vis *vis, Text *txt, size_t pos) {
	char c;
	size_t hit = text_find_next(txt, pos+1, vis->search_char);
	if (!text_byte_get(txt, hit, &c) || c != vis->search_char[0])
		return pos;
	return hit;
}

static size_t till_right(Vis *vis, Text *txt, size_t pos) {
	size_t hit = to_right(vis, txt, pos+1);
	if (hit != pos)
		return text_char_prev(txt, hit);
	return pos;
}

static size_t to_left(Vis *vis, Text *txt, size_t pos) {
	return text_find_prev(txt, pos, vis->search_char);
}

static size_t till_left(Vis *vis, Text *txt, size_t pos) {
	size_t hit = to_left(vis, txt, pos-1);
	if (hit != pos-1)
		return text_char_next(txt, hit);
	return pos;
}

static size_t to_line_right(Vis *vis, Text *txt, size_t pos) {
	char c;
	if (pos == text_line_end(txt, pos))
		return pos;
	size_t hit = text_line_find_next(txt, pos+1, vis->search_char);

	return hit;
}

static size_t till_line_right(Vis *vis, Text *txt, size_t pos) {
	size_t hit = to_line_right(vis, txt, pos+1);
	if (pos == text_line_end(txt, pos))
		return pos;
	if (hit != pos)

	return pos;
}

static size_t to_line_left(Vis *vis, Text *txt, size_t pos) {
	return text_line_find_prev(txt, pos, vis->search_char);
}

static size_t till_line_left(Vis *vis, Text *txt, size_t pos) {
	if (pos == text_line_begin(txt, pos))
		return pos;
	size_t hit = to_line_left(vis, txt, pos-1);
	if (hit != pos-1)
		return text_char_next(txt, hit);
	return pos;

		}
		break;
	}
	case VIS_MOVE_TO_RIGHT:
	case VIS_MOVE_TO_LEFT:
	case VIS_MOVE_TO_LINE_RIGHT:
	case VIS_MOVE_TO_LINE_LEFT:
	case VIS_MOVE_TILL_RIGHT:
	case VIS_MOVE_TILL_LEFT:
	case VIS_MOVE_TILL_LINE_RIGHT:
	case VIS_MOVE_TILL_LINE_LEFT:
	{
		const char *key = va_arg(ap, char*);
		if (!key)

		break;
	case VIS_MOVE_TOTILL_REVERSE:
		switch (vis->last_totill) {
		case VIS_MOVE_TO_RIGHT:
			motion = VIS_MOVE_TO_LEFT;
			break;
		case VIS_MOVE_TO_LEFT:
			motion = VIS_MOVE_TO_RIGHT;
			break;
		case VIS_MOVE_TO_LINE_RIGHT:
			motion = VIS_MOVE_TO_LINE_LEFT;
			break;
		case VIS_MOVE_TO_LINE_LEFT:
			motion = VIS_MOVE_TO_LINE_RIGHT;
			break;
		case VIS_MOVE_TILL_RIGHT:
			motion = VIS_MOVE_TILL_LEFT;
			break;
		case VIS_MOVE_TILL_LEFT:
			motion = VIS_MOVE_TILL_RIGHT;
			break;
		case VIS_MOVE_TILL_LINE_RIGHT:
			motion = VIS_MOVE_TILL_LINE_LEFT;
			break;
		case VIS_MOVE_TILL_LINE_LEFT:
			motion = VIS_MOVE_TILL_LINE_RIGHT;
			break;
		default:
			goto err;
		}

		.txt = lastline,
		.type = LINEWISE|LINEWISE_INCLUSIVE|JUMP|IDEMPOTENT,
	},
	[VIS_MOVE_TO_LEFT] = {
		.vis = to_left,
		.type = COUNT_EXACT,
	},
	[VIS_MOVE_TO_RIGHT] = {
		.vis = to_right,
		.type = INCLUSIVE|COUNT_EXACT,
	},
	[VIS_MOVE_TO_LINE_LEFT] = {
		.vis = to_line_left,
		.type = COUNT_EXACT,
	},
	[VIS_MOVE_TO_LINE_RIGHT] = {
		.vis = to_line_right,
		.type = INCLUSIVE|COUNT_EXACT,
	},
	[VIS_MOVE_TILL_LEFT] = {
		.vis = till_left,
		.type = COUNT_EXACT,
	},
	[VIS_MOVE_TILL_RIGHT] = {
		.vis = till_right,
		.type = INCLUSIVE|COUNT_EXACT,
	},
	[VIS_MOVE_TILL_LINE_LEFT] = {
		.vis = till_line_left,
		.type = COUNT_EXACT,
	},
	[VIS_MOVE_TILL_LINE_RIGHT] = {
		.vis = till_line_right,
		.type = INCLUSIVE|COUNT_EXACT,
	},
	[VIS_MOVE_SEARCH_WORD_FORWARD] = {




VIS_MENU_PROMPT=""
ALLOW_AUTO_SELECT=1

wrap_dirs() {
	local o

	while read o
	do
		[ -d "$o" ] && printf "%s/\n" "$o" || printf "%s\n" "$o"
	done
}

while [ $# -gt 0 ]; do
	case "$1" in
	-h|--help)


# At this point, we have a bunch of options we need to present to the
# user so they can pick one.
CHOICE=$(printf "%s\n" "$@" | wrap_dirs | vis-menu -b -p "$VIS_MENU_PROMPT")

# Did they pick a file or directory? Who knows, let's let the next iteration figure it out.
exec "$0" -p "$VIS_MENU_PROMPT" -- "$CHOICE"

Lines 63-69 Link Here

(-)vis-0.6/vis-prompt.c (-1 / +2 lines)
63	pattern = "^:";	63	pattern = "^:";
64	else if (prompt->file == vis->search_file)	64	else if (prompt->file == vis->search_file)
65	pattern = "^(/\|\\?)";	65	pattern = "^(/\|\\?)";
66	if (pattern && regex && text_regex_compile(regex, pattern, REG_EXTENDED\|REG_NEWLINE) == 0) {	66	int cflags = REG_EXTENDED\|REG_NEWLINE\|(REG_ICASE*vis->ignorecase);
		67	if (pattern && regex && text_regex_compile(regex, pattern, cflags) == 0) {
67	size_t end = text_line_end(txt, pos);	68	size_t end = text_line_end(txt, pos);
68	size_t prev = text_search_backward(txt, end, regex);	69	size_t prev = text_search_backward(txt, end, regex);
69	if (prev > pos)	70	if (prev > pos)

Lines 69-84 Link Here

(-)vis-0.6/vis-registers.c (-9 / +37 lines)
69	case REGISTER_CLIPBOARD:	69	case REGISTER_CLIPBOARD:
70	{	70	{
71	Buffer buferr;	71	Buffer buferr;
		72	enum VisRegister id = reg - vis->registers;
		73	const char *cmd[] = { VIS_CLIPBOARD, "--paste", "--selection", NULL, NULL };
72	buffer_init(&buferr);	74	buffer_init(&buferr);
73	Buffer *buf = array_get(&reg->values, slot);	75	Buffer *buf = array_get(&reg->values, slot);
74	if (!buf)	76	if (!buf)
75	return NULL;	77	return NULL;
76	buffer_clear(buf);	78	buffer_clear(buf);
77		79
		80	if (id == VIS_REG_PRIMARY)
		81	cmd[3] = "primary";
		82	else
		83	cmd[3] = "clipboard";
78	int status = vis_pipe(vis, vis->win->file,	84	int status = vis_pipe(vis, vis->win->file,
79	&(Filerange){ .start = 0, .end = 0 },	85	&(Filerange){ .start = 0, .end = 0 },
80	(const char*[]){ VIS_CLIPBOARD, "--paste", NULL },	86	cmd, buf, read_buffer, &buferr, read_buffer);
81	buf, read_buffer, &buferr, read_buffer);
82		87
83	if (status != 0)	88	if (status != 0)
84	vis_info_show(vis, "Command failed %s", buffer_content0(&buferr));	89	vis_info_show(vis, "Command failed %s", buffer_content0(&buferr));
Lines 152-162 Link Here
152	case REGISTER_CLIPBOARD:	157	case REGISTER_CLIPBOARD:
153	{	158	{
154	Buffer buferr;	159	Buffer buferr;
		160	const char *cmd[] = { VIS_CLIPBOARD, "--copy", "--selection", NULL, NULL };
		161	enum VisRegister id = reg - vis->registers;
155	buffer_init(&buferr);	162	buffer_init(&buferr);
156		163
		164	if (id == VIS_REG_PRIMARY)
		165	cmd[3] = "primary";
		166	else
		167	cmd[3] = "clipboard";
		168
157	int status = vis_pipe(vis, vis->win->file, range,	169	int status = vis_pipe(vis, vis->win->file, range,
158	(const char*[]){ VIS_CLIPBOARD, "--copy", NULL },	170	cmd, NULL, NULL, &buferr, read_buffer);
159	NULL, NULL, &buferr, read_buffer);
160		171
161	if (status != 0)	172	if (status != 0)
162	vis_info_show(vis, "Command failed %s", buffer_content0(&buferr));	173	vis_info_show(vis, "Command failed %s", buffer_content0(&buferr));
Lines 186-200 Link Here
186	}	197	}
187		198
188	enum VisRegister vis_register_from(Vis *vis, char reg) {	199	enum VisRegister vis_register_from(Vis *vis, char reg) {
189	switch (reg) {
190	case '+': return VIS_REG_CLIPBOARD;
191	case '@': return VIS_MACRO_LAST_RECORDED;
192	}
193		200
		201	if (reg == '@')
		202	return VIS_MACRO_LAST_RECORDED;
		203
194	if ('a' <= reg && reg <= 'z')	204	if ('a' <= reg && reg <= 'z')
195	return VIS_REG_a + reg - 'a';	205	return VIS_REG_a + reg - 'a';
196	if ('A' <= reg && reg <= 'Z')	206	if ('A' <= reg && reg <= 'Z')
197	return VIS_REG_A + reg - 'A';	207	return VIS_REG_A + reg - 'A';
		208
198	for (size_t i = 0; i < LENGTH(vis_registers); i++) {	209	for (size_t i = 0; i < LENGTH(vis_registers); i++) {
199	if (vis_registers[i].name == reg)	210	if (vis_registers[i].name == reg)
200	return i;	211	return i;
Lines 202-207 Link Here
202	return VIS_REG_INVALID;	213	return VIS_REG_INVALID;
203	}	214	}
204		215
		216	char vis_register_to(Vis *vis, enum VisRegister reg) {
		217
		218	if (reg == VIS_MACRO_LAST_RECORDED)
		219	return '@';
		220
		221	if (VIS_REG_a <= reg && reg <= VIS_REG_z)
		222	return 'a' + reg - VIS_REG_a;
		223	if (VIS_REG_A <= reg && reg <= VIS_REG_Z)
		224	return 'A' + reg - VIS_REG_A;
		225
		226	if (reg < LENGTH(vis_registers))
		227	return vis_registers[reg].name;
		228
		229	return '\0';
		230	}
		231
205	void vis_register(Vis *vis, enum VisRegister reg) {	232	void vis_register(Vis *vis, enum VisRegister reg) {
206	if (VIS_REG_A <= reg && reg <= VIS_REG_Z) {	233	if (VIS_REG_A <= reg && reg <= VIS_REG_Z) {
207	vis->action.reg = &vis->registers[VIS_REG_a + reg - VIS_REG_A];	234	vis->action.reg = &vis->registers[VIS_REG_a + reg - VIS_REG_A];
Lines 275-281 Link Here
275	[VIS_REG_9] = { '9', VIS_HELP("9th sub-expression match") },	302	[VIS_REG_9] = { '9', VIS_HELP("9th sub-expression match") },
276	[VIS_REG_AMPERSAND] = { '&', VIS_HELP("Last regex match") },	303	[VIS_REG_AMPERSAND] = { '&', VIS_HELP("Last regex match") },
277	[VIS_REG_BLACKHOLE] = { '_', VIS_HELP("/dev/null register") },	304	[VIS_REG_BLACKHOLE] = { '_', VIS_HELP("/dev/null register") },
278	[VIS_REG_CLIPBOARD] = { '*', VIS_HELP("System clipboard register, see vis-clipboard(1)") },	305	[VIS_REG_PRIMARY] = { '*', VIS_HELP("Primary clipboard register, see vis-clipboard(1)") },
		306	[VIS_REG_CLIPBOARD] = { '+', VIS_HELP("System clipboard register, see vis-clipboard(1)") },
279	[VIS_REG_DOT] = { '.', VIS_HELP("Last inserted text") },	307	[VIS_REG_DOT] = { '.', VIS_HELP("Last inserted text") },
280	[VIS_REG_SEARCH] = { '/', VIS_HELP("Last search pattern") },	308	[VIS_REG_SEARCH] = { '/', VIS_HELP("Last search pattern") },
281	[VIS_REG_COMMAND] = { ':', VIS_HELP("Last :-command") },	309	[VIS_REG_COMMAND] = { ':', VIS_HELP("Last :-command") },




		.txt = object_backtick,
		.type = TEXTOBJECT_DELIMITED_INNER,
	},
	[VIS_TEXTOBJECT_OUTER_ENTIRE] = {
		.txt = text_object_entire,
	},
	[VIS_TEXTOBJECT_INNER_ENTIRE] = {
		.txt = text_object_entire_inner,
        },
	[VIS_TEXTOBJECT_OUTER_LINE] = {
		.txt = text_object_line,
	},

Lines 100-105 Link Here

(-)vis-0.6/vis.c (-6 / +24 lines)
100	if (vis->event->quit)	100	if (vis->event->quit)
101	vis->event->quit(vis);	101	vis->event->quit(vis);
102	break;	102	break;
		103	case VIS_EVENT_TERM_CSI:
		104	if (vis->event->term_csi)
		105	vis->event->term_csi(vis, va_arg(ap, const long *));
		106	break;
103	}	107	}
104		108
105	va_end(ap);	109	va_end(ap);
Lines 675-680 Link Here
675	register_init(&vis->registers[i]);	679	register_init(&vis->registers[i]);
676	vis->registers[VIS_REG_BLACKHOLE].type = REGISTER_BLACKHOLE;	680	vis->registers[VIS_REG_BLACKHOLE].type = REGISTER_BLACKHOLE;
677	vis->registers[VIS_REG_CLIPBOARD].type = REGISTER_CLIPBOARD;	681	vis->registers[VIS_REG_CLIPBOARD].type = REGISTER_CLIPBOARD;
		682	vis->registers[VIS_REG_PRIMARY].type = REGISTER_CLIPBOARD;
678	vis->registers[VIS_REG_NUMBER].type = REGISTER_NUMBER;	683	vis->registers[VIS_REG_NUMBER].type = REGISTER_NUMBER;
679	array_init(&vis->operators);	684	array_init(&vis->operators);
680	array_init(&vis->motions);	685	array_init(&vis->motions);
Lines 1013-1019 Link Here
1013	register_resize(reg, last_reg_slot+1);	1018	register_resize(reg, last_reg_slot+1);
1014	}	1019	}
1015		1020
1016	/* we do not support visual repeat, still do something resonable */	1021	/* we do not support visual repeat, still do something reasonable */
1017	if (vis->mode->visual && !a->movement && !a->textobj)	1022	if (vis->mode->visual && !a->movement && !a->textobj)
1018	a->movement = &vis_motions[VIS_MOVE_NOP];	1023	a->movement = &vis_motions[VIS_MOVE_NOP];
1019		1024
Lines 1303-1308 Link Here
1303	}	1308	}
1304		1309
1305	TermKey *termkey = vis->ui->termkey_get(vis->ui);	1310	TermKey *termkey = vis->ui->termkey_get(vis->ui);
		1311	if (key.type == TERMKEY_TYPE_UNKNOWN_CSI) {
		1312	long args[18];
		1313	size_t nargs;
		1314	unsigned long cmd;
		1315	if (termkey_interpret_csi(termkey, &key, &args[2], &nargs, &cmd) == TERMKEY_RES_KEY) {
		1316	args[0] = (long)cmd;
		1317	args[1] = nargs;
		1318	vis_event_emit(vis, VIS_EVENT_TERM_CSI, args);
		1319	}
		1320	return getkey(vis);
		1321	}
1306	termkey_strfkey(termkey, vis->key, sizeof(vis->key), &key, TERMKEY_FORMAT_VIM);	1322	termkey_strfkey(termkey, vis->key, sizeof(vis->key), &key, TERMKEY_FORMAT_VIM);
1307	return vis->key;	1323	return vis->key;
1308	}	1324	}
Lines 1380-1386 Link Here
1380	vis_die(vis, "Killed by SIGTERM\n");	1396	vis_die(vis, "Killed by SIGTERM\n");
1381	if (vis->interrupted) {	1397	if (vis->interrupted) {
1382	vis->interrupted = false;	1398	vis->interrupted = false;
1383	vis_keys_feed(vis, "<C-c>");	1399	vis_keys_push(vis, "<C-c>", 0, true);
		1400	continue;
1384	}	1401	}
1385		1402
1386	if (vis->resume) {	1403	if (vis->resume) {
Lines 1669-1675 Link Here
1669	size_t newpos = vis_text_insert_nl(vis, txt, pos);	1686	size_t newpos = vis_text_insert_nl(vis, txt, pos);
1670	/* This is a bit of a hack to fix cursor positioning when	1687	/* This is a bit of a hack to fix cursor positioning when
1671	* inserting a new line at the start of the view port.	1688	* inserting a new line at the start of the view port.
1672	* It has the effect of reseting the mark used by the view	1689	* It has the effect of resetting the mark used by the view
1673	* code to keep track of the start of the visible region.	1690	* code to keep track of the start of the visible region.
1674	*/	1691	*/
1675	view_cursors_to(s, pos);	1692	view_cursors_to(s, pos);
Lines 1684-1690 Link Here
1684	Regex *regex = text_regex_new();	1701	Regex *regex = text_regex_new();
1685	if (!regex)	1702	if (!regex)
1686	return NULL;	1703	return NULL;
1687	if (text_regex_compile(regex, pattern, REG_EXTENDED\|REG_NEWLINE) != 0) {	1704	int cflags = REG_EXTENDED\|REG_NEWLINE\|(REG_ICASE*vis->ignorecase);
		1705	if (text_regex_compile(regex, pattern, cflags) != 0) {
1688	text_regex_free(regex);	1706	text_regex_free(regex);
1689	return NULL;	1707	return NULL;
1690	}	1708	}
Lines 1842-1849 Link Here
1842	if (len > 0) {	1860	if (len > 0) {
1843	rout.start += len;	1861	rout.start += len;
1844	if (text_range_size(&rout) == 0) {	1862	if (text_range_size(&rout) == 0) {
1845	close(pout[1]);	1863	close(pin[1]);
1846	pout[1] = -1;	1864	pin[1] = -1;
1847	}	1865	}
1848	} else {	1866	} else {
1849	close(pin[1]);	1867	close(pin[1]);




	void (*win_close)(Vis*, Win*);
	void (*win_highlight)(Vis*, Win*);
	void (*win_status)(Vis*, Win*);
	void (*term_csi)(Vis*, const long *);
} VisEvent;

/** Union used to pass arguments to key action functions. */

 * @rst
 * .. note:: An empty string ``""`` indicates that no further input is available.
 * @endrst
 * @return Pointer to first non-consumed key.
 * @rst
 * .. warning:: Must be in range ``[keys, keys+strlen(keys)]`` or ``NULL`` to
 *              indicate that not enough input was available. In the latter case

void vis_die(Vis*, const char *msg, ...) __attribute__((noreturn,format(printf, 2, 3)));

/**
 * Temporarily suspend the editor process.
 * @rst
 * .. note:: This function will generate a ``SIGTSTP`` signal.
 * @endrst

void vis_window_focus(Win*);
/** Swap location of two windows. */
void vis_window_swap(Win*, Win*);
/** Query window width. */
int vis_window_width_get(const Win*);
/** Query window height. */
int vis_window_height_get(const Win*);
/**
 * @}

/** Perform insertion at all cursor positions. */
void vis_insert_key(Vis*, const char *data, size_t len);
/**
 * Perform character substitution at all cursor positions.
 * @rst
 * .. note:: Does not replace new line characters.
 * @endrst

 *
 *  - `VIS_OP_JOIN`       a char pointer referring to the text to insert between lines.
 *  - `VIS_OP_MODESWITCH` an ``enum VisMode`` indicating the mode to switch to.
 *  - `VIS_OP_REPLACE`    a char pointer referring to the replacement character.
 */
bool vis_operator(Vis*, enum VisOperator, ...);


	VIS_MOVE_PARENTHESIS_START,
	VIS_MOVE_PARENTHESIS_END,
	VIS_MOVE_BRACKET_MATCH,
	VIS_MOVE_TO_LEFT,
	VIS_MOVE_TO_RIGHT,
	VIS_MOVE_TO_LINE_LEFT,
	VIS_MOVE_TO_LINE_RIGHT,
	VIS_MOVE_TILL_LEFT,
	VIS_MOVE_TILL_RIGHT,
	VIS_MOVE_TILL_LINE_LEFT,
	VIS_MOVE_TILL_LINE_RIGHT,
	VIS_MOVE_FILE_BEGIN,
	VIS_MOVE_FILE_END,
	VIS_MOVE_SEARCH_WORD_FORWARD,

	VIS_TEXTOBJECT_INNER_SINGLE_QUOTE,
	VIS_TEXTOBJECT_OUTER_BACKTICK,
	VIS_TEXTOBJECT_INNER_BACKTICK,
	VIS_TEXTOBJECT_OUTER_ENTIRE,
	VIS_TEXTOBJECT_INNER_ENTIRE,
	VIS_TEXTOBJECT_OUTER_LINE,
	VIS_TEXTOBJECT_INNER_LINE,
	VIS_TEXTOBJECT_INDENTATION,

 * @defgroup vis_marks
 * @{
 */
/** Translate between single character mark name and corresponding constant. */
enum VisMark vis_mark_from(Vis*, char mark);
char vis_mark_to(Vis*, enum VisMark);
/**
 * Specify mark to use.
 * @rst

	VIS_REG_9,
	VIS_REG_BLACKHOLE,  /* /dev/null register */
	VIS_REG_CLIPBOARD,  /* system clipboard register */
	VIS_REG_PRIMARY,    /* system primary clipboard register */
	VIS_REG_DOT,        /* last inserted text, copy of VIS_MACRO_OPERATOR */
	VIS_REG_SEARCH,     /* last used search pattern "/ */
	VIS_REG_COMMAND,    /* last used :-command ": */

 * @defgroup vis_registers
 * @{
 */
/** Translate between single character register name and corresponding constant. */
enum VisRegister vis_register_from(Vis*, char reg);
char vis_register_to(Vis*, enum VisRegister);
/**
 * Specify register to use.
 * @rst

 * Get register content.
 * @return An array of ``TextString`` structs.
 * @rst
 * .. warning:: The caller must eventually free the array resources using
 *              ``array_release``.
 * @endrst
 */

 * Option handler function.
 * @param win The window to which option should apply, might be ``NULL``.
 * @param context User provided context pointer as given to `vis_option_register`.
 * @param force Whether the option was specified with a bang ``!``.
 * @param name Name of option which was set.
 * @param arg The new option value.
 */

Regex *vis_regex(Vis*, const char *pattern);

/**
 * Take an undo snapshot to which we can later revert.
 * @rst
 * .. note:: Does nothing when invoked while replaying a macro.
 * @endrst

Return to bug 46325

Lines 21-28 Link Here

(-)vis-0.6/.github/workflows/windows.yml (-2 / +12 lines)
21	run: \|	21	run: \|
22	choco install --no-progress --yes --force --source=cygwin gcc-core,libtool,make,wget,pkg-config	22	choco install --no-progress --yes --force --source=cygwin gcc-core,libtool,make,wget,pkg-config
23	choco install --no-progress --yes --force --source=cygwin lua,lua-devel,lua-lpeg,libncurses-devel	23	choco install --no-progress --yes --force --source=cygwin lua,lua-devel,lua-lpeg,libncurses-devel
24	echo '::add-path::C:\tools\cygwin\bin'
25		24
		25	- name: Setup $PATH
		26	shell: bash
		27	run: echo 'C:\tools\cygwin\bin' >> $GITHUB_PATH
		28
26	- name: Git configuration	29	- name: Git configuration
27	run: \|	30	run: \|
28	git config --global core.autocrlf input	31	git config --global core.autocrlf input
Lines 51-54 Link Here
51	shell: bash	54	shell: bash
52	env:	55	env:
53	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}	56	CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
54	run: bash <(curl -s https://codecov.io/bash)	57	run: \|
		58	curl -s https://codecov.io/bash > codecov
		59	curl -s https://raw.githubusercontent.com/codecov/codecov-bash/master/SHA256SUM > codecov.sha256
		60	if ! sha256sum -c --ignore-missing --status codecov.sha256 ; then
		61	echo "Download checksum verification failed"
		62	exit 1
		63	fi
		64	bash < codecov

Lines 2-11 Link Here

(-)vis-0.6/Makefile (-7 / +36 lines)
2		2
3	REGEX_SRC ?= text-regex.c	3	REGEX_SRC ?= text-regex.c
4		4
5	SRC = array.c buffer.c libutf.c main.c map.c \	5	SRC = array.c \
6	sam.c text.c text-motions.c text-objects.c text-util.c \	6	buffer.c \
7	ui-terminal.c view.c vis.c vis-lua.c vis-modes.c vis-motions.c \	7	libutf.c \
8	vis-operators.c vis-registers.c vis-marks.c vis-prompt.c vis-text-objects.c $(REGEX_SRC)	8	main.c \
		9	map.c \
		10	sam.c \
		11	text.c \
		12	text-common.c \
		13	text-io.c \
		14	text-iterator.c \
		15	text-motions.c \
		16	text-objects.c \
		17	text-util.c \
		18	ui-terminal.c \
		19	view.c \
		20	vis.c \
		21	vis-lua.c \
		22	vis-marks.c \
		23	vis-modes.c \
		24	vis-motions.c \
		25	vis-operators.c \
		26	vis-prompt.c \
		27	vis-registers.c \
		28	vis-text-objects.c \
		29	$(REGEX_SRC)
9		30
10	ELF = vis vis-menu vis-digraph	31	ELF = vis vis-menu vis-digraph
11	EXECUTABLES = $(ELF) vis-clipboard vis-complete vis-open	32	EXECUTABLES = $(ELF) vis-clipboard vis-complete vis-open
Lines 14-20 Link Here
14		35
15	DOCUMENTATION = LICENSE README.md	36	DOCUMENTATION = LICENSE README.md
16		37
17	VERSION = v0.6	38	VERSION = 0.8
18		39
19	CONFIG_HELP ?= 1	40	CONFIG_HELP ?= 1
20	CONFIG_CURSES ?= 1	41	CONFIG_CURSES ?= 1
Lines 121-131 Link Here
121	[ -e test/Makefile ] \|\| $(MAKE) test-update	142	[ -e test/Makefile ] \|\| $(MAKE) test-update
122	@$(MAKE) -C test	143	@$(MAKE) -C test
123		144
		145	testclean:
		146	@echo cleaning the test artifacts
		147	[ ! -e test/Makefile ] \|\| $(MAKE) -C test clean
		148
124	clean:	149	clean:
125	@echo cleaning	150	@echo cleaning
126	@rm -f $(ELF) vis-single vis-single-payload.inc vis-.tar.gz .gcov .gcda .gcno	151	@rm -f $(ELF) vis-single vis-single-payload.inc vis-.tar.gz .gcov .gcda .gcno
127		152
128	dist: clean	153	distclean: clean testclean
		154	@echo cleaning build configuration
		155	@rm -f config.h config.mk
		156
		157	dist: distclean
129	@echo creating dist tarball	158	@echo creating dist tarball
130	@git archive --prefix=vis-${VERSION}/ -o vis-${VERSION}.tar.gz HEAD	159	@git archive --prefix=vis-${VERSION}/ -o vis-${VERSION}.tar.gz HEAD
131		160
Lines 192-195 Link Here
192	@echo removing support files from ${DESTDIR}${SHAREPREFIX}/vis	221	@echo removing support files from ${DESTDIR}${SHAREPREFIX}/vis
193	@rm -rf ${DESTDIR}${SHAREPREFIX}/vis	222	@rm -rf ${DESTDIR}${SHAREPREFIX}/vis
194		223
195	.PHONY: all clean dist install install-strip uninstall debug profile coverage test test-update luadoc luadoc-all luacheck man docker-kill docker docker-clean	224	.PHONY: all clean testclean dist distclean install install-strip uninstall debug profile coverage test test-update luadoc luadoc-all luacheck man docker-kill docker docker-clean

Lines 1-10 Link Here

(-)vis-0.6/README.md (-5 / +5 lines)
1	# Vis - Combining Modal Editing with Structural Regular Expressions	1	# Vis - Combining Modal Editing with Structural Regular Expressions
2		2
3	[![builds.sr.ht status](https://builds.sr.ht/~martanne/vis.svg)](https://builds.sr.ht/~martanne/vis)	3	[![builds.sr.ht status](https://builds.sr.ht/~martanne/vis/commits.svg)](https://builds.sr.ht/~martanne/vis/commits?)
4	[![Coverity Scan Build Status](https://scan.coverity.com/projects/3939/badge.svg)](https://scan.coverity.com/projects/3939)	4	[![Coverity Scan Build Status](https://scan.coverity.com/projects/3939/badge.svg)](https://scan.coverity.com/projects/3939)
5	[![codecov](https://codecov.io/gh/martanne/vis/branch/master/graph/badge.svg)](https://codecov.io/gh/martanne/vis)	5	[![codecov](https://codecov.io/gh/martanne/vis/branch/master/graph/badge.svg)](https://codecov.io/gh/martanne/vis)
6	[![Documentation Status](https://readthedocs.org/projects/vis/badge/?version=master)](http://vis.readthedocs.io/en/master/?badge=master)	6	[![Documentation Status](https://readthedocs.org/projects/vis/badge/?version=master)](http://vis.readthedocs.io/en/master/?badge=master)
7	[![#vis-editor on freenode](https://img.shields.io/badge/IRC-%23vis--editor-blue.svg)](irc://irc.freenode.net/vis-editor)	7	[![#vis-editor on libera](https://img.shields.io/badge/IRC-%23vis--editor-blue.svg)](ircs://irc.libera.chat:6697/vis-editor)
8		8
9	Vis aims to be a modern, legacy-free, simple yet efficient editor,	9	Vis aims to be a modern, legacy-free, simple yet efficient editor,
10	combining the strengths of both vi(m) and sam.	10	combining the strengths of both vi(m) and sam.
Lines 60-67 Link Here
60	$ ./configure && make && sudo make install	60	$ ./configure && make && sudo make install
61		61
62	By default the `configure` script will try to auto detect support for	62	By default the `configure` script will try to auto detect support for
63	Lua. See `configure --help` for a list of supported options. You can	63	Lua using `pkg-config(1)`. See `configure --help` for a list of supported
64	also manually tweak the generated `config.mk` file.	64	options. You can also manually tweak the generated `config.mk` file.
65		65
66	Or simply use one of the	66	Or simply use one of the
67	[distribution provided packages](https://github.com/martanne/vis/wiki/Distribution-Packages).	67	[distribution provided packages](https://github.com/martanne/vis/wiki/Distribution-Packages).
Lines 127-130 Link Here
127		127
128	Checkout the [Developer Overview](https://github.com/martanne/vis/wiki/Developer-Overview)	128	Checkout the [Developer Overview](https://github.com/martanne/vis/wiki/Developer-Overview)
129	to get started and do not hesitate to ask question in the `#vis-editor`	129	to get started and do not hesitate to ask question in the `#vis-editor`
130	IRC channel on freenode.	130	IRC channel on libera ([join via your browser](https://web.libera.chat/#vis-editor)).

Lines 11-17 Link Here

(-)vis-0.6/array.c (-6 / +6 lines)
11	array_init_sized(arr, sizeof(void*));	11	array_init_sized(arr, sizeof(void*));
12	}	12	}
13		13
14	void array_init_from(Array arr, Array from) {	14	void array_init_from(Array arr, const Array from) {
15	array_init_sized(arr, from->elem_size);	15	array_init_sized(arr, from->elem_size);
16	}	16	}
17		17
Lines 55-61 Link Here
55	memset(arr->items, 0, arr->count * arr->elem_size);	55	memset(arr->items, 0, arr->count * arr->elem_size);
56	}	56	}
57		57
58	void array_get(Array arr, size_t idx) {	58	void array_get(const Array arr, size_t idx) {
59	if (idx >= arr->len) {	59	if (idx >= arr->len) {
60	errno = EINVAL;	60	errno = EINVAL;
61	return NULL;	61	return NULL;
Lines 63-69 Link Here
63	return arr->items + (idx * arr->elem_size);	63	return arr->items + (idx * arr->elem_size);
64	}	64	}
65		65
66	void array_get_ptr(Array arr, size_t idx) {	66	void array_get_ptr(const Array arr, size_t idx) {
67	if (arr->elem_size != sizeof(void*)) {	67	if (arr->elem_size != sizeof(void*)) {
68	errno = ENOTSUP;	68	errno = ENOTSUP;
69	return NULL;	69	return NULL;
Lines 124-134 Link Here
124	return true;	124	return true;
125	}	125	}
126		126
127	size_t array_length(Array *arr) {	127	size_t array_length(const Array *arr) {
128	return arr->len;	128	return arr->len;
129	}	129	}
130		130
131	size_t array_capacity(Array *arr) {	131	size_t array_capacity(const Array *arr) {
132	return arr->count;	132	return arr->count;
133	}	133	}
134		134
Lines 165-171 Link Here
165	return item;	165	return item;
166	}	166	}
167		167
168	void array_peek(Array arr) {	168	void array_peek(const Array arr) {
169	if (arr->len == 0)	169	if (arr->len == 0)
170	return NULL;	170	return NULL;
171	return array_get(arr, arr->len - 1);	171	return array_get(arr, arr->len - 1);

Lines 44-50 Link Here

(-)vis-0.6/array.h (-7 / +7 lines)
44	*/	44	*/
45	void array_init_sized(Array*, size_t elem_size);	45	void array_init_sized(Array*, size_t elem_size);
46	/** Initialize Array by using the same element size as in ``from``. */	46	/** Initialize Array by using the same element size as in ``from``. */
47	void array_init_from(Array, Array from);	47	void array_init_from(Array, const Array from);
48	/** Release storage space. Reinitializes Array object. */	48	/** Release storage space. Reinitializes Array object. */
49	void array_release(Array*);	49	void array_release(Array*);
50	/**	50	/**
Lines 66-72 Link Here
66	* of new elements) might invalidate the pointer.	66	* of new elements) might invalidate the pointer.
67	* @endrst	67	* @endrst
68	*/	68	*/
69	void array_get(Array, size_t idx);	69	void array_get(const Array, size_t idx);
70	/**	70	/**
71	* Set array element.	71	* Set array element.
72	* @rst	72	* @rst
Lines 76-82 Link Here
76	*/	76	*/
77	bool array_set(Array, size_t idx, void item);	77	bool array_set(Array, size_t idx, void item);
78	/** Dereference pointer stored in array element. */	78	/** Dereference pointer stored in array element. */
79	void array_get_ptr(Array, size_t idx);	79	void array_get_ptr(const Array, size_t idx);
80	/** Store the address to which ``item`` points to into the array. */	80	/** Store the address to which ``item`` points to into the array. */
81	bool array_set_ptr(Array, size_t idx, void item);	81	bool array_set_ptr(Array, size_t idx, void item);
82	/** Add element to the end of the array. */	82	/** Add element to the end of the array. */
Lines 91-106 Link Here
91	*/	91	*/
92	bool array_remove(Array*, size_t idx);	92	bool array_remove(Array*, size_t idx);
93	/** Number of elements currently stored in the array. */	93	/** Number of elements currently stored in the array. */
94	size_t array_length(Array*);	94	size_t array_length(const Array*);
95	/** Number of elements which can be stored without enlarging the array. */	95	/** Number of elements which can be stored without enlarging the array. */
96	size_t array_capacity(Array*);	96	size_t array_capacity(const Array*);
97	/** Remove all elements with index greater or equal to ``length``, keep allocated memory. */	97	/** Remove all elements with index greater or equal to ``length``, keep allocated memory. */
98	bool array_truncate(Array*, size_t length);	98	bool array_truncate(Array*, size_t length);
99	/**	99	/**
100	* Change length.	100	* Change length.
101	* @rst	101	* @rst
102	* .. note:: Has to be less or equal than the capacity.	102	* .. note:: Has to be less or equal than the capacity.
103	* Newly accesible elements preserve their previous values.	103	* Newly accessible elements preserve their previous values.
104	* @endrst	104	* @endrst
105	*/	105	*/
106	bool array_resize(Array*, size_t length);	106	bool array_resize(Array*, size_t length);
Lines 128-133 Link Here
128	* .. warning:: The same ownership rules as for ``array_get`` apply.	128	* .. warning:: The same ownership rules as for ``array_get`` apply.
129	* @endrst	129	* @endrst
130	*/	130	*/
131	void array_peek(Array);	131	void array_peek(const Array);
132		132
133	#endif	133	#endif

Lines 44-54 Link Here

(-)vis-0.6/buffer.h (-4 / +4 lines)
44	bool buffer_insert0(Buffer, size_t pos, const char data);	44	bool buffer_insert0(Buffer, size_t pos, const char data);
45	/** Append further content to the end. */	45	/** Append further content to the end. */
46	bool buffer_append(Buffer, const void data, size_t len);	46	bool buffer_append(Buffer, const void data, size_t len);
47	/** Append NUl-terminated data. */	47	/** Append NUL-terminated data. */
48	bool buffer_append0(Buffer, const char data);	48	bool buffer_append0(Buffer, const char data);
49	/** Insert ``len`` bytes of ``data`` at the begin. */	49	/** Insert ``len`` bytes of ``data`` at the start. */
50	bool buffer_prepend(Buffer, const void data, size_t len);	50	bool buffer_prepend(Buffer, const void data, size_t len);
51	/** Insert NUL-terminated data at the begin. */	51	/** Insert NUL-terminated data at the start. */
52	bool buffer_prepend0(Buffer, const char data);	52	bool buffer_prepend0(Buffer, const char data);
53	/** Set formatted buffer content, ensures NUL termination on success. */	53	/** Set formatted buffer content, ensures NUL termination on success. */
54	bool buffer_printf(Buffer, const char fmt, ...) __attribute__((format(printf, 2, 3)));	54	bool buffer_printf(Buffer, const char fmt, ...) __attribute__((format(printf, 2, 3)));
Lines 75-81 Link Here
75	/**	75	/**
76	* Borrow underlying buffer data.	76	* Borrow underlying buffer data.
77	* @rst	77	* @rst
78	* .. warning:: The caller is responsible to `free(3)` it.	78	* .. warning:: The caller is responsible to ``free(3)`` it.
79	* @endrst	79	* @endrst
80	*/	80	*/
81	char buffer_move(Buffer);	81	char buffer_move(Buffer);

Lines 45-64 Link Here

(-)vis-0.6/config.def.h (-36 / +9 lines)
45	{ ",", ACTION(TOTILL_REVERSE) },	45	{ ",", ACTION(TOTILL_REVERSE) },
46	{ "+", ALIAS("j^") },	46	{ "+", ALIAS("j^") },
47	{ "-", ALIAS("k^") },	47	{ "-", ALIAS("k^") },
48	{ " ", ALIAS("<Space>") },
49	{ "<Space>", ALIAS("l") },
50	{ "<Backspace>", ALIAS("h") },
51	{ "B", ACTION(CURSOR_LONGWORD_START_PREV) },	48	{ "B", ACTION(CURSOR_LONGWORD_START_PREV) },
52	{ "b", ACTION(CURSOR_WORD_START_PREV) },	49	{ "b", ACTION(CURSOR_WORD_START_PREV) },
53	{ "<C-h>", ALIAS("<Backspace>") },
54	{ "<C-j>", ALIAS("j") },
55	{ "<C-n>", ALIAS("j") },
56	{ "<C-p>", ALIAS("k") },
57	{ "E", ACTION(CURSOR_LONGWORD_END_NEXT) },	50	{ "E", ACTION(CURSOR_LONGWORD_END_NEXT) },
58	{ "e", ACTION(CURSOR_WORD_END_NEXT) },	51	{ "e", ACTION(CURSOR_WORD_END_NEXT) },
59	{ "<Enter>", ALIAS("j") },	52	{ "F", ACTION(TO_LINE_LEFT) },
60	{ "F", ACTION(TO_LEFT) },	53	{ "f", ACTION(TO_LINE_RIGHT) },
61	{ "f", ACTION(TO_RIGHT) },
62	{ "go", ACTION(CURSOR_BYTE) },	54	{ "go", ACTION(CURSOR_BYTE) },
63	{ "gH", ACTION(CURSOR_BYTE_LEFT) },	55	{ "gH", ACTION(CURSOR_BYTE_LEFT) },
64	{ "gL", ACTION(CURSOR_BYTE_RIGHT) },	56	{ "gL", ACTION(CURSOR_BYTE_RIGHT) },
Lines 83-90 Link Here
83	{ "M", ACTION(CURSOR_WINDOW_LINE_MIDDLE) },	75	{ "M", ACTION(CURSOR_WINDOW_LINE_MIDDLE) },
84	{ "n", ACTION(CURSOR_SEARCH_REPEAT_FORWARD) },	76	{ "n", ACTION(CURSOR_SEARCH_REPEAT_FORWARD) },
85	{ "N", ACTION(CURSOR_SEARCH_REPEAT_BACKWARD) },	77	{ "N", ACTION(CURSOR_SEARCH_REPEAT_BACKWARD) },
86	{ "T", ACTION(TILL_LEFT) },	78	{ "T", ACTION(TILL_LINE_LEFT) },
87	{ "t", ACTION(TILL_RIGHT) },	79	{ "t", ACTION(TILL_LINE_RIGHT) },
88	{ "W", ACTION(CURSOR_LONGWORD_START_NEXT) },	80	{ "W", ACTION(CURSOR_LONGWORD_START_NEXT) },
89	{ "w", ACTION(CURSOR_WORD_START_NEXT) },	81	{ "w", ACTION(CURSOR_WORD_START_NEXT) },
90	{ 0 /* empty last element, array terminator */ },	82	{ 0 /* empty last element, array terminator */ },
Lines 104-110 Link Here
104	{ "a}", ALIAS("a{") },	96	{ "a}", ALIAS("a{") },
105	{ "ab", ALIAS("a(") },	97	{ "ab", ALIAS("a(") },
106	{ "aB", ALIAS("a{") },	98	{ "aB", ALIAS("a{") },
107	{ "ae", ACTION(TEXT_OBJECT_ENTIRE_OUTER) },
108	{ "al", ACTION(TEXT_OBJECT_LINE_OUTER) },	99	{ "al", ACTION(TEXT_OBJECT_LINE_OUTER) },
109	{ "ap", ACTION(TEXT_OBJECT_PARAGRAPH_OUTER) },	100	{ "ap", ACTION(TEXT_OBJECT_PARAGRAPH_OUTER) },
110	{ "as", ACTION(TEXT_OBJECT_SENTENCE) },	101	{ "as", ACTION(TEXT_OBJECT_SENTENCE) },
Lines 126-132 Link Here
126	{ "i}", ALIAS("i{") },	117	{ "i}", ALIAS("i{") },
127	{ "ib", ALIAS("i(") },	118	{ "ib", ALIAS("i(") },
128	{ "iB", ALIAS("i{") },	119	{ "iB", ALIAS("i{") },
129	{ "ie", ACTION(TEXT_OBJECT_ENTIRE_INNER) },
130	{ "il", ACTION(TEXT_OBJECT_LINE_INNER) },	120	{ "il", ACTION(TEXT_OBJECT_LINE_INNER) },
131	{ "ip", ACTION(TEXT_OBJECT_PARAGRAPH) },	121	{ "ip", ACTION(TEXT_OBJECT_PARAGRAPH) },
132	{ "is", ACTION(TEXT_OBJECT_SENTENCE) },	122	{ "is", ACTION(TEXT_OBJECT_SENTENCE) },
Lines 141-156 Link Here
141	{ "M", ACTION(SELECTIONS_RESTORE) },	131	{ "M", ACTION(SELECTIONS_RESTORE) },
142	{ "\|", ACTION(SELECTIONS_UNION) },	132	{ "\|", ACTION(SELECTIONS_UNION) },
143	{ "&", ACTION(SELECTIONS_INTERSECT) },	133	{ "&", ACTION(SELECTIONS_INTERSECT) },
144	{ "!", ACTION(SELECTIONS_COMPLEMENT) },	134	{ "~", ACTION(SELECTIONS_COMPLEMENT) },
145	{ "\\", ACTION(SELECTIONS_MINUS) },	135	{ "\\", ACTION(SELECTIONS_MINUS) },
146	{ "z\|", ACTION(SELECTIONS_COMBINE_UNION) },
147	{ "z&", ACTION(SELECTIONS_COMBINE_INTERSECT) },
148	{ "z+", ACTION(SELECTIONS_COMBINE_LONGER) },
149	{ "z-", ACTION(SELECTIONS_COMBINE_SHORTER) },
150	{ "z<", ACTION(SELECTIONS_COMBINE_LEFTMOST) },
151	{ "z>", ACTION(SELECTIONS_COMBINE_RIGHTMOST) },
152	// { "-", ACTION(SELECTIONS_ROTATE_LEFT) },
153	// { "+", ACTION(SELECTIONS_ROTATE_RIGHT) },
154	{ "_", ACTION(SELECTIONS_TRIM) },	136	{ "_", ACTION(SELECTIONS_TRIM) },
155	{ "<S-Tab>", ACTION(SELECTIONS_ALIGN_INDENT_RIGHT) },	137	{ "<S-Tab>", ACTION(SELECTIONS_ALIGN_INDENT_RIGHT) },
156	{ "<Tab>", ACTION(SELECTIONS_ALIGN_INDENT_LEFT) },	138	{ "<Tab>", ACTION(SELECTIONS_ALIGN_INDENT_LEFT) },
Lines 171-177 Link Here
171	{ "7", ACTION(COUNT) },	153	{ "7", ACTION(COUNT) },
172	{ "8", ACTION(COUNT) },	154	{ "8", ACTION(COUNT) },
173	{ "9", ACTION(COUNT) },	155	{ "9", ACTION(COUNT) },
174	{ "~", ALIAS("g~") },
175	{ "=", ALIAS(":\|fmt<Enter>") },	156	{ "=", ALIAS(":\|fmt<Enter>") },
176	{ "<", ACTION(OPERATOR_SHIFT_LEFT) },	157	{ "<", ACTION(OPERATOR_SHIFT_LEFT) },
177	{ ">", ACTION(OPERATOR_SHIFT_RIGHT) },	158	{ ">", ACTION(OPERATOR_SHIFT_RIGHT) },
Lines 203-219 Link Here
203	{ "<C-j>", ACTION(SELECTIONS_NEW_LINE_BELOW) },	184	{ "<C-j>", ACTION(SELECTIONS_NEW_LINE_BELOW) },
204	{ "<C-k>", ACTION(SELECTIONS_NEW_LINE_ABOVE) },	185	{ "<C-k>", ACTION(SELECTIONS_NEW_LINE_ABOVE) },
205	{ "<C-l>", ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT) },	186	{ "<C-l>", ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT) },
206	{ "<C-n>", ACTION(SELECTIONS_MATCH_WORD) },	187	{ "<C-n>", ALIAS("viw") },
207	{ "<C-p>", ACTION(SELECTIONS_REMOVE_LAST) },	188	{ "<C-p>", ACTION(SELECTIONS_REMOVE_LAST) },
208	{ "<C-r>", ACTION(REDO) },	189	{ "<C-r>", ACTION(REDO) },
209	{ "<C-u>", ACTION(SELECTIONS_PREV) },	190	{ "<C-u>", ACTION(SELECTIONS_PREV) },
210	{ "<C-w><Backspace>", ALIAS("<C-w>k") },
211	{ "<C-w>c", ALIAS(":q<Enter>") },	191	{ "<C-w>c", ALIAS(":q<Enter>") },
212	{ "<C-w><C-h>", ALIAS("<C-w>k") },
213	{ "<C-w><C-j>", ALIAS("<C-w>j") },
214	{ "<C-w><C-k>", ALIAS("<C-w>k") },
215	{ "<C-w><C-l>", ALIAS("<C-w>j") },
216	{ "<C-w><C-w>", ALIAS("<C-w>j") },
217	{ "<C-w>h", ALIAS("<C-w>k") },	192	{ "<C-w>h", ALIAS("<C-w>k") },
218	{ "<C-w>j", ACTION(WINDOW_NEXT) },	193	{ "<C-w>j", ACTION(WINDOW_NEXT) },
219	{ "<C-w>k", ACTION(WINDOW_PREV) },	194	{ "<C-w>k", ACTION(WINDOW_PREV) },
Lines 221-230 Link Here
221	{ "<C-w>n", ALIAS(":open<Enter>") },	196	{ "<C-w>n", ALIAS(":open<Enter>") },
222	{ "<C-w>s", ALIAS(":split<Enter>") },	197	{ "<C-w>s", ALIAS(":split<Enter>") },
223	{ "<C-w>v", ALIAS(":vsplit<Enter>") },	198	{ "<C-w>v", ALIAS(":vsplit<Enter>") },
224	{ "<C-w>w", ALIAS("<C-w>j") },
225	{ "<C-y>", ACTION(WINDOW_SLIDE_DOWN) },	199	{ "<C-y>", ACTION(WINDOW_SLIDE_DOWN) },
226	{ "D", ALIAS("d$") },	200	{ "D", ALIAS("d$") },
227	{ "<Delete>", ALIAS("x") },
228	{ "<Escape>", ACTION(MODE_NORMAL_ESCAPE) },	201	{ "<Escape>", ACTION(MODE_NORMAL_ESCAPE) },
229	{ "<F1>", ALIAS(":help<Enter>") },	202	{ "<F1>", ALIAS(":help<Enter>") },
230	{ "ga", ACTION(UNICODE_INFO) },	203	{ "ga", ACTION(UNICODE_INFO) },
Lines 270-281 Link Here
270	{ "+", ACTION(SELECTIONS_ROTATE_RIGHT) },	243	{ "+", ACTION(SELECTIONS_ROTATE_RIGHT) },
271	{ "<", ALIAS("<vis-operator-shift-left>gv") },	244	{ "<", ALIAS("<vis-operator-shift-left>gv") },
272	{ ">", ALIAS("<vis-operator-shift-right>gv") },	245	{ ">", ALIAS("<vis-operator-shift-right>gv") },
273	{ "<Backspace>", ALIAS("d") },	246	{ "<C-a>", ACTION(SELECTIONS_NEW_MATCH_ALL) },
274	{ "<C-b>", ALIAS("<PageUp>") },	247	{ "<C-b>", ALIAS("<PageUp>") },
275	{ "<C-c>", ACTION(SELECTIONS_REMOVE_COLUMN) },	248	{ "<C-c>", ACTION(SELECTIONS_REMOVE_COLUMN) },
276	{ "<C-d>", ACTION(SELECTIONS_NEXT) },	249	{ "<C-d>", ACTION(SELECTIONS_NEXT) },
277	{ "<C-f>", ALIAS("<PageDown>") },	250	{ "<C-f>", ALIAS("<PageDown>") },
278	{ "<C-h>", ALIAS("<Backspace>") },
279	{ "<C-j>", ALIAS("<C-d>") },	251	{ "<C-j>", ALIAS("<C-d>") },
280	{ "<C-k>", ALIAS("<C-u>") },	252	{ "<C-k>", ALIAS("<C-u>") },
281	{ "<C-l>", ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT) },	253	{ "<C-l>", ACTION(SELECTIONS_REMOVE_COLUMN_EXCEPT) },
Lines 283-289 Link Here
283	{ "<C-p>", ACTION(SELECTIONS_REMOVE_LAST) },	255	{ "<C-p>", ACTION(SELECTIONS_REMOVE_LAST) },
284	{ "<C-u>", ACTION(SELECTIONS_PREV) },	256	{ "<C-u>", ACTION(SELECTIONS_PREV) },
285	{ "<C-x>", ACTION(SELECTIONS_NEW_MATCH_SKIP) },	257	{ "<C-x>", ACTION(SELECTIONS_NEW_MATCH_SKIP) },
286	{ "<Delete>", ALIAS("<Backspace>") },
287	{ "<Escape>", ACTION(MODE_VISUAL_ESCAPE) },	258	{ "<Escape>", ACTION(MODE_VISUAL_ESCAPE) },
288	{ "I", ACTION(SELECTIONS_NEW_LINES_BEGIN) },	259	{ "I", ACTION(SELECTIONS_NEW_LINES_BEGIN) },
289	{ "J", ACTION(JOIN_LINES) },	260	{ "J", ACTION(JOIN_LINES) },
Lines 314-319 Link Here
314	{ "<C-u>", ACTION(DELETE_LINE_BEGIN) },	285	{ "<C-u>", ACTION(DELETE_LINE_BEGIN) },
315	{ "<C-v>", ACTION(INSERT_VERBATIM) },	286	{ "<C-v>", ACTION(INSERT_VERBATIM) },
316	{ "<C-w>", ACTION(DELETE_WORD_PREV) },	287	{ "<C-w>", ACTION(DELETE_WORD_PREV) },
		288	{ "<C-e>", ACTION(CURSOR_LINE_END) },
		289	{ "<C-a>", ACTION(CURSOR_LINE_START) },
317	{ "<Delete>", ACTION(DELETE_CHAR_NEXT) },	290	{ "<Delete>", ACTION(DELETE_CHAR_NEXT) },
318	{ "<Escape>", ACTION(MODE_NORMAL) },	291	{ "<Escape>", ACTION(MODE_NORMAL) },
319	{ 0 /* empty last element, array terminator */ },	292	{ 0 /* empty last element, array terminator */ },

Lines 227-232 Link Here

(-)vis-0.6/configure (-4 / +5 lines)
227		227
228	case "$OS" in	228	case "$OS" in
229	FreeBSD\|DragonFly) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE -D__BSD_VISIBLE=1" ;;	229	FreeBSD\|DragonFly) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE -D__BSD_VISIBLE=1" ;;
		230	NetBSD) CFLAGS_STD="$CFLAGS_STD -D_NETBSD_SOURCE" ;;
230	*BSD) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE" ;;	231	*BSD) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE" ;;
231	Darwin) CFLAGS_STD="$CFLAGS_STD -D_DARWIN_C_SOURCE" ;;	232	Darwin) CFLAGS_STD="$CFLAGS_STD -D_DARWIN_C_SOURCE" ;;
232	AIX) CFLAGS_STD="$CFLAGS_STD -D_ALL_SOURCE" ;;	233	AIX) CFLAGS_STD="$CFLAGS_STD -D_ALL_SOURCE" ;;
Lines 309-315 Link Here
309	}	310	}
310	EOF	311	EOF
311		312
312	for libcurses in ncursesw ncurses libcurses; do	313	for libcurses in ncursesw ncurses curses; do
313	printf " checking for %s... " "$libcurses"	314	printf " checking for %s... " "$libcurses"
314		315
315	if test "$have_pkgconfig" = "yes" ; then	316	if test "$have_pkgconfig" = "yes" ; then
Lines 442-448 Link Here
442	}	443	}
443	EOF	444	EOF
444		445
445	for liblua in lua lua5.3 lua5.2 lua-5.3 lua-5.2 lua53 lua52; do	446	for liblua in lua lua5.4 lua5.3 lua5.2 lua-5.3 lua-5.2 lua54 lua53 lua52; do
446	printf " checking for %s... " "$liblua"	447	printf " checking for %s... " "$liblua"
447		448
448	if test "$have_pkgconfig" = "yes" ; then	449	if test "$have_pkgconfig" = "yes" ; then
Lines 474-480 Link Here
474	test "$lua" = "yes" -a $CONFIG_LUA -ne 1 && fail "$0: cannot find liblua"	475	test "$lua" = "yes" -a $CONFIG_LUA -ne 1 && fail "$0: cannot find liblua"
475		476
476	if test $CONFIG_LUA -eq 1; then	477	if test $CONFIG_LUA -eq 1; then
477	CFLAGS_LUA="$CFLAGS_LUA -DLUA_COMPAT_5_1 -DLUA_COMPAT_5_2 -DLUA_COMPAT_ALL"	478	CFLAGS_LUA="$CFLAGS_LUA -DLUA_COMPAT_5_1 -DLUA_COMPAT_5_2 -DLUA_COMPAT_5_3 -DLUA_COMPAT_ALL"
478	fi	479	fi
479	fi	480	fi
480		481
Lines 618-624 Link Here
618	}	619	}
619	EOF	620	EOF
620		621
621	if $CC $CFLAGS "$tmpc" $LDFLAGS -o "$tmpo" >/dev/null 2>&1; then	622	if $CC $CFLAGS $CFLAGS_STD "$tmpc" $LDFLAGS -o "$tmpo" >/dev/null 2>&1; then
622	HAVE_MEMRCHR=1	623	HAVE_MEMRCHR=1
623	printf "%s\n" "yes"	624	printf "%s\n" "yes"
624	else	625	else

Lines 4-10 Link Here

(-)vis-0.6/doc/text.rst (-3 / +3 lines)
4	The core text management data structure which supports efficient	4	The core text management data structure which supports efficient
5	modifications and provides a byte string interface. Text positions	5	modifications and provides a byte string interface. Text positions
6	are represented as ``size_t``. Valid addresses are in range ``[0,	6	are represented as ``size_t``. Valid addresses are in range ``[0,
7	text_size(txt)]``. An invalid position is denoted by `EPOS`. Access to	7	text_size(txt)]``. An invalid position is denoted by ``EPOS``. Access to
8	the non-contigiuos pieces is available by means of an iterator interface	8	the non-contigiuos pieces is available by means of an iterator interface
9	or a copy mechanism. Text revisions are tracked in an history graph.	9	or a copy mechanism. Text revisions are tracked in an history graph.
10		10
Lines 77-83 Link Here
77	.. note:: The grapheme cluster boundaries are currently not implemented	77	.. note:: The grapheme cluster boundaries are currently not implemented
78	according to `UAX#29 rules <http://unicode.org/reports/tr29>`_.	78	according to `UAX#29 rules <http://unicode.org/reports/tr29>`_.
79	Instead a base character followed by arbitrarily many combining	79	Instead a base character followed by arbitrarily many combining
80	character as reported by `wcwidth(3)` are skipped.	80	character as reported by ``wcwidth(3)`` are skipped.
81		81
82	.. doxygengroup:: iterator_char	82	.. doxygengroup:: iterator_char
83	:content-only:	83	:content-only:
Lines 105-111 Link Here
105	all marks placed after the modification point. Reverting to an older text	105	all marks placed after the modification point. Reverting to an older text
106	state will hide all affected marks, redoing the changes will restore them.	106	state will hide all affected marks, redoing the changes will restore them.
107		107
108	.. warning:: Due to an optimization cached modifications (i.e. no `text_snaphot`	108	.. warning:: Due to an optimization cached modifications (i.e. no ``text_snaphot``
109	was performed between setting the mark and issuing the changes) might	109	was performed between setting the mark and issuing the changes) might
110	not adjust mark positions accurately.	110	not adjust mark positions accurately.
111		111

Lines 18-27 Link Here

(-)vis-0.6/lua/lexers/bash.lua (-3 / +11 lines)
18	local dq_str = l.delimited_range('"')	18	local dq_str = l.delimited_range('"')
19	local ex_str = l.delimited_range('`')	19	local ex_str = l.delimited_range('`')
20	local heredoc = '<<' * P(function(input, index)	20	local heredoc = '<<' * P(function(input, index)
21	local s, e, _, delimiter =	21	local s, e, minus, _, delimiter =
22	input:find('%-?(["\']?)([%a_][%w_]*)%1[\n\r\f;]+', index)	22	input:find('(-?)(["\']?)([%a_][%w_]*)%2[\n\r\f;]+', index)
23	if s == index and delimiter then	23	if s == index and delimiter then
24	local _, e = input:find('[\n\r\f]+'..delimiter..'\n', e)	24	-- If the starting delimiter of a here-doc begins with "-", then
		25	-- spaces are allowed to come before the closing delimiter.
		26	local close_pattern
		27	if minus == '-' then
		28	close_pattern = '[\n\r\f%s]+'..delimiter..'\n'
		29	else
		30	close_pattern = '[\n\r\f]+'..delimiter..'\n'
		31	end
		32	local _, e = input:find(close_pattern, e)
25	return e and e + 1 or #input + 1	33	return e and e + 1 or #input + 1
26	end	34	end
27	end)	35	end)

Lines 1-9 Link Here

(-)vis-0.6/lua/lexers/strace.lua (-6 / +8 lines)
1	-- Copyright 2017 Marc André Tanner. See LICENSE.	1	-- Copyright 2017-2021 Marc André Tanner. See LICENSE.
2	-- strace(1) output lexer	2	-- strace(1) output lexer
3		3
4	local l = require('lexer')	4	local l = require('lexer')
5	local token, word_match = l.token, l.word_match	5	local token, word_match = l.token, l.word_match
6	local S = lpeg.S	6	local S, B = lpeg.S, lpeg.B
7		7
8	local M = {_NAME = 'strace'}	8	local M = {_NAME = 'strace'}
9		9
Lines 13-28 Link Here
13	local constant = token(l.CONSTANT, (l.upper + '_') * (l.upper + l.digit + '_')^0)	13	local constant = token(l.CONSTANT, (l.upper + '_') * (l.upper + l.digit + '_')^0)
14	local syscall = token(l.KEYWORD, l.starts_line(l.word))	14	local syscall = token(l.KEYWORD, l.starts_line(l.word))
15	local operator = token(l.OPERATOR, S('+-/*%<>~!=^&\|?~:;,.()[]{}'))	15	local operator = token(l.OPERATOR, S('+-/*%<>~!=^&\|?~:;,.()[]{}'))
16	local comment = token(l.COMMENT, l.nested_pair('/', '/') + ('(' * (l.alpha + ' ')^1 * ')\n'))	16	local comment = token(l.COMMENT, l.nested_pair('/', '/') + (l.delimited_range('()') * l.newline))
17	local result = token(l.TYPE, '= ' * l.integer)	17	local result = token(l.TYPE, B(' = ') * l.integer)
		18	local identifier = token(l.IDENTIFIER, l.word)
18		19
19	M._rules = {	20	M._rules = {
20	{'whitespace', ws},	21	{'whitespace', ws},
21	{'keyword', syscall},	22	{'syscall', syscall},
22	{'constant', constant},	23	{'constant', constant},
23	{'string', string},	24	{'string', string},
24	{'comment', comment},	25	{'comment', comment},
25	{'type', result},	26	{'result', result},
		27	{'identifier', identifier},
26	{'number', number},	28	{'number', number},
27	{'operator', operator},	29	{'operator', operator},
28	}	30	}

Lines 103-109 Link Here

(-)vis-0.6/lua/vis.lua (-1 / +3 lines)
103	-- Checks whether a subsequent @{require} call will succeed.	103	-- Checks whether a subsequent @{require} call will succeed.
104	-- @tparam string name the module name to check	104	-- @tparam string name the module name to check
105	-- @treturn bool whether the module was found	105	-- @treturn bool whether the module was found
106	vis.module_exist = function(vis, name)	106	vis.module_exist = function(_, name)
107	for _, searcher in ipairs(package.searchers or package.loaders) do	107	for _, searcher in ipairs(package.searchers or package.loaders) do
108	local loader = searcher(name)	108	local loader = searcher(name)
109	if type(loader) == 'function' then	109	if type(loader) == 'function' then
Lines 151-156 Link Here
151	WIN_HIGHLIGHT = "Event::WIN_HIGHLIGHT", -- see @{win_highlight}	151	WIN_HIGHLIGHT = "Event::WIN_HIGHLIGHT", -- see @{win_highlight}
152	WIN_OPEN = "Event::WIN_OPEN", -- see @{win_open}	152	WIN_OPEN = "Event::WIN_OPEN", -- see @{win_open}
153	WIN_STATUS = "Event::WIN_STATUS", -- see @{win_status}	153	WIN_STATUS = "Event::WIN_STATUS", -- see @{win_status}
		154	TERM_CSI = "Event::TERM_CSI", -- see @{term_csi}
154	}	155	}
155		156
156	events.file_close = function(...) events.emit(events.FILE_CLOSE, ...) end	157	events.file_close = function(...) events.emit(events.FILE_CLOSE, ...) end
Lines 165-170 Link Here
165	events.win_highlight = function(...) events.emit(events.WIN_HIGHLIGHT, ...) end	166	events.win_highlight = function(...) events.emit(events.WIN_HIGHLIGHT, ...) end
166	events.win_open = function(...) events.emit(events.WIN_OPEN, ...) end	167	events.win_open = function(...) events.emit(events.WIN_OPEN, ...) end
167	events.win_status = function(...) events.emit(events.WIN_STATUS, ...) end	168	events.win_status = function(...) events.emit(events.WIN_STATUS, ...) end
		169	events.term_csi = function(...) events.emit(events.TERM_CSI, ...) end
168		170
169	local handlers = {}	171	local handlers = {}
170		172

Lines 66-73 Link Here

(-)vis-0.6/main.c (-203 / +72 lines)
66	static const char selections_remove_column_except(Vis, const char keys, const Arg arg);	66	static const char selections_remove_column_except(Vis, const char keys, const Arg arg);
67	/* move to the previous (arg->i < 0) or next (arg->i > 0) selection */	67	/* move to the previous (arg->i < 0) or next (arg->i > 0) selection */
68	static const char selections_navigate(Vis, const char keys, const Arg arg);	68	static const char selections_navigate(Vis, const char keys, const Arg arg);
69	/* select the word the selection is currently over */
70	static const char selections_match_word(Vis, const char keys, const Arg arg);
71	/* select the next region matching the current selection */	69	/* select the next region matching the current selection */
72	static const char selections_match_next(Vis, const char keys, const Arg arg);	70	static const char selections_match_next(Vis, const char keys, const Arg arg);
73	/* clear current selection but select next match */	71	/* clear current selection but select next match */
Lines 88-101 Link Here
88	static const char selections_complement(Vis, const char keys, const Arg arg);	86	static const char selections_complement(Vis, const char keys, const Arg arg);
89	/* subtract selections from mark */	87	/* subtract selections from mark */
90	static const char selections_minus(Vis, const char keys, const Arg arg);	88	static const char selections_minus(Vis, const char keys, const Arg arg);
91	/* pairwise combine selections from mark */
92	static const char selections_combine(Vis, const char keys, const Arg arg);
93	static Filerange combine_union(const Filerange, const Filerange);
94	static Filerange combine_intersect(const Filerange, const Filerange);
95	static Filerange combine_longer(const Filerange, const Filerange);
96	static Filerange combine_shorter(const Filerange, const Filerange);
97	static Filerange combine_leftmost(const Filerange, const Filerange);
98	static Filerange combine_rightmost(const Filerange, const Filerange);
99	/* adjust current used count according to keys */	89	/* adjust current used count according to keys */
100	static const char count(Vis, const char keys, const Arg arg);	90	static const char count(Vis, const char keys, const Arg arg);
101	/* move to the count-th line or if not given either to the first (arg->i < 0)	91	/* move to the count-th line or if not given either to the first (arg->i < 0)
Lines 104-110 Link Here
104	/* make the current action use the operator indicated by arg->i */	94	/* make the current action use the operator indicated by arg->i */
105	static const char operator(Vis, const char keys, const Arg arg);	95	static const char operator(Vis, const char keys, const Arg arg);
106	/* blocks to read a key and performs movement indicated by arg->i which	96	/* blocks to read a key and performs movement indicated by arg->i which
107	* should be one of VIS_MOVE_{RIGHT,LEFT}_{TO,TILL} */	97	* should be one of VIS_MOVE_{TO,TILL}_{,LINE}_{RIGHT,LEFT}*/
108	static const char movement_key(Vis, const char keys, const Arg arg);	98	static const char movement_key(Vis, const char keys, const Arg arg);
109	/* perform the movement as indicated by arg->i */	99	/* perform the movement as indicated by arg->i */
110	static const char movement(Vis, const char keys, const Arg arg);	100	static const char movement(Vis, const char keys, const Arg arg);
Lines 232-239 Link Here
232	VIS_ACTION_PROMPT_SEARCH_BACKWARD,	222	VIS_ACTION_PROMPT_SEARCH_BACKWARD,
233	VIS_ACTION_TILL_LEFT,	223	VIS_ACTION_TILL_LEFT,
234	VIS_ACTION_TILL_RIGHT,	224	VIS_ACTION_TILL_RIGHT,
		225	VIS_ACTION_TILL_LINE_LEFT,
		226	VIS_ACTION_TILL_LINE_RIGHT,
235	VIS_ACTION_TO_LEFT,	227	VIS_ACTION_TO_LEFT,
236	VIS_ACTION_TO_RIGHT,	228	VIS_ACTION_TO_RIGHT,
		229	VIS_ACTION_TO_LINE_LEFT,
		230	VIS_ACTION_TO_LINE_RIGHT,
237	VIS_ACTION_REGISTER,	231	VIS_ACTION_REGISTER,
238	VIS_ACTION_OPERATOR_CHANGE,	232	VIS_ACTION_OPERATOR_CHANGE,
239	VIS_ACTION_OPERATOR_DELETE,	233	VIS_ACTION_OPERATOR_DELETE,
Lines 264-276 Link Here
264	VIS_ACTION_WINDOW_SLIDE_DOWN,	258	VIS_ACTION_WINDOW_SLIDE_DOWN,
265	VIS_ACTION_PUT_AFTER,	259	VIS_ACTION_PUT_AFTER,
266	VIS_ACTION_PUT_BEFORE,	260	VIS_ACTION_PUT_BEFORE,
267	VIS_ACTION_SELECTIONS_MATCH_WORD,
268	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE,	261	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE,
269	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE_FIRST,	262	VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE_FIRST,
270	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW,	263	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW,
271	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW_LAST,	264	VIS_ACTION_SELECTIONS_NEW_LINE_BELOW_LAST,
272	VIS_ACTION_SELECTIONS_NEW_LINES_BEGIN,	265	VIS_ACTION_SELECTIONS_NEW_LINES_BEGIN,
273	VIS_ACTION_SELECTIONS_NEW_LINES_END,	266	VIS_ACTION_SELECTIONS_NEW_LINES_END,
		267	VIS_ACTION_SELECTIONS_NEW_MATCH_ALL,
274	VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT,	268	VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT,
275	VIS_ACTION_SELECTIONS_NEW_MATCH_SKIP,	269	VIS_ACTION_SELECTIONS_NEW_MATCH_SKIP,
276	VIS_ACTION_SELECTIONS_ALIGN,	270	VIS_ACTION_SELECTIONS_ALIGN,
Lines 291-302 Link Here
291	VIS_ACTION_SELECTIONS_INTERSECT,	285	VIS_ACTION_SELECTIONS_INTERSECT,
292	VIS_ACTION_SELECTIONS_COMPLEMENT,	286	VIS_ACTION_SELECTIONS_COMPLEMENT,
293	VIS_ACTION_SELECTIONS_MINUS,	287	VIS_ACTION_SELECTIONS_MINUS,
294	VIS_ACTION_SELECTIONS_COMBINE_UNION,
295	VIS_ACTION_SELECTIONS_COMBINE_INTERSECT,
296	VIS_ACTION_SELECTIONS_COMBINE_LONGER,
297	VIS_ACTION_SELECTIONS_COMBINE_SHORTER,
298	VIS_ACTION_SELECTIONS_COMBINE_LEFTMOST,
299	VIS_ACTION_SELECTIONS_COMBINE_RIGHTMOST,
300	VIS_ACTION_TEXT_OBJECT_WORD_OUTER,	288	VIS_ACTION_TEXT_OBJECT_WORD_OUTER,
301	VIS_ACTION_TEXT_OBJECT_WORD_INNER,	289	VIS_ACTION_TEXT_OBJECT_WORD_INNER,
302	VIS_ACTION_TEXT_OBJECT_LONGWORD_OUTER,	290	VIS_ACTION_TEXT_OBJECT_LONGWORD_OUTER,
Lines 318-325 Link Here
318	VIS_ACTION_TEXT_OBJECT_SINGLE_QUOTE_INNER,	306	VIS_ACTION_TEXT_OBJECT_SINGLE_QUOTE_INNER,
319	VIS_ACTION_TEXT_OBJECT_BACKTICK_OUTER,	307	VIS_ACTION_TEXT_OBJECT_BACKTICK_OUTER,
320	VIS_ACTION_TEXT_OBJECT_BACKTICK_INNER,	308	VIS_ACTION_TEXT_OBJECT_BACKTICK_INNER,
321	VIS_ACTION_TEXT_OBJECT_ENTIRE_OUTER,
322	VIS_ACTION_TEXT_OBJECT_ENTIRE_INNER,
323	VIS_ACTION_TEXT_OBJECT_LINE_OUTER,	309	VIS_ACTION_TEXT_OBJECT_LINE_OUTER,
324	VIS_ACTION_TEXT_OBJECT_LINE_INNER,	310	VIS_ACTION_TEXT_OBJECT_LINE_INNER,
325	VIS_ACTION_TEXT_OBJECT_INDENTATION,	311	VIS_ACTION_TEXT_OBJECT_INDENTATION,
Lines 739-761 Link Here
739	[VIS_ACTION_TILL_LEFT] = {	725	[VIS_ACTION_TILL_LEFT] = {
740	"vis-motion-till-left",	726	"vis-motion-till-left",
741	VIS_HELP("Till after the occurrence of character to the left")	727	VIS_HELP("Till after the occurrence of character to the left")
742	movement_key, { .i = VIS_MOVE_LEFT_TILL }	728	movement_key, { .i = VIS_MOVE_TILL_LEFT }
743	},	729	},
744	[VIS_ACTION_TILL_RIGHT] = {	730	[VIS_ACTION_TILL_RIGHT] = {
745	"vis-motion-till-right",	731	"vis-motion-till-right",
746	VIS_HELP("Till before the occurrence of character to the right")	732	VIS_HELP("Till before the occurrence of character to the right")
747	movement_key, { .i = VIS_MOVE_RIGHT_TILL }	733	movement_key, { .i = VIS_MOVE_TILL_RIGHT }
748	},	734	},
		735	[VIS_ACTION_TILL_LINE_LEFT] = {
		736	"vis-motion-till-line-left",
		737	VIS_HELP("Till after the occurrence of character to the left on the current line")
		738	movement_key, { .i = VIS_MOVE_TILL_LINE_LEFT }
		739	},
		740	[VIS_ACTION_TILL_LINE_RIGHT] = {
		741	"vis-motion-till-line-right",
		742	VIS_HELP("Till before the occurrence of character to the right on the current line")
		743	movement_key, { .i = VIS_MOVE_TILL_LINE_RIGHT }
		744	},
749	[VIS_ACTION_TO_LEFT] = {	745	[VIS_ACTION_TO_LEFT] = {
750	"vis-motion-to-left",	746	"vis-motion-to-left",
751	VIS_HELP("To the first occurrence of character to the left")	747	VIS_HELP("To the first occurrence of character to the left")
752	movement_key, { .i = VIS_MOVE_LEFT_TO }	748	movement_key, { .i = VIS_MOVE_TO_LEFT }
753	},	749	},
754	[VIS_ACTION_TO_RIGHT] = {	750	[VIS_ACTION_TO_RIGHT] = {
755	"vis-motion-to-right",	751	"vis-motion-to-right",
756	VIS_HELP("To the first occurrence of character to the right")	752	VIS_HELP("To the first occurrence of character to the right")
757	movement_key, { .i = VIS_MOVE_RIGHT_TO }	753	movement_key, { .i = VIS_MOVE_TO_RIGHT }
758	},	754	},
		755	[VIS_ACTION_TO_LINE_LEFT] = {
		756	"vis-motion-to-line-left",
		757	VIS_HELP("To the first occurrence of character to the left on the current line")
		758	movement_key, { .i = VIS_MOVE_TO_LINE_LEFT }
		759	},
		760	[VIS_ACTION_TO_LINE_RIGHT] = {
		761	"vis-motion-to-line-right",
		762	VIS_HELP("To the first occurrence of character to the right on the current line")
		763	movement_key, { .i = VIS_MOVE_TO_LINE_RIGHT }
		764	},
759	[VIS_ACTION_REGISTER] = {	765	[VIS_ACTION_REGISTER] = {
760	"vis-register",	766	"vis-register",
761	VIS_HELP("Use given register for next operator")	767	VIS_HELP("Use given register for next operator")
Lines 906-916 Link Here
906	VIS_HELP("Put text before the cursor")	912	VIS_HELP("Put text before the cursor")
907	operator, { .i = VIS_OP_PUT_BEFORE }	913	operator, { .i = VIS_OP_PUT_BEFORE }
908	},	914	},
909	[VIS_ACTION_SELECTIONS_MATCH_WORD] = {
910	"vis-selections-select-word",
911	VIS_HELP("Select word under cursor")
912	selections_match_word,
913	},
914	[VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE] = {	915	[VIS_ACTION_SELECTIONS_NEW_LINE_ABOVE] = {
915	"vis-selection-new-lines-above",	916	"vis-selection-new-lines-above",
916	VIS_HELP("Create a new selection on the line above")	917	VIS_HELP("Create a new selection on the line above")
Lines 941-946 Link Here
941	VIS_HELP("Create a new selection at the end of every line covered by selection")	942	VIS_HELP("Create a new selection at the end of every line covered by selection")
942	operator, { .i = VIS_OP_CURSOR_EOL }	943	operator, { .i = VIS_OP_CURSOR_EOL }
943	},	944	},
		945	[VIS_ACTION_SELECTIONS_NEW_MATCH_ALL] = {
		946	"vis-selection-new-match-all",
		947	VIS_HELP("Select all regions matching the current selection")
		948	selections_match_next, { .b = true }
		949	},
944	[VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT] = {	950	[VIS_ACTION_SELECTIONS_NEW_MATCH_NEXT] = {
945	"vis-selection-new-match-next",	951	"vis-selection-new-match-next",
946	VIS_HELP("Select the next region matching the current selection")	952	VIS_HELP("Select the next region matching the current selection")
Lines 1041-1076 Link Here
1041	VIS_HELP("Subtract selections from mark")	1047	VIS_HELP("Subtract selections from mark")
1042	selections_minus	1048	selections_minus
1043	},	1049	},
1044	[VIS_ACTION_SELECTIONS_COMBINE_UNION] = {
1045	"vis-selections-combine-union",
1046	VIS_HELP("Pairwise union with selections from mark")
1047	selections_combine, { .combine = combine_union }
1048	},
1049	[VIS_ACTION_SELECTIONS_COMBINE_INTERSECT] = {
1050	"vis-selections-combine-intersect",
1051	VIS_HELP("Pairwise intersect with selections from mark")
1052	selections_combine, { .combine = combine_intersect }
1053	},
1054	[VIS_ACTION_SELECTIONS_COMBINE_LONGER] = {
1055	"vis-selections-combine-longer",
1056	VIS_HELP("Pairwise combine: take longer")
1057	selections_combine, { .combine = combine_longer }
1058	},
1059	[VIS_ACTION_SELECTIONS_COMBINE_SHORTER] = {
1060	"vis-selections-combine-shorter",
1061	VIS_HELP("Pairwise combine: take shorter")
1062	selections_combine, { .combine = combine_shorter }
1063	},
1064	[VIS_ACTION_SELECTIONS_COMBINE_LEFTMOST] = {
1065	"vis-selections-combine-leftmost",
1066	VIS_HELP("Pairwise combine: leftmost")
1067	selections_combine, { .combine = combine_leftmost }
1068	},
1069	[VIS_ACTION_SELECTIONS_COMBINE_RIGHTMOST] = {
1070	"vis-selections-combine-rightmost",
1071	VIS_HELP("Pairwise combine: rightmost")
1072	selections_combine, { .combine = combine_rightmost }
1073	},
1074	[VIS_ACTION_TEXT_OBJECT_WORD_OUTER] = {	1050	[VIS_ACTION_TEXT_OBJECT_WORD_OUTER] = {
1075	"vis-textobject-word-outer",	1051	"vis-textobject-word-outer",
1076	VIS_HELP("A word leading and trailing whitespace included")	1052	VIS_HELP("A word leading and trailing whitespace included")
Lines 1176-1191 Link Here
1176	VIS_HELP("A backtick delimited string (inner variant)")	1152	VIS_HELP("A backtick delimited string (inner variant)")
1177	textobj, { .i = VIS_TEXTOBJECT_INNER_BACKTICK }	1153	textobj, { .i = VIS_TEXTOBJECT_INNER_BACKTICK }
1178	},	1154	},
1179	[VIS_ACTION_TEXT_OBJECT_ENTIRE_OUTER] = {
1180	"vis-textobject-entire-outer",
1181	VIS_HELP("The whole text content")
1182	textobj, { .i = VIS_TEXTOBJECT_OUTER_ENTIRE }
1183	},
1184	[VIS_ACTION_TEXT_OBJECT_ENTIRE_INNER] = {
1185	"vis-textobject-entire-inner",
1186	VIS_HELP("The whole text content, except for leading and trailing empty lines")
1187	textobj, { .i = VIS_TEXTOBJECT_INNER_ENTIRE }
1188	},
1189	[VIS_ACTION_TEXT_OBJECT_LINE_OUTER] = {	1155	[VIS_ACTION_TEXT_OBJECT_LINE_OUTER] = {
1190	"vis-textobject-line-outer",	1156	"vis-textobject-line-outer",
1191	VIS_HELP("The whole line")	1157	VIS_HELP("The whole line")
Lines 1389-1407 Link Here
1389	return keys;	1355	return keys;
1390	}	1356	}
1391		1357
1392	static const char selections_match_word(Vis vis, const char keys, const Arg arg) {	1358	static Selection selection_new(View view, Filerange *r, bool isprimary) {
1393	Text *txt = vis_text(vis);
1394	View *view = vis_view(vis);
1395	for (Selection *s = view_selections(view); s; s = view_selections_next(s)) {
1396	Filerange word = text_object_word(txt, view_cursors_pos(s));
1397	if (text_range_valid(&word))
1398	view_selections_set(s, &word);
1399	}
1400	vis_mode_switch(vis, VIS_MODE_VISUAL);
1401	return keys;
1402	}
1403
1404	static const Selection selection_new_primary(View view, Filerange *r) {
1405	Text *txt = view_text(view);	1359	Text *txt = view_text(view);
1406	size_t pos = text_char_prev(txt, r->end);	1360	size_t pos = text_char_prev(txt, r->end);
1407	Selection *s = view_selections_new(view, pos);	1361	Selection *s = view_selections_new(view, pos);
Lines 1409-1449 Link Here
1409	return NULL;	1363	return NULL;
1410	view_selections_set(s, r);	1364	view_selections_set(s, r);
1411	view_selections_anchor(s, true);	1365	view_selections_anchor(s, true);
1412	view_selections_primary_set(s);	1366	if (isprimary)
		1367	view_selections_primary_set(s);
1413	return s;	1368	return s;
1414	}	1369	}
1415		1370
1416	static const char selections_match_next_literal(Vis vis, const char keys, const Arg arg) {
1417	Text *txt = vis_text(vis);
1418	View *view = vis_view(vis);
1419	Selection *s = view_selections_primary_get(view);
1420	Filerange sel = view_selections_get(s);
1421	size_t len = text_range_size(&sel);
1422	if (!len)
1423	return keys;
1424
1425	char *buf = text_bytes_alloc0(txt, sel.start, len);
1426	if (!buf)
1427	return keys;
1428
1429	size_t start = text_find_next(txt, sel.end, buf);
1430	Filerange match = text_range_new(start, start+len);
1431	if (start != sel.end && selection_new_primary(view, &match))
1432	goto out;
1433
1434	sel = view_selections_get(view_selections(view));
1435	start = text_find_prev(txt, sel.start, buf);
1436	if (start == sel.start)
1437	goto out;
1438
1439	match = text_range_new(start, start+len);
1440	selection_new_primary(view, &match);
1441
1442	out:
1443	free(buf);
1444	return keys;
1445	}
1446
1447	static const char selections_match_next(Vis vis, const char keys, const Arg arg) {	1371	static const char selections_match_next(Vis vis, const char keys, const Arg arg) {
1448	Text *txt = vis_text(vis);	1372	Text *txt = vis_text(vis);
1449	View *view = vis_view(vis);	1373	View *view = vis_view(vis);
Lines 1452-1475 Link Here
1452	if (!text_range_valid(&sel))	1376	if (!text_range_valid(&sel))
1453	return keys;	1377	return keys;
1454		1378
1455	Filerange word = text_object_word(txt, view_cursors_pos(s));	1379	static bool match_word;
1456	if (!text_range_equal(&sel, &word))
1457	return selections_match_next_literal(vis, keys, arg);
1458		1380
		1381	if (view_selections_count(view) == 1) {
		1382	Filerange word = text_object_word(txt, view_cursors_pos(s));
		1383	match_word = text_range_equal(&sel, &word);
		1384	}
		1385
		1386	Filerange (find_next)(Text , size_t, const char *) = text_object_word_find_next;
		1387	Filerange (find_prev)(Text , size_t, const char *) = text_object_word_find_prev;
		1388	if (!match_word) {
		1389	find_next = text_object_find_next;
		1390	find_prev = text_object_find_prev;
		1391	}
		1392
1459	char *buf = text_bytes_alloc0(txt, sel.start, text_range_size(&sel));	1393	char *buf = text_bytes_alloc0(txt, sel.start, text_range_size(&sel));
1460	if (!buf)	1394	if (!buf)
1461	return keys;	1395	return keys;
1462		1396
1463	word = text_object_word_find_next(txt, sel.end, buf);	1397	bool match_all = arg->b;
1464	if (text_range_valid(&word) && selection_new_primary(view, &word))	1398	Filerange primary = sel;
1465	goto out;
1466		1399
1467	sel = view_selections_get(view_selections(view));	1400	for (;;) {
1468	word = text_object_word_find_prev(txt, sel.start, buf);	1401	sel = find_next(txt, sel.end, buf);
1469	if (!text_range_valid(&word))	1402	if (!text_range_valid(&sel))
1470	goto out;	1403	break;
1471	selection_new_primary(view, &word);	1404	if (selection_new(view, &sel, !match_all) && !match_all)
		1405	goto out;
		1406	}
1472		1407
		1408	sel = primary;
		1409
		1410	for (;;) {
		1411	sel = find_prev(txt, sel.start, buf);
		1412	if (!text_range_valid(&sel))
		1413	break;
		1414	if (selection_new(view, &sel, !match_all) && !match_all)
		1415	break;
		1416	}
		1417
1473	out:	1418	out:
1474	free(buf);	1419	free(buf);
1475	return keys;	1420	return keys;
Lines 1825-1907 Link Here
1825	return keys;	1770	return keys;
1826	}	1771	}
1827		1772
1828	static Filerange combine_union(const Filerange r1, const Filerange r2) {
1829	if (!r1)
1830	return *r2;
1831	if (!r2)
1832	return *r1;
1833	return text_range_union(r1, r2);
1834	}
1835
1836	static Filerange combine_intersect(const Filerange r1, const Filerange r2) {
1837	if (!r1 \|\| !r2)
1838	return text_range_empty();
1839	return text_range_intersect(r1, r2);
1840	}
1841
1842	static Filerange combine_longer(const Filerange r1, const Filerange r2) {
1843	if (!r1)
1844	return *r2;
1845	if (!r2)
1846	return *r1;
1847	size_t l1 = text_range_size(r1);
1848	size_t l2 = text_range_size(r2);
1849	return l1 < l2 ? r2 : r1;
1850	}
1851
1852	static Filerange combine_shorter(const Filerange r1, const Filerange r2) {
1853	if (!r1)
1854	return *r2;
1855	if (!r2)
1856	return *r1;
1857	size_t l1 = text_range_size(r1);
1858	size_t l2 = text_range_size(r2);
1859	return l1 < l2 ? r1 : r2;
1860	}
1861
1862	static Filerange combine_leftmost(const Filerange r1, const Filerange r2) {
1863	if (!r1)
1864	return *r2;
1865	if (!r2)
1866	return *r1;
1867	return r1->start < r2->start \|\| (r1->start == r2->start && r1->end < r2->end) ? r1 : r2;
1868	}
1869
1870	static Filerange combine_rightmost(const Filerange r1, const Filerange r2) {
1871	if (!r1)
1872	return *r2;
1873	if (!r2)
1874	return *r1;
1875	return r1->start < r2->start \|\| (r1->start == r2->start && r1->end < r2->end) ? r2 : r1;
1876	}
1877
1878	static const char selections_combine(Vis vis, const char keys, const Arg arg) {
1879	Win *win = vis_window(vis);
1880	View *view = vis_view(vis);
1881	enum VisMark mark = vis_mark_used(vis);
1882	Array a = view_selections_get_all(view);
1883	Array b = vis_mark_get(win, mark);
1884	Array sel;
1885	array_init_from(&sel, &a);
1886
1887	Filerange r1 = array_get(&a, 0), r2 = array_get(&b, 0);
1888	for (size_t i = 0, j = 0; r1 \|\| r2; r1 = array_get(&a, ++i), r2 = array_get(&b, ++j)) {
1889	Filerange new = arg->combine(r1, r2);
1890	if (text_range_valid(&new))
1891	array_add(&sel, &new);
1892	}
1893
1894	vis_mark_normalize(&sel);
1895	selections_set(vis, view, &sel);
1896	vis_cancel(vis);
1897
1898	array_release(&a);
1899	array_release(&b);
1900	array_release(&sel);
1901
1902	return keys;
1903	}
1904
1905	static const char replace(Vis vis, const char keys, const Arg arg) {	1773	static const char replace(Vis vis, const char keys, const Arg arg) {
1906	if (!keys[0]) {	1774	if (!keys[0]) {
1907	vis_keymap_disable(vis);	1775	vis_keymap_disable(vis);
Lines 2227-2233 Link Here
2227	vis_motion(vis, VIS_MOVE_LINE_BEGIN);	2095	vis_motion(vis, VIS_MOVE_LINE_BEGIN);
2228	vis_keys_feed(vis, "<vis-motion-line-begin>");	2096	vis_keys_feed(vis, "<vis-motion-line-begin>");
2229	}	2097	}
2230	vis_keys_feed(vis, "<Enter><Up>");	2098	vis_keys_feed(vis, "<Enter><vis-motion-line-up>");
2231	}	2099	}
2232	return keys;	2100	return keys;
2233	}	2101	}
Lines 2360-2365 Link Here
2360	.win_close = vis_lua_win_close,	2228	.win_close = vis_lua_win_close,
2361	.win_highlight = vis_lua_win_highlight,	2229	.win_highlight = vis_lua_win_highlight,
2362	.win_status = vis_lua_win_status,	2230	.win_status = vis_lua_win_status,
		2231	.term_csi = vis_lua_term_csi,
2363	};	2232	};
2364		2233
2365	vis = vis_new(ui_term_new(), &event);	2234	vis = vis_new(ui_term_new(), &event);

Lines 78-96 Link Here

(-)vis-0.6/map.c (-13 lines)
78	return !map_empty(map_prefix(map, prefix));	78	return !map_empty(map_prefix(map, prefix));
79	}	79	}
80		80
81	static bool leaf(const char key, void value, void *data)
82	{
83	int *nodes = data;
84	return (*nodes)++ < 1;
85	}
86
87	bool map_leaf(const Map map, const char prefix)
88	{
89	int nodes = 0;
90	map_iterate(map_prefix(map, prefix), leaf, &nodes);
91	return nodes == 1;
92	}
93
94	bool map_put(Map map, const char k, const void *value)	81	bool map_put(Map map, const char k, const void *value)
95	{	82	{
96	size_t len = strlen(k);	83	size_t len = strlen(k);

Lines 2-8 Link Here

(-)vis-0.6/sam.c (-16 / +25 lines)
2	* Heavily inspired (and partially based upon) the X11 version of	2	* Heavily inspired (and partially based upon) the X11 version of
3	* Rob Pike's sam text editor originally written for Plan 9.	3	* Rob Pike's sam text editor originally written for Plan 9.
4	*	4	*
5	* Copyright © 2016-2018 Marc André Tanner <mat at brain-dump.org>	5	* Copyright © 2016-2020 Marc André Tanner <mat at brain-dump.org>
6	* Copyright © 1998 by Lucent Technologies	6	* Copyright © 1998 by Lucent Technologies
7	*	7	*
8	* Permission to use, copy, modify, and distribute this software for any	8	* Permission to use, copy, modify, and distribute this software for any
Lines 23-28 Link Here
23	#include <errno.h>	23	#include <errno.h>
24	#include <unistd.h>	24	#include <unistd.h>
25	#include <limits.h>	25	#include <limits.h>
		26	#include <fcntl.h>
26	#include "sam.h"	27	#include "sam.h"
27	#include "vis-core.h"	28	#include "vis-core.h"
28	#include "buffer.h"	29	#include "buffer.h"
Lines 144-150 Link Here
144		145
145	static const CommandDef cmds[] = {	146	static const CommandDef cmds[] = {
146	// name help	147	// name help
147	// flags, default command, implemenation	148	// flags, default command, implementation
148	{	149	{
149	"a", VIS_HELP("Append text after range")	150	"a", VIS_HELP("Append text after range")
150	CMD_TEXT, NULL, cmd_append	151	CMD_TEXT, NULL, cmd_append
Lines 277-283 Link Here
277	const char names[3]; / name and optional alias */	278	const char names[3]; / name and optional alias */
278	enum VisOption flags; /* option type, etc. */	279	enum VisOption flags; /* option type, etc. */
279	VIS_HELP_DECL(const char help;) / short, one line help text */	280	VIS_HELP_DECL(const char help;) / short, one line help text */
280	VisOptionFunction func; / option handler, NULL for bulitins */	281	VisOptionFunction func; / option handler, NULL for builtins */
281	void context; / context passed to option handler function */	282	void context; / context passed to option handler function */
282	} OptionDef;	283	} OptionDef;
283		284
Lines 299-304 Link Here
299	OPTION_LOAD_METHOD,	300	OPTION_LOAD_METHOD,
300	OPTION_CHANGE_256COLORS,	301	OPTION_CHANGE_256COLORS,
301	OPTION_LAYOUT,	302	OPTION_LAYOUT,
		303	OPTION_IGNORECASE,
302	};	304	};
303		305
304	static const OptionDef options[] = {	306	static const OptionDef options[] = {
Lines 387-392 Link Here
387	VIS_OPTION_TYPE_STRING,	389	VIS_OPTION_TYPE_STRING,
388	VIS_HELP("Vertical or horizontal window layout")	390	VIS_HELP("Vertical or horizontal window layout")
389	},	391	},
		392	[OPTION_IGNORECASE] = {
		393	{ "ignorecase", "ic" },
		394	VIS_OPTION_TYPE_BOOL,
		395	VIS_HELP("Ignore case when searching")
		396	},
390	};	397	};
391		398
392	bool sam_init(Vis *vis) {	399	bool sam_init(Vis *vis) {
Lines 1005-1011 Link Here
1005	size_t start = range->start, end = range->end, line;	1012	size_t start = range->start, end = range->end, line;
1006	if (sign > 0) {	1013	if (sign > 0) {
1007	char c;	1014	char c;
1008	if (start < end && end > 0 && text_byte_get(txt, end-1, &c) && c == '\n')	1015	if (start < end && text_byte_get(txt, end-1, &c) && c == '\n')
1009	end--;	1016	end--;
1010	line = text_lineno_by_pos(txt, end);	1017	line = text_lineno_by_pos(txt, end);
1011	line = text_pos_by_lineno(txt, line + offset);	1018	line = text_pos_by_lineno(txt, line + offset);
Lines 1386-1399 Link Here
1386	Text *txt = win->file->text;	1393	Text *txt = win->file->text;
1387		1394
1388	if (cmd->regex) {	1395	if (cmd->regex) {
1389	bool trailing_match = false;	1396	size_t start = range->start, end = range->end;
1390	size_t start = range->start, end = range->end, last_start = EPOS;	1397	size_t last_start = argv[0][0] == 'x' ? EPOS : start;
1391	size_t nsub = 1 + text_regex_nsub(cmd->regex);	1398	size_t nsub = 1 + text_regex_nsub(cmd->regex);
1392	if (nsub > MAX_REGEX_SUB)	1399	if (nsub > MAX_REGEX_SUB)
1393	nsub = MAX_REGEX_SUB;	1400	nsub = MAX_REGEX_SUB;
1394	RegexMatch match[MAX_REGEX_SUB];	1401	RegexMatch match[MAX_REGEX_SUB];
1395	while (start < end \|\| trailing_match) {	1402	while (start <= end) {
1396	trailing_match = false;
1397	char c;	1403	char c;
1398	int flags = start > range->start &&	1404	int flags = start > range->start &&
1399	text_byte_get(txt, start - 1, &c) && c != '\n' ?	1405	text_byte_get(txt, start - 1, &c) && c != '\n' ?
Lines 1406-1412 Link Here
1406	if (argv[0][0] == 'x')	1412	if (argv[0][0] == 'x')
1407	r = text_range_new(match[0].start, match[0].end);	1413	r = text_range_new(match[0].start, match[0].end);
1408	else	1414	else
1409	r = text_range_new(start, match[0].start);	1415	r = text_range_new(last_start, match[0].start);
1410	if (match[0].start == match[0].end) {	1416	if (match[0].start == match[0].end) {
1411	if (last_start == match[0].start) {	1417	if (last_start == match[0].start) {
1412	start++;	1418	start++;
Lines 1417-1432 Link Here
1417	* matches the zero-length string immediately after a	1423	* matches the zero-length string immediately after a
1418	* newline. Try filtering out the last such match at EOF.	1424	* newline. Try filtering out the last such match at EOF.
1419	*/	1425	*/
1420	if (end == match[0].start && start > range->start)	1426	if (end == match[0].start && start > range->start &&
		1427	text_byte_get(txt, end-1, &c) && c == '\n')
1421	break;	1428	break;
		1429	start = match[0].end + 1;
		1430	} else {
		1431	start = match[0].end;
1422	}	1432	}
1423	start = match[0].end;
1424	if (start == end)
1425	trailing_match = true;
1426	} else {	1433	} else {
1427	if (argv[0][0] == 'y')	1434	if (argv[0][0] == 'y')
1428	r = text_range_new(start, end);	1435	r = text_range_new(start, end);
1429	start = end;	1436	start = end + 1;
1430	}	1437	}
1431		1438
1432	if (text_range_valid(&r)) {	1439	if (text_range_valid(&r)) {
Lines 1435-1446 Link Here
1435	Register *reg = &vis->registers[VIS_REG_AMPERSAND+i];	1442	Register *reg = &vis->registers[VIS_REG_AMPERSAND+i];
1436	register_put_range(vis, reg, txt, &match[i]);	1443	register_put_range(vis, reg, txt, &match[i]);
1437	}	1444	}
		1445	last_start = match[0].end;
		1446	} else {
		1447	last_start = start;
1438	}	1448	}
1439	if (simulate)	1449	if (simulate)
1440	count++;	1450	count++;
1441	else	1451	else
1442	ret &= sam_execute(vis, win, cmd->cmd, NULL, &r);	1452	ret &= sam_execute(vis, win, cmd->cmd, NULL, &r);
1443	last_start = start;
1444	}	1453	}
1445	}	1454	}
1446	} else {	1455	} else {
Lines 1670-1676 Link Here
1670	if (write_entire_file)	1679	if (write_entire_file)
1671	*r = text_range_new(0, text_size(text));	1680	*r = text_range_new(0, text_size(text));
1672		1681
1673	TextSave *ctx = text_save_begin(text, path, file->save_method);	1682	TextSave *ctx = text_save_begin(text, AT_FDCWD, path, file->save_method);
1674	if (!ctx) {	1683	if (!ctx) {
1675	const char *msg = errno ? strerror(errno) : "try changing `:set savemethod`";	1684	const char *msg = errno ? strerror(errno) : "try changing `:set savemethod`";
1676	vis_info_show(vis, "Can't write `%s': %s", path, msg);	1685	vis_info_show(vis, "Can't write `%s': %s", path, msg);

Lines 1-8 Link Here

(-)vis-0.6/text-motions.h (-7 / +7 lines)
1	#ifndef TEXT_MOTIONS_H	1	#ifndef TEXT_MOTIONS_H
2	#define TEXT_MOTIONS_H	2	#define TEXT_MOTIONS_H
3		3
4	/* these function all take a position in bytes from the start of the file,	4	/* these functions all take a position in bytes from the start of the file,
5	* perform a certain movement and return the new postion. if the movement	5	* perform a certain movement and return the new postion. If the movement
6	* is not possible the original position is returned unchanged. */	6	* is not possible the original position is returned unchanged. */
7		7
8	#include <stddef.h>	8	#include <stddef.h>
Lines 20-26 Link Here
20	size_t text_codepoint_prev(Text*, size_t pos);	20	size_t text_codepoint_prev(Text*, size_t pos);
21		21
22	/* find the given substring either in forward or backward direction.	22	/* find the given substring either in forward or backward direction.
23	* does not wrap around at file start / end. if no match is found return	23	* does not wrap around at file start / end. If no match is found return
24	* original position */	24	* original position */
25	size_t text_find_next(Text, size_t pos, const char s);	25	size_t text_find_next(Text, size_t pos, const char s);
26	size_t text_find_prev(Text, size_t pos, const char s);	26	size_t text_find_prev(Text, size_t pos, const char s);
Lines 69-75 Link Here
69	/*	69	/*
70	* A longword consists of a sequence of non-blank characters, separated with	70	* A longword consists of a sequence of non-blank characters, separated with
71	* white space. TODO?: An empty line is also considered to be a word.	71	* white space. TODO?: An empty line is also considered to be a word.
72	* This is equivalant to a WORD in vim terminology.	72	* This is equivalent to a WORD in vim terminology.
73	*/	73	*/
74	size_t text_longword_end_next(Text*, size_t pos);	74	size_t text_longword_end_next(Text*, size_t pos);
75	size_t text_longword_end_prev(Text*, size_t pos);	75	size_t text_longword_end_prev(Text*, size_t pos);
Lines 79-85 Link Here
79	* A word consists of a sequence of letters, digits and underscores, or a	79	* A word consists of a sequence of letters, digits and underscores, or a
80	* sequence of other non-blank characters, separated with white space.	80	* sequence of other non-blank characters, separated with white space.
81	* TODO?: An empty line is also considered to be a word.	81	* TODO?: An empty line is also considered to be a word.
82	* This is equivalant to a word (lowercase) in vim terminology.	82	* This is equivalent to a word (lowercase) in vim terminology.
83	*/	83	*/
84	size_t text_word_end_next(Text*, size_t pos);	84	size_t text_word_end_next(Text*, size_t pos);
85	size_t text_word_end_prev(Text*, size_t pos);	85	size_t text_word_end_prev(Text*, size_t pos);
Lines 116-128 Link Here
116	size_t text_block_end(Text*, size_t pos);	116	size_t text_block_end(Text*, size_t pos);
117	size_t text_parenthesis_start(Text*, size_t pos);	117	size_t text_parenthesis_start(Text*, size_t pos);
118	size_t text_parenthesis_end(Text*, size_t pos);	118	size_t text_parenthesis_end(Text*, size_t pos);
119	/* search coresponding '(', ')', '{', '}', '[', ']', '>', '<', '"', ''' */	119	/* search corresponding '(', ')', '{', '}', '[', ']', '>', '<', '"', ''' */
120	size_t text_bracket_match(Text, size_t pos, const Filerange limits);	120	size_t text_bracket_match(Text, size_t pos, const Filerange limits);
121	/* same as above but explicitly specify symbols to match */	121	/* same as above but explicitly specify symbols to match */
122	size_t text_bracket_match_symbol(Text, size_t pos, const char symbols, const Filerange *limits);	122	size_t text_bracket_match_symbol(Text, size_t pos, const char symbols, const Filerange *limits);
123		123
124	/* search the given regex pattern in either forward or backward direction,	124	/* search the given regex pattern in either forward or backward direction,
125	* starting from pos. does wrap around if no match was found. */	125	* starting from pos. Does wrap around if no match was found. */
126	size_t text_search_forward(Text txt, size_t pos, Regex regex);	126	size_t text_search_forward(Text txt, size_t pos, Regex regex);
127	size_t text_search_backward(Text txt, size_t pos, Regex regex);	127	size_t text_search_backward(Text txt, size_t pos, Regex regex);
128		128

Lines 15-33 Link Here

(-)vis-0.6/text-objects.c (-31 / +31 lines)
15	return text_range_new(0, text_size(txt));	15	return text_range_new(0, text_size(txt));
16	}	16	}
17		17
18	Filerange text_object_entire_inner(Text *txt, size_t pos) {
19	char c;
20	Filerange r = text_object_entire(txt, pos);
21	Iterator it = text_iterator_get(txt, r.start);
22	if (text_iterator_byte_get(&it, &c) && c == '\n')
23	while (text_iterator_byte_next(&it, &c) && c == '\n');
24	r.start = it.pos;
25	it = text_iterator_get(txt, r.end);
26	while (text_iterator_char_prev(&it, &c) && c == '\n');
27	r.end = it.pos;
28	return text_range_linewise(txt, &r);
29	}
30
31	static Filerange text_object_customword(Text txt, size_t pos, int (isboundary)(int)) {	18	static Filerange text_object_customword(Text txt, size_t pos, int (isboundary)(int)) {
32	Filerange r;	19	Filerange r;
33	char c, prev = '0', next = '0';	20	char c, prev = '0', next = '0';
Lines 40-66 Link Here
40	if (space(c)) {	27	if (space(c)) {
41	r.start = text_char_next(txt, text_customword_end_prev(txt, pos, isboundary));	28	r.start = text_char_next(txt, text_customword_end_prev(txt, pos, isboundary));
42	r.end = text_customword_start_next(txt, pos, isboundary);	29	r.end = text_customword_start_next(txt, pos, isboundary);
43	} else if (boundary(prev) && boundary(next)) {	30	} else if (boundary(c)) {
44	if (boundary(c)) {	31	if (boundary(prev) && !space(prev))
45	r.start = text_char_next(txt, text_customword_end_prev(txt, pos, isboundary));	32	r.start = text_customword_start_prev(txt, pos, isboundary);
46	r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));	33	else
47	} else {
48	/* on a single character */
49	r.start = pos;	34	r.start = pos;
		35
		36	if (boundary(next) && !space(next))
		37	r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
		38	else
50	r.end = text_char_next(txt, pos);	39	r.end = text_char_next(txt, pos);
51	}
52	} else if (boundary(prev)) {
53	/* at start of a word */
54	r.start = pos;
55	r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
56	} else if (boundary(next)) {
57	/* at end of a word */
58	r.start = text_customword_start_prev(txt, pos, isboundary);
59	r.end = text_char_next(txt, pos);
60	} else {	40	} else {
61	/* in the middle of a word */	41	if (boundary(prev))
62	r.start = text_customword_start_prev(txt, pos, isboundary);	42	r.start = pos;
63	r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));	43	else
		44	r.start = text_customword_start_prev(txt, pos, isboundary);
		45
		46	if (boundary(next))
		47	r.end = text_char_next(txt, pos);
		48	else
		49	r.end = text_char_next(txt, text_customword_end_next(txt, pos, isboundary));
64	}	50	}
65		51
66	return r;	52	return r;
Lines 149-154 Link Here
149	return text_range_empty();	135	return text_range_empty();
150	}	136	}
151	}	137	}
		138	}
		139
		140	Filerange text_object_find_next(Text txt, size_t pos, const char search) {
		141	size_t start = text_find_next(txt, pos, search);
		142	if (start == pos)
		143	return text_range_empty();
		144	return text_range_new(start, start+strlen(search));
		145	}
		146
		147	Filerange text_object_find_prev(Text txt, size_t pos, const char search) {
		148	size_t start = text_find_prev(txt, pos, search);
		149	if (start == pos)
		150	return text_range_empty();
		151	return text_range_new(start, start+strlen(search));
152	}	152	}
153		153
154	Filerange text_object_line(Text *txt, size_t pos) {	154	Filerange text_object_line(Text *txt, size_t pos) {

Lines 1-8 Link Here

(-)vis-0.6/text-objects.h (-7 / +8 lines)
1	#ifndef TEXT_OBJECTS_H	1	#ifndef TEXT_OBJECTS_H
2	#define TEXT_OBJECTS_H	2	#define TEXT_OBJECTS_H
3		3
4	/* these functions all take a file position. if this position is part of the	4	/* these functions all take a file position. If this position is part of the
5	* respective text-object, a corresponding range is returned. if there is no	5	* respective text-object, a corresponding range is returned. If there is no
6	* such text-object at the given location, an empty range is returned.	6	* such text-object at the given location, an empty range is returned.
7	*/	7	*/
8		8
Lines 11-26 Link Here
11		11
12	/* return range covering the entire text */	12	/* return range covering the entire text */
13	Filerange text_object_entire(Text*, size_t pos);	13	Filerange text_object_entire(Text*, size_t pos);
14	/* entire document except leading and trailing empty lines */
15	Filerange text_object_entire_inner(Text*, size_t pos);
16	/* word which happens to be at pos without any neighbouring white spaces */	14	/* word which happens to be at pos without any neighbouring white spaces */
17	Filerange text_object_word(Text*, size_t pos);	15	Filerange text_object_word(Text*, size_t pos);
18	/* includes trailing white spaces. if at pos happens to be a white space	16	/* includes trailing white spaces. If at pos happens to be a white space
19	* include all neighbouring leading white spaces and the following word. */	17	* include all neighbouring leading white spaces and the following word. */
20	Filerange text_object_word_outer(Text*, size_t pos);	18	Filerange text_object_word_outer(Text*, size_t pos);
21	/* find next occurance of `word' (as word not substring) in forward/backward direction */	19	/* find next occurence of `word' (as word not substring) in forward/backward direction */
22	Filerange text_object_word_find_next(Text, size_t pos, const char word);	20	Filerange text_object_word_find_next(Text, size_t pos, const char word);
23	Filerange text_object_word_find_prev(Text, size_t pos, const char word);	21	Filerange text_object_word_find_prev(Text, size_t pos, const char word);
		22	/* find next occurence of a literal string (not regex) in forward/backward direction */
		23	Filerange text_object_find_next(Text txt, size_t pos, const char search);
		24	Filerange text_object_find_prev(Text txt, size_t pos, const char search);
24	/* same semantics as above but for a longword (i.e. delimited by white spaces) */	25	/* same semantics as above but for a longword (i.e. delimited by white spaces) */
25	Filerange text_object_longword(Text*, size_t pos);	26	Filerange text_object_longword(Text*, size_t pos);
26	Filerange text_object_longword_outer(Text*, size_t pos);	27	Filerange text_object_longword_outer(Text*, size_t pos);
Lines 43-49 Link Here
43	/* match a search term in either forward or backward direction */	44	/* match a search term in either forward or backward direction */
44	Filerange text_object_search_forward(Text, size_t pos, Regex);	45	Filerange text_object_search_forward(Text, size_t pos, Regex);
45	Filerange text_object_search_backward(Text, size_t pos, Regex);	46	Filerange text_object_search_backward(Text, size_t pos, Regex);
46	/* match all lines with same indendation level than the current one */	47	/* match all lines with same indentation level as the current one */
47	Filerange text_object_indentation(Text*, size_t pos);	48	Filerange text_object_indentation(Text*, size_t pos);
48		49
49	/* extend a range to cover whole lines */	50	/* extend a range to cover whole lines */

Lines 12-18 Link Here

(-)vis-0.6/text.h (-44 / +52 lines)
12	/** A mark. */	12	/** A mark. */
13	typedef uintptr_t Mark;	13	typedef uintptr_t Mark;
14		14
15	/** An invalid mark, lookup of which will yield `EPOS`. */	15	/** An invalid mark, lookup of which will yield ``EPOS``. */
16	#define EMARK ((Mark)0)	16	#define EMARK ((Mark)0)
17	/** An invalid position. */	17	/** An invalid position. */
18	#define EPOS ((size_t)-1)	18	#define EPOS ((size_t)-1)
Lines 75-87 Link Here
75	*/	75	*/
76	TEXT_LOAD_READ,	76	TEXT_LOAD_READ,
77	/**	77	/**
78	* Memory map the the file from disk. Use file system / virtual memory	78	* Memory map the file from disk. Use file system / virtual memory
79	* subsystem as a caching layer.	79	* subsystem as a caching layer.
80	* @rst	80	* @rst
81	* .. note:: Load time is (almost) independent of the file size.	81	* .. note:: Load time is (almost) independent of the file size.
82	* .. warning:: Inplace modifications of the underlying file	82	* .. warning:: Inplace modifications of the underlying file
83	* will be reflected in the current text content.	83	* will be reflected in the current text content.
84	* In particular, truncatenation will raise ``SIGBUS``	84	* In particular, truncation will raise ``SIGBUS``
85	* and result in data loss.	85	* and result in data loss.
86	* @endrst	86	* @endrst
87	*/	87	*/
Lines 95-100 Link Here
95	* @endrst	95	* @endrst
96	*/	96	*/
97	Text text_load(const char filename);	97	Text text_load(const char filename);
		98	Text text_loadat(int dirfd, const char filename);
98	/**	99	/**
99	* Create a text instance populated with the given file content.	100	* Create a text instance populated with the given file content.
100	*	101	*
Lines 109-115 Link Here
109	* @endrst	110	* @endrst
110	*/	111	*/
111	Text text_load_method(const char filename, enum TextLoadMethod);	112	Text text_load_method(const char filename, enum TextLoadMethod);
112	/** Release all ressources associated with this text instance. */	113	Text text_loadat_method(int dirfd, const char filename, enum TextLoadMethod);
		114	/** Release all resources associated with this text instance. */
113	void text_free(Text*);	115	void text_free(Text*);
114	/**	116	/**
115	* @}	117	* @}
Lines 117-123 Link Here
117	* @{	119	* @{
118	*/	120	*/
119	/** Return the size in bytes of the whole text. */	121	/** Return the size in bytes of the whole text. */
120	size_t text_size(Text*);	122	size_t text_size(const Text*);
121	/**	123	/**
122	* Get file information at time of load or last save, whichever happened more	124	* Get file information at time of load or last save, whichever happened more
123	* recently.	125	* recently.
Lines 128-136 Link Here
128	* @endrst	130	* @endrst
129	* @return See ``stat(2)`` for details.	131	* @return See ``stat(2)`` for details.
130	*/	132	*/
131	struct stat text_stat(Text*);	133	struct stat text_stat(const Text*);
132	/** Query whether the text contains any unsaved modifications. */	134	/** Query whether the text contains any unsaved modifications. */
133	bool text_modified(Text*);	135	bool text_modified(const Text*);
134	/**	136	/**
135	* @}	137	* @}
136	* @defgroup modify	138	* @defgroup modify
Lines 153-159 Link Here
153	* @return Whether the deletion succeeded.	155	* @return Whether the deletion succeeded.
154	*/	156	*/
155	bool text_delete(Text*, size_t pos, size_t len);	157	bool text_delete(Text*, size_t pos, size_t len);
156	bool text_delete_range(Text, Filerange);	158	bool text_delete_range(Text, const Filerange);
157	bool text_printf(Text, size_t pos, const char format, ...) __attribute__((format(printf, 3, 4)));	159	bool text_printf(Text, size_t pos, const char format, ...) __attribute__((format(printf, 3, 4)));
158	bool text_appendf(Text, const char format, ...) __attribute__((format(printf, 2, 3)));	160	bool text_appendf(Text, const char format, ...) __attribute__((format(printf, 2, 3)));
159	/**	161	/**
Lines 162-170 Link Here
162	* @{	164	* @{
163	*/	165	*/
164	/**	166	/**
165	* Create a text snapshot, that is a vertice in the history graph.	167	* Create a text snapshot, that is a vertex in the history graph.
166	*/	168	*/
167	void text_snapshot(Text*);	169	bool text_snapshot(Text*);
168	/**	170	/**
169	* Revert to previous snapshot along the main branch.	171	* Revert to previous snapshot along the main branch.
170	* @rst	172	* @rst
Lines 195-201 Link Here
195	* .. note:: TODO: This is currently not the same as the time of the last snapshot.	197	* .. note:: TODO: This is currently not the same as the time of the last snapshot.
196	* @endrst	198	* @endrst
197	*/	199	*/
198	time_t text_state(Text*);	200	time_t text_state(const Text*);
199	/**	201	/**
200	* @}	202	* @}
201	* @defgroup lines	203	* @defgroup lines
Lines 219-227 Link Here
219	* return an artificial NUL byte at EOF.	221	* return an artificial NUL byte at EOF.
220	* @endrst	222	* @endrst
221	*/	223	*/
222	bool text_byte_get(Text, size_t pos, char byte);	224	bool text_byte_get(const Text, size_t pos, char byte);
223	/**	225	/**
224	* Store at most `len` bytes starting from ``pos`` into ``buf``.	226	* Store at most ``len`` bytes starting from ``pos`` into ``buf``.
225	* @param pos The absolute starting position.	227	* @param pos The absolute starting position.
226	* @param len The length in bytes.	228	* @param len The length in bytes.
227	* @param buf The destination buffer.	229	* @param buf The destination buffer.
Lines 230-254 Link Here
230	* .. warning:: ``buf`` will not be NUL terminated.	232	* .. warning:: ``buf`` will not be NUL terminated.
231	* @endrst	233	* @endrst
232	*/	234	*/
233	size_t text_bytes_get(Text, size_t pos, size_t len, char buf);	235	size_t text_bytes_get(const Text, size_t pos, size_t len, char buf);
234	/**	236	/**
235	* Fetch text range into newly allocate memory region.	237	* Fetch text range into newly allocate memory region.
236	* @param pos The absolute starting position.	238	* @param pos The absolute starting position.
237	* @param len The length in bytes.	239	* @param len The length in bytes.
238	* @return A contigious NUL terminated buffer holding the requested range, or	240	* @return A contiguous NUL terminated buffer holding the requested range, or
239	* ``NULL`` in error case.	241	* ``NULL`` in error case.
240	* @rst	242	* @rst
241	* .. warning:: The returned pointer must be `free(3)`-ed by the caller.	243	* .. warning:: The returned pointer must be freed by the caller.
242	* @endrst	244	* @endrst
243	*/	245	*/
244	char text_bytes_alloc0(Text, size_t pos, size_t len);	246	char text_bytes_alloc0(const Text, size_t pos, size_t len);
245	/**	247	/**
246	* @}	248	* @}
247	* @defgroup iterator	249	* @defgroup iterator
248	* @{	250	* @{
249	*/	251	*/
250	Iterator text_iterator_get(Text*, size_t pos);	252	Iterator text_iterator_get(const Text*, size_t pos);
		253	bool text_iterator_init(const Text, Iterator, size_t pos);
		254	const Text text_iterator_text(const Iterator);
251	bool text_iterator_valid(const Iterator*);	255	bool text_iterator_valid(const Iterator*);
		256	bool text_iterator_has_next(const Iterator*);
		257	bool text_iterator_has_prev(const Iterator*);
252	bool text_iterator_next(Iterator*);	258	bool text_iterator_next(Iterator*);
253	bool text_iterator_prev(Iterator*);	259	bool text_iterator_prev(Iterator*);
254	/**	260	/**
Lines 256-262 Link Here
256	* @defgroup iterator_byte	262	* @defgroup iterator_byte
257	* @{	263	* @{
258	*/	264	*/
259	bool text_iterator_byte_get(Iterator, char b);	265	bool text_iterator_byte_get(const Iterator, char b);
260	bool text_iterator_byte_prev(Iterator, char b);	266	bool text_iterator_byte_prev(Iterator, char b);
261	bool text_iterator_byte_next(Iterator, char b);	267	bool text_iterator_byte_next(Iterator, char b);
262	bool text_iterator_byte_find_prev(Iterator*, char b);	268	bool text_iterator_byte_find_prev(Iterator*, char b);
Lines 283-301 Link Here
283	/**	289	/**
284	* Set a mark.	290	* Set a mark.
285	* @rst	291	* @rst
286	* .. note:: Setting a mark to `text_size` will always return the current text	292	* .. note:: Setting a mark to ``text_size`` will always return the
287	* size upon lookup.	293	* current text size upon lookup.
288	* @endrst	294	* @endrst
289	* @param pos The position at which to store the mark.	295	* @param pos The position at which to store the mark.
290	* @return The mark or `EMARK` if an invalid position was given.	296	* @return The mark or ``EMARK`` if an invalid position was given.
291	*/	297	*/
292	Mark text_mark_set(Text*, size_t pos);	298	Mark text_mark_set(Text*, size_t pos);
293	/**	299	/**
294	* Lookup a mark.	300	* Lookup a mark.
295	* @param mark The mark to look up.	301	* @param mark The mark to look up.
296	* @return The byte position or `EPOS` for an invalid mark.	302	* @return The byte position or ``EPOS`` for an invalid mark.
297	*/	303	*/
298	size_t text_mark_get(Text*, Mark);	304	size_t text_mark_get(const Text*, Mark);
299	/**	305	/**
300	* @}	306	* @}
301	* @defgroup save	307	* @defgroup save
Lines 308-319 Link Here
308	/** Automatically chose best option. */	314	/** Automatically chose best option. */
309	TEXT_SAVE_AUTO,	315	TEXT_SAVE_AUTO,
310	/**	316	/**
311	* Save file atomically using `rename(2)`.	317	* Save file atomically using ``rename(2)``.
312	*	318	*
313	* Creates a temporary file, restores all important meta data,	319	* Creates a temporary file, restores all important meta data,
314	* before moving it atomically to its final (possibly already	320	* before moving it atomically to its final (possibly already
315	* existing) destination using `rename(2)`. For new files,	321	* existing) destination using ``rename(2)``. For new files,
316	* permissions are set to `0666 & ~umask`.	322	* permissions are set to ``0666 & ~umask``.
317	*	323	*
318	* @rst	324	* @rst
319	* .. warning:: This approach does not work if:	325	* .. warning:: This approach does not work if:
Lines 323-329 Link Here
323	* - File ownership can not be preserved.	329	* - File ownership can not be preserved.
324	* - File group can not be preserved.	330	* - File group can not be preserved.
325	* - Directory permissions do not allow creation of a new file.	331	* - Directory permissions do not allow creation of a new file.
326	* - POSXI ACL can not be preserved (if enabled).	332	* - POSIX ACL can not be preserved (if enabled).
327	* - SELinux security context can not be preserved (if enabled).	333	* - SELinux security context can not be preserved (if enabled).
328	* @endrst	334	* @endrst
329	*/	335	*/
Lines 339-377 Link Here
339		345
340	/**	346	/**
341	* Save the whole text to the given file name.	347	* Save the whole text to the given file name.
342	*/
343	bool text_save(Text, const char filename);
344	/**
345	* Save the whole text to the given file name, using the specified method.
346	*	348	*
347	* @rst	349	* @rst
348	* .. note:: Equivalent to ``text_save_method(filename, TEXT_SAVE_AUTO)``.	350	* .. note:: Equivalent to ``text_save_method(filename, TEXT_SAVE_AUTO)``.
349	* @endrst	351	* @endrst
350	*/	352	*/
		353	bool text_save(Text, const char filename);
		354	bool text_saveat(Text, int dirfd, const char filename);
		355	/**
		356	* Save the whole text to the given file name, using the specified method.
		357	*/
351	bool text_save_method(Text, const char filename, enum TextSaveMethod);	358	bool text_save_method(Text, const char filename, enum TextSaveMethod);
		359	bool text_saveat_method(Text, int dirfd, const char filename, enum TextSaveMethod);
352		360
353	/**	361	/**
354	* Setup a sequence of write operations.	362	* Setup a sequence of write operations.
355	*	363	*
356	* The returned `TextSave` pointer can be used to write multiple, possibly	364	* The returned ``TextSave`` pointer can be used to write multiple, possibly
357	* non-contigious, file ranges.	365	* non-contiguous, file ranges.
358	* @rst	366	* @rst
359	* .. warning:: For every call to `text_save_begin` there must be exactly	367	* .. warning:: For every call to ``text_save_begin`` there must be exactly
360	* one matching call to either `text_save_commit` or	368	* one matching call to either ``text_save_commit`` or
361	* `text_save_cancel` to release the underlying resources.	369	* ``text_save_cancel`` to release the underlying resources.
362	* @endrst	370	* @endrst
363	*/	371	*/
364	TextSave text_save_begin(Text, const char *filename, enum TextSaveMethod);	372	TextSave text_save_begin(Text, int dirfd, const char *filename, enum TextSaveMethod);
365	/**	373	/**
366	* Write file range.	374	* Write file range.
367	* @return The number of bytes written or ``-1`` in case of an error.	375	* @return The number of bytes written or ``-1`` in case of an error.
368	*/	376	*/
369	ssize_t text_save_write_range(TextSave, Filerange);	377	ssize_t text_save_write_range(TextSave, const Filerange);
370	/**	378	/**
371	* Commit changes to disk.	379	* Commit changes to disk.
372	* @return Whether changes have been saved.	380	* @return Whether changes have been saved.
373	* @rst	381	* @rst
374	* .. note:: Releases the underlying resources and `free(3)`'s the given `TextSave`	382	* .. note:: Releases the underlying resources and frees the given ``TextSave``
375	* pointer which must no longer be used.	383	* pointer which must no longer be used.
376	* @endrst	384	* @endrst
377	*/	385	*/
Lines 381-387 Link Here
381	* @rst	389	* @rst
382	* .. note:: Does not guarantee to undo the previous writes (they might have been	390	* .. note:: Does not guarantee to undo the previous writes (they might have been
383	* performed in-place). However, it releases the underlying resources and	391	* performed in-place). However, it releases the underlying resources and
384	* `free(3)`'s the given `TextSave` pointer which must no longer be used.	392	* frees the given ``TextSave`` pointer which must no longer be used.
385	* @endrst	393	* @endrst
386	*/	394	*/
387	void text_save_cancel(TextSave*);	395	void text_save_cancel(TextSave*);
Lines 389-400 Link Here
389	* Write whole text content to file descriptor.	397	* Write whole text content to file descriptor.
390	* @return The number of bytes written or ``-1`` in case of an error.	398	* @return The number of bytes written or ``-1`` in case of an error.
391	*/	399	*/
392	ssize_t text_write(Text*, int fd);	400	ssize_t text_write(const Text*, int fd);
393	/**	401	/**
394	* Write file range to file descriptor.	402	* Write file range to file descriptor.
395	* @return The number of bytes written or ``-1`` in case of an error.	403	* @return The number of bytes written or ``-1`` in case of an error.
396	*/	404	*/
397	ssize_t text_write_range(Text, Filerange, int fd);	405	ssize_t text_write_range(const Text, const Filerange, int fd);
398	/**	406	/**
399	* @}	407	* @}
400	* @defgroup misc	408	* @defgroup misc
Lines 404-410 Link Here
404	* Check whether ``ptr`` is part of a memory mapped region associated with	412	* Check whether ``ptr`` is part of a memory mapped region associated with
405	* this text instance.	413	* this text instance.
406	*/	414	*/
407	bool text_mmaped(Text, const char ptr);	415	bool text_mmaped(const Text, const char ptr);
408	/** @} */	416	/** @} */
409		417
410	#endif	418	#endif

Lines 56-68 Link Here

(-)vis-0.6/view.h (-11 / +11 lines)
56	/**	56	/**
57	* Get window coordinate of text position.	57	* Get window coordinate of text position.
58	* @param pos The position to query.	58	* @param pos The position to query.
59	* @param line Will be updated with screen line on which `pos` resides.	59	* @param line Will be updated with screen line on which ``pos`` resides.
60	* @param row Will be updaded with zero based window row on which `pos` resides.	60	* @param row Will be updaded with zero based window row on which ``pos`` resides.
61	* @param col Will be updated with zero based window column which `pos` resides.	61	* @param col Will be updated with zero based window column on which ``pos`` resides.
62	* @return Whether `pos` is visible. If not, the pointer arguments are left unmodified.	62	* @return Whether ``pos`` is visible. If not, the pointer arguments are left unmodified.
63	*/	63	*/
64	bool view_coord_get(View, size_t pos, Line line, int row, int *col);	64	bool view_coord_get(View, size_t pos, Line line, int row, int *col);
65	/** Get position at the start ot the `n`-th window line, counting from 1. */	65	/** Get position at the start of the ``n``-th window line, counting from 1. */
66	size_t view_screenline_goto(View*, int n);	66	size_t view_screenline_goto(View*, int n);
67	/** Get first screen line. */	67	/** Get first screen line. */
68	Line view_lines_first(View);	68	Line view_lines_first(View);
Lines 122-128 Link Here
122	/**	122	/**
123	* Dispose an existing selection.	123	* Dispose an existing selection.
124	* @rst	124	* @rst
125	* .. warning:: Not applicaple for the last existing selection.	125	* .. warning:: Not applicable for the last existing selection.
126	* @endrst	126	* @endrst
127	*/	127	*/
128	bool view_selections_dispose(Selection*);	128	bool view_selections_dispose(Selection*);
Lines 138-144 Link Here
138	* Query state of primary selection.	138	* Query state of primary selection.
139	*	139	*
140	* If the primary selection was marked for destruction, return it and	140	* If the primary selection was marked for destruction, return it and
141	* clear descruction flag.	141	* clear destruction flag.
142	*/	142	*/
143	Selection view_selection_disposed(View);	143	Selection view_selection_disposed(View);
144	/** Dispose all but the primary selection. */	144	/** Dispose all but the primary selection. */
Lines 147-153 Link Here
147	void view_selections_normalize(View*);	147	void view_selections_normalize(View*);
148	/**	148	/**
149	* Replace currently active selections.	149	* Replace currently active selections.
150	* @param array The Array of ``Filerange``s.	150	* @param array The array of ``Filerange`` objects.
151	* @param anchored Whether all selection should be anchored.	151	* @param anchored Whether all selection should be anchored.
152	*/	152	*/
153	void view_selections_set_all(View, Array, bool anchored);	153	void view_selections_set_all(View, Array, bool anchored);
Lines 176-182 Link Here
176	/**	176	/**
177	* Get selection index.	177	* Get selection index.
178	* @rst	178	* @rst
179	* .. note:: Is always in range `[0, count-1]`.	179	* .. note:: Is always in range ``[0, count-1]``.
180	* .. warning: The relative order is determined during creation and assumed	180	* .. warning: The relative order is determined during creation and assumed
181	* to remain the same.	181	* to remain the same.
182	* @endrst	182	* @endrst
Lines 259-265 Link Here
259	/**	259	/**
260	* Get zero based index of screen cell on which selection cursor currently resides.	260	* Get zero based index of screen cell on which selection cursor currently resides.
261	* @rst	261	* @rst
262	* .. warning:: Returns `-1` if the selection cursor is currently not visible.	262	* .. warning:: Returns ``-1`` if the selection cursor is currently not visible.
263	* @endrst	263	* @endrst
264	*/	264	*/
265	int view_cursors_cell_get(Selection*);	265	int view_cursors_cell_get(Selection*);
Lines 324-330 Link Here
324	*/	324	*/
325	/**	325	/**
326	* Move primary selection cursor to the given position.	326	* Move primary selection cursor to the given position.
327	* Makes sure that position is visisble.	327	* Makes sure that position is visible.
328	* @rst	328	* @rst
329	* .. note:: If position was not visible before, we attempt to show	329	* .. note:: If position was not visible before, we attempt to show
330	* surrounding context. The viewport will be adjusted such	330	* surrounding context. The viewport will be adjusted such

Lines 14-20 Link Here

(-)vis-0.6/vis-core.h (-9 / +11 lines)
14		14
15	/* a mode contains a set of key bindings which are currently valid.	15	/* a mode contains a set of key bindings which are currently valid.
16	*	16	*
17	* each mode can specify one parent mode which is consultated if a given key	17	* each mode can specify one parent mode which is consulted if a given key
18	* is not found in the current mode. hence the modes form a tree which is	18	* is not found in the current mode. hence the modes form a tree which is
19	* searched from the current mode up towards the root mode until a valid binding	19	* searched from the current mode up towards the root mode until a valid binding
20	* is found.	20	* is found.
Lines 63-75 Link Here
63	};	63	};
64		64
65	typedef struct {	65	typedef struct {
66	/* operator logic, returns new cursor position, if EPOS is	66	/* operator logic, returns new cursor position, if EPOS
67	* the cursor is disposed (except if it is the primary one) */	67	* the cursor is disposed (except if it is the primary one) */
68	VisOperatorFunction *func;	68	VisOperatorFunction *func;
69	void *context;	69	void *context;
70	} Operator;	70	} Operator;
71		71
72	typedef struct { /* Motion implementation, takes a cursor postion and returns a new one */	72	typedef struct { /* Motion implementation, takes a cursor position and returns a new one */
73	/* TODO: merge types / use union to save space */	73	/* TODO: merge types / use union to save space */
74	size_t (cur)(Selection);	74	size_t (cur)(Selection);
75	size_t (txt)(Text, size_t pos);	75	size_t (txt)(Text, size_t pos);
Lines 154-160 Link Here
154	};	154	};
155		155
156	struct Win {	156	struct Win {
157	Vis vis; / editor instance to which this window belongs to */	157	Vis vis; / editor instance to which this window belongs */
158	UiWin ui; / ui object handling visual appearance of this window */	158	UiWin ui; / ui object handling visual appearance of this window */
159	File file; / file being displayed in this window */	159	File file; / file being displayed in this window */
160	View view; / currently displayed part of underlying text */	160	View view; / currently displayed part of underlying text */
Lines 167-173 Link Here
167	};	167	};
168		168
169	struct Vis {	169	struct Vis {
170	Ui ui; / user interface repsonsible for visual appearance */	170	Ui ui; / user interface responsible for visual appearance */
171	File files; / all files currently managed by this editor instance */	171	File files; / all files currently managed by this editor instance */
172	File command_file; / special internal file used to store :-command prompt */	172	File command_file; / special internal file used to store :-command prompt */
173	File search_file; / special internal file used to store /,? search prompt */	173	File search_file; / special internal file used to store /,? search prompt */
Lines 201-226 Link Here
201	Action action; /* current action which is in progress */	201	Action action; /* current action which is in progress */
202	Action action_prev; /* last operator action used by the repeat (dot) command */	202	Action action_prev; /* last operator action used by the repeat (dot) command */
203	Mode mode; / currently active mode, used to search for keybindings */	203	Mode mode; / currently active mode, used to search for keybindings */
204	Mode mode_prev; / previsouly active user mode */	204	Mode mode_prev; / previously active user mode */
205	bool initialized; /* whether UI and Lua integration has been initialized */	205	bool initialized; /* whether UI and Lua integration has been initialized */
206	int nesting_level; /* parsing state to hold keep track of { } nesting level */	206	int nesting_level; /* parsing state to hold keep track of { } nesting level */
207	volatile bool running; /* exit main loop once this becomes false */	207	volatile bool running; /* exit main loop once this becomes false */
208	int exit_status; /* exit status when terminating main loop */	208	int exit_status; /* exit status when terminating main loop */
209	volatile sig_atomic_t interrupted; /* abort command (SIGINT occured) */	209	volatile sig_atomic_t interrupted; /* abort command (SIGINT occured) */
210	volatile sig_atomic_t sigbus; /* one of the memory mapped region became unavailable (SIGBUS) */	210	volatile sig_atomic_t sigbus; /* one of the memory mapped regions became unavailable (SIGBUS) */
211	volatile sig_atomic_t need_resize; /* need to resize UI (SIGWINCH occured) */	211	volatile sig_atomic_t need_resize; /* need to resize UI (SIGWINCH occured) */
212	volatile sig_atomic_t resume; /* need to resume UI (SIGCONT occured) */	212	volatile sig_atomic_t resume; /* need to resume UI (SIGCONT occured) */
213	volatile sig_atomic_t terminate; /* need to terminate we were being killed by SIGTERM */	213	volatile sig_atomic_t terminate; /* need to terminate we were being killed by SIGTERM */
214	sigjmp_buf sigbus_jmpbuf; /* used to jump back to a known good state in the mainloop after (SIGBUS) */	214	sigjmp_buf sigbus_jmpbuf; /* used to jump back to a known good state in the mainloop after (SIGBUS) */
215	Map actions; / registered editor actions / special keys commands */	215	Map actions; / registered editor actions / special keys commands */
216	Array actions_user; /* dynamically allocated editor actions */	216	Array actions_user; /* dynamically allocated editor actions */
217	lua_State lua; / lua context used for syntax highligthing */	217	lua_State lua; / lua context used for syntax highlighting */
218	enum TextLoadMethod load_method; /* how existing files should be loaded */	218	enum TextLoadMethod load_method; /* how existing files should be loaded */
219	VisEvent *event;	219	VisEvent *event;
220	Array operators;	220	Array operators;
221	Array motions;	221	Array motions;
222	Array textobjects;	222	Array textobjects;
223	Array bindings;	223	Array bindings;
		224	bool ignorecase; /* whether to ignore case when searching */
224	};	225	};
225		226
226	enum VisEvents {	227	enum VisEvents {
Lines 235-240 Link Here
235	VIS_EVENT_WIN_CLOSE,	236	VIS_EVENT_WIN_CLOSE,
236	VIS_EVENT_WIN_HIGHLIGHT,	237	VIS_EVENT_WIN_HIGHLIGHT,
237	VIS_EVENT_WIN_STATUS,	238	VIS_EVENT_WIN_STATUS,
		239	VIS_EVENT_TERM_CSI,
238	};	240	};
239		241
240	bool vis_event_emit(Vis*, enum VisEvents, ...);	242	bool vis_event_emit(Vis*, enum VisEvents, ...);
Lines 246-252 Link Here
246		248
247	typedef MarkDef RegisterDef;	249	typedef MarkDef RegisterDef;
248		250
249	/** stuff used by multiple of the vis-* files */	251	/** stuff used by several of the vis-* files */
250		252
251	extern Mode vis_modes[VIS_MODE_INVALID];	253	extern Mode vis_modes[VIS_MODE_INVALID];
252	extern const Movement vis_motions[VIS_MOVE_INVALID];	254	extern const Movement vis_motions[VIS_MOVE_INVALID];

Lines 161-166 Link Here

(-)vis-0.6/vis-lua.c (-27 / +109 lines)
161	void vis_lua_win_close(Vis vis, Win win) { }	161	void vis_lua_win_close(Vis vis, Win win) { }
162	void vis_lua_win_highlight(Vis vis, Win win) { }	162	void vis_lua_win_highlight(Vis vis, Win win) { }
163	void vis_lua_win_status(Vis vis, Win win) { window_status_update(vis, win); }	163	void vis_lua_win_status(Vis vis, Win win) { window_status_update(vis, win); }
		164	void vis_lua_term_csi(Vis vis, const long csi) { }
164		165
165	#else	166	#else
166		167
Lines 330-336 Link Here
330	lua_getfield(L, LUA_REGISTRYINDEX, "vis.types");	331	lua_getfield(L, LUA_REGISTRYINDEX, "vis.types");
331	lua_getmetatable(L, -2);	332	lua_getmetatable(L, -2);
332	lua_gettable(L, -2);	333	lua_gettable(L, -2);
333	// XXX: in theory string might become invalid when poped from stack	334	// XXX: in theory string might become invalid when popped from stack
334	const char *type = lua_tostring(L, -1);	335	const char *type = lua_tostring(L, -1);
335	lua_pop(L, 2);	336	lua_pop(L, 2);
336	return type;	337	return type;
Lines 675-704 Link Here
675	* @usage	676	* @usage
676	* local marks = vis.win.marks	677	* local marks = vis.win.marks
677	* for name in vis:mark_names() do	678	* for name in vis:mark_names() do
678	* local mark = marks[name]	679	* local mark = marks[name]
679	* for i = 1, #mark do	680	* for i = 1, #mark do
680	* -- do somthing with: name, mark[i].start, mark[i].finish	681	* -- do somthing with: name, mark[i].start, mark[i].finish
681	* end	682	* end
682	* end	683	* end
683	*/	684	*/
684	static int mark_names_iter(lua_State *L);	685	static int mark_names_iter(lua_State *L);
685	static int mark_names(lua_State *L) {	686	static int mark_names(lua_State *L) {
		687	Vis *vis = obj_ref_check(L, 1, "vis");
		688	lua_pushlightuserdata(L, vis);
686	enum VisMark handle = lua_newuserdata(L, sizeof handle);	689	enum VisMark handle = lua_newuserdata(L, sizeof handle);
687	*handle = 0;	690	*handle = 0;
688	lua_pushcclosure(L, mark_names_iter, 1);	691	lua_pushcclosure(L, mark_names_iter, 2);
689	return 1;	692	return 1;
690	}	693	}
691		694
692	static int mark_names_iter(lua_State *L) {	695	static int mark_names_iter(lua_State *L) {
693	char mark = '\0';	696	Vis *vis = lua_touserdata(L, lua_upvalueindex(1));
694	enum VisMark *handle = lua_touserdata(L, lua_upvalueindex(1));	697	enum VisMark *handle = lua_touserdata(L, lua_upvalueindex(2));
695	if (*handle < LENGTH(vis_marks))	698	char mark = vis_mark_to(vis, *handle);
696	mark = vis_marks[*handle].name;
697	else if (VIS_MARK_a <= handle && handle <= VIS_MARK_z)
698	mark = 'a' + *handle - VIS_MARK_a;
699	if (mark) {	699	if (mark) {
700	char name[2] = { mark, '\0' };	700	lua_pushlstring(L, &mark, 1);
701	lua_pushstring(L, name);
702	(*handle)++;	701	(*handle)++;
703	return 1;	702	return 1;
704	}	703	}
Lines 719-740 Link Here
719	*/	718	*/
720	static int register_names_iter(lua_State *L);	719	static int register_names_iter(lua_State *L);
721	static int register_names(lua_State *L) {	720	static int register_names(lua_State *L) {
		721	Vis *vis = obj_ref_check(L, 1, "vis");
		722	lua_pushlightuserdata(L, vis);
722	enum VisRegister handle = lua_newuserdata(L, sizeof handle);	723	enum VisRegister handle = lua_newuserdata(L, sizeof handle);
723	*handle = 0;	724	*handle = 0;
724	lua_pushcclosure(L, register_names_iter, 1);	725	lua_pushcclosure(L, register_names_iter, 2);
725	return 1;	726	return 1;
726	}	727	}
727		728
728	static int register_names_iter(lua_State *L) {	729	static int register_names_iter(lua_State *L) {
729	char reg = '\0';	730	Vis *vis = lua_touserdata(L, lua_upvalueindex(1));
730	enum VisRegister *handle = lua_touserdata(L, lua_upvalueindex(1));	731	enum VisRegister *handle = lua_touserdata(L, lua_upvalueindex(2));
731	if (*handle < LENGTH(vis_registers))	732	char reg = vis_register_to(vis, *handle);
732	reg = vis_registers[*handle].name;
733	else if (VIS_REG_a <= handle && handle <= VIS_REG_z)
734	reg = 'a' + *handle - VIS_REG_a;
735	if (reg) {	733	if (reg) {
736	char name[2] = { reg, '\0' };	734	lua_pushlstring(L, &reg, 1);
737	lua_pushstring(L, name);
738	(*handle)++;	735	(*handle)++;
739	return 1;	736	return 1;
740	}	737	}
Lines 761-767 Link Here
761	* Display a short message.	758	* Display a short message.
762	*	759	*
763	* The single line message will be displayed at the bottom of	760	* The single line message will be displayed at the bottom of
764	* the scren and automatically hidden once a key is pressed.	761	* the screen and automatically hidden once a key is pressed.
765	*	762	*
766	* @function info	763	* @function info
767	* @tparam string message the message to display	764	* @tparam string message the message to display
Lines 1312-1318 Link Here
1312	* eventually hands over control to the editor core. The exit status	1309	* eventually hands over control to the editor core. The exit status
1313	* of the most recent call is used.	1310	* of the most recent call is used.
1314	*	1311	*
1315	* All unsaved chanes will be lost!	1312	* All unsaved changes will be lost!
1316	*	1313	*
1317	* @function exit	1314	* @function exit
1318	* @tparam int code the exit status returned to the operating system	1315	* @tparam int code the exit status returned to the operating system
Lines 1363-1369 Link Here
1363	*	1360	*
1364	* Will trigger redraw events, make sure to avoid recursive events.	1361	* Will trigger redraw events, make sure to avoid recursive events.
1365	*	1362	*
1366	* @function draw	1363	* @function redraw
1367	*/	1364	*/
1368	static int redraw(lua_State *L) {	1365	static int redraw(lua_State *L) {
1369	Vis *vis = obj_ref_check(L, 1, "vis");	1366	Vis *vis = obj_ref_check(L, 1, "vis");
Lines 1387-1392 Link Here
1387	* Currently unconsumed keys in the input queue.	1384	* Currently unconsumed keys in the input queue.
1388	* @tfield string input_queue	1385	* @tfield string input_queue
1389	*/	1386	*/
		1387	/***
		1388	* Register name in use.
		1389	* @tfield string register
		1390	*/
		1391	/***
		1392	* Mark name in use.
		1393	* @tfield string mark
		1394	*/
1390	static int vis_index(lua_State *L) {	1395	static int vis_index(lua_State *L) {
1391	Vis *vis = obj_ref_check(L, 1, "vis");	1396	Vis *vis = obj_ref_check(L, 1, "vis");
1392		1397
Lines 1424-1434 Link Here
1424	return 1;	1429	return 1;
1425	}	1430	}
1426		1431
		1432	if (strcmp(key, "register") == 0) {
		1433	char name = vis_register_to(vis, vis_register_used(vis));
		1434	lua_pushlstring(L, &name, 1);
		1435	return 1;
		1436	}
		1437
1427	if (strcmp(key, "registers") == 0) {	1438	if (strcmp(key, "registers") == 0) {
1428	obj_ref_new(L, vis->ui, VIS_LUA_TYPE_REGISTERS);	1439	obj_ref_new(L, vis->ui, VIS_LUA_TYPE_REGISTERS);
1429	return 1;	1440	return 1;
1430	}	1441	}
1431		1442
		1443	if (strcmp(key, "mark") == 0) {
		1444	char name = vis_mark_to(vis, vis_mark_used(vis));
		1445	lua_pushlstring(L, &name, 1);
		1446	return 1;
		1447	}
		1448
1432	if (strcmp(key, "ui") == 0) {	1449	if (strcmp(key, "ui") == 0) {
1433	obj_ref_new(L, vis->ui, VIS_LUA_TYPE_UI);	1450	obj_ref_new(L, vis->ui, VIS_LUA_TYPE_UI);
1434	return 1;	1451	return 1;
Lines 1462-1467 Link Here
1462	vis_window_focus(obj_ref_check(L, 3, VIS_LUA_TYPE_WINDOW));	1479	vis_window_focus(obj_ref_check(L, 3, VIS_LUA_TYPE_WINDOW));
1463	return 0;	1480	return 0;
1464	}	1481	}
		1482
		1483	if (strcmp(key, "register") == 0) {
		1484	const char *name = luaL_checkstring(L, 3);
		1485	if (strlen(name) == 1)
		1486	vis_register(vis, vis_register_from(vis, name[0]));
		1487	return 0;
		1488	}
		1489
		1490	if (strcmp(key, "mark") == 0) {
		1491	const char *name = luaL_checkstring(L, 3);
		1492	if (strlen(name) == 1)
		1493	vis_mark(vis, vis_mark_from(vis, name[0]));
		1494	return 0;
		1495	}
1465	}	1496	}
1466	return newindex_common(L);	1497	return newindex_common(L);
1467	}	1498	}
Lines 2066-2071 Link Here
2066	* File state.	2097	* File state.
2067	* @tfield bool modified whether the file contains unsaved changes	2098	* @tfield bool modified whether the file contains unsaved changes
2068	*/	2099	*/
		2100	/***
		2101	* File permission.
		2102	* @tfield int permission the file permission bits as of the most recent load/save
		2103	*/
2069	static int file_index(lua_State *L) {	2104	static int file_index(lua_State *L) {
2070	File *file = obj_ref_check(L, 1, VIS_LUA_TYPE_FILE);	2105	File *file = obj_ref_check(L, 1, VIS_LUA_TYPE_FILE);
2071		2106
Lines 2095-2105 Link Here
2095	lua_pushboolean(L, text_modified(file->text));	2130	lua_pushboolean(L, text_modified(file->text));
2096	return 1;	2131	return 1;
2097	}	2132	}
		2133
		2134	if (strcmp(key, "permission") == 0) {
		2135	struct stat stat = text_stat(file->text);
		2136	lua_pushunsigned(L, stat.st_mode & 0777);
		2137	return 1;
		2138	}
2098	}	2139	}
2099		2140
2100	return index_common(L);	2141	return index_common(L);
2101	}	2142	}
2102		2143
		2144	static int file_newindex(lua_State *L) {
		2145	File *file = obj_ref_check(L, 1, VIS_LUA_TYPE_FILE);
		2146
		2147	if (lua_isstring(L, 2)) {
		2148	const char *key = lua_tostring(L, 2);
		2149
		2150	if (strcmp(key, "modified") == 0) {
		2151	bool modified = lua_isboolean(L, 3) && lua_toboolean(L, 3);
		2152	if (modified) {
		2153	text_insert(file->text, 0, " ", 1);
		2154	text_delete(file->text, 0, 1);
		2155	} else {
		2156	text_save(file->text, NULL);
		2157	}
		2158	return 0;
		2159	}
		2160	}
		2161
		2162	return newindex_common(L);
		2163	}
		2164
2103	/***	2165	/***
2104	* Insert data at position.	2166	* Insert data at position.
2105	* @function insert	2167	* @function insert
Lines 2281-2287 Link Here
2281		2343
2282	static const struct luaL_Reg file_funcs[] = {	2344	static const struct luaL_Reg file_funcs[] = {
2283	{ "__index", file_index },	2345	{ "__index", file_index },
2284	{ "__newindex", newindex_common },	2346	{ "__newindex", file_newindex },
2285	{ "insert", file_insert },	2347	{ "insert", file_insert },
2286	{ "delete", file_delete },	2348	{ "delete", file_delete },
2287	{ "lines_iterator", file_lines_iterator },	2349	{ "lines_iterator", file_lines_iterator },
Lines 2860-2866 Link Here
2860	* Input key event in either input or replace mode.	2922	* Input key event in either input or replace mode.
2861	* @function input	2923	* @function input
2862	* @tparam string key	2924	* @tparam string key
2863	* @treturn bool whether the key was cosumed or not	2925	* @treturn bool whether the key was consumed or not
2864	*/	2926	*/
2865	static bool vis_lua_input(Vis vis, const char key, size_t len) {	2927	static bool vis_lua_input(Vis vis, const char key, size_t len) {
2866	lua_State *L = vis->lua;	2928	lua_State *L = vis->lua;
Lines 3050-3055 Link Here
3050	pcall(vis, L, 1, 0);	3112	pcall(vis, L, 1, 0);
3051	} else {	3113	} else {
3052	window_status_update(vis, win);	3114	window_status_update(vis, win);
		3115	}
		3116	lua_pop(L, 1);
		3117	}
		3118
		3119	/***
		3120	* CSI command received from terminal.
		3121	* @function term_csi
		3122	* @param List of CSI parameters
		3123	*/
		3124	void vis_lua_term_csi(Vis vis, const long csi) {
		3125	lua_State *L = vis->lua;
		3126	if (!L)
		3127	return;
		3128	vis_lua_event_get(L, "term_csi");
		3129	if (lua_isfunction(L, -1)) {
		3130	int nargs = csi[1];
		3131	lua_pushinteger(L, csi[0]);
		3132	for (int i = 0; i < nargs; i++)
		3133	lua_pushinteger(L, csi[2 + i]);
		3134	pcall(vis, L, 1 + nargs, 0);
3053	}	3135	}
3054	lua_pop(L, 1);	3136	lua_pop(L, 1);
3055	}	3137	}

Lines 226-231 Link Here

(-)vis-0.6/vis-marks.c (+10 lines)
226	return VIS_MARK_INVALID;	226	return VIS_MARK_INVALID;
227	}	227	}
228		228
		229	char vis_mark_to(Vis *vis, enum VisMark mark) {
		230	if (VIS_MARK_a <= mark && mark <= VIS_MARK_z)
		231	return 'a' + mark - VIS_MARK_a;
		232
		233	if (mark < LENGTH(vis_marks))
		234	return vis_marks[mark].name;
		235
		236	return '\0';
		237	}
		238
229	const MarkDef vis_marks[] = {	239	const MarkDef vis_marks[] = {
230	[VIS_MARK_DEFAULT] = { '\'', VIS_HELP("Default mark") },	240	[VIS_MARK_DEFAULT] = { '\'', VIS_HELP("Default mark") },
231	[VIS_MARK_SELECTION] = { '^', VIS_HELP("Last selections") },	241	[VIS_MARK_SELECTION] = { '^', VIS_HELP("Last selections") },

Lines 112-119 Link Here

(-)vis-0.6/vis-motions.c (-24 / +82 lines)
112	VIS_MOVE_LONGWORD_END_NEXT, isspace);	112	VIS_MOVE_LONGWORD_END_NEXT, isspace);
113	}	113	}
114		114
115	static size_t to(Vis vis, Text txt, size_t pos) {	115	static size_t to_right(Vis vis, Text txt, size_t pos) {
116	char c;	116	char c;
		117	size_t hit = text_find_next(txt, pos+1, vis->search_char);
		118	if (!text_byte_get(txt, hit, &c) \|\| c != vis->search_char[0])
		119	return pos;
		120	return hit;
		121	}
		122
		123	static size_t till_right(Vis vis, Text txt, size_t pos) {
		124	size_t hit = to_right(vis, txt, pos+1);
		125	if (hit != pos)
		126	return text_char_prev(txt, hit);
		127	return pos;
		128	}
		129
		130	static size_t to_left(Vis vis, Text txt, size_t pos) {
		131	return text_find_prev(txt, pos, vis->search_char);
		132	}
		133
		134	static size_t till_left(Vis vis, Text txt, size_t pos) {
		135	size_t hit = to_left(vis, txt, pos-1);
		136	if (hit != pos-1)
		137	return text_char_next(txt, hit);
		138	return pos;
		139	}
		140
		141	static size_t to_line_right(Vis vis, Text txt, size_t pos) {
		142	char c;
117	if (pos == text_line_end(txt, pos))	143	if (pos == text_line_end(txt, pos))
118	return pos;	144	return pos;
119	size_t hit = text_line_find_next(txt, pos+1, vis->search_char);	145	size_t hit = text_line_find_next(txt, pos+1, vis->search_char);
Lines 122-129 Link Here
122	return hit;	148	return hit;
123	}	149	}
124		150
125	static size_t till(Vis vis, Text txt, size_t pos) {	151	static size_t till_line_right(Vis vis, Text txt, size_t pos) {
126	size_t hit = to(vis, txt, pos+1);	152	size_t hit = to_line_right(vis, txt, pos+1);
127	if (pos == text_line_end(txt, pos))	153	if (pos == text_line_end(txt, pos))
128	return pos;	154	return pos;
129	if (hit != pos)	155	if (hit != pos)
Lines 131-144 Link Here
131	return pos;	157	return pos;
132	}	158	}
133		159
134	static size_t to_left(Vis vis, Text txt, size_t pos) {	160	static size_t to_line_left(Vis vis, Text txt, size_t pos) {
135	return text_line_find_prev(txt, pos, vis->search_char);	161	return text_line_find_prev(txt, pos, vis->search_char);
136	}	162	}
137		163
138	static size_t till_left(Vis vis, Text txt, size_t pos) {	164	static size_t till_line_left(Vis vis, Text txt, size_t pos) {
139	if (pos == text_line_begin(txt, pos))	165	if (pos == text_line_begin(txt, pos))
140	return pos;	166	return pos;
141	size_t hit = to_left(vis, txt, pos-1);	167	size_t hit = to_line_left(vis, txt, pos-1);
142	if (hit != pos-1)	168	if (hit != pos-1)
143	return text_char_next(txt, hit);	169	return text_char_next(txt, hit);
144	return pos;	170	return pos;
Lines 294-303 Link Here
294	}	320	}
295	break;	321	break;
296	}	322	}
297	case VIS_MOVE_RIGHT_TO:	323	case VIS_MOVE_TO_RIGHT:
298	case VIS_MOVE_LEFT_TO:	324	case VIS_MOVE_TO_LEFT:
299	case VIS_MOVE_RIGHT_TILL:	325	case VIS_MOVE_TO_LINE_RIGHT:
300	case VIS_MOVE_LEFT_TILL:	326	case VIS_MOVE_TO_LINE_LEFT:
		327	case VIS_MOVE_TILL_RIGHT:
		328	case VIS_MOVE_TILL_LEFT:
		329	case VIS_MOVE_TILL_LINE_RIGHT:
		330	case VIS_MOVE_TILL_LINE_LEFT:
301	{	331	{
302	const char key = va_arg(ap, char);	332	const char key = va_arg(ap, char);
303	if (!key)	333	if (!key)
Lines 314-331 Link Here
314	break;	344	break;
315	case VIS_MOVE_TOTILL_REVERSE:	345	case VIS_MOVE_TOTILL_REVERSE:
316	switch (vis->last_totill) {	346	switch (vis->last_totill) {
317	case VIS_MOVE_RIGHT_TO:	347	case VIS_MOVE_TO_RIGHT:
318	motion = VIS_MOVE_LEFT_TO;	348	motion = VIS_MOVE_TO_LEFT;
319	break;	349	break;
320	case VIS_MOVE_LEFT_TO:	350	case VIS_MOVE_TO_LEFT:
321	motion = VIS_MOVE_RIGHT_TO;	351	motion = VIS_MOVE_TO_RIGHT;
322	break;	352	break;
323	case VIS_MOVE_RIGHT_TILL:	353	case VIS_MOVE_TO_LINE_RIGHT:
324	motion = VIS_MOVE_LEFT_TILL;	354	motion = VIS_MOVE_TO_LINE_LEFT;
325	break;	355	break;
326	case VIS_MOVE_LEFT_TILL:	356	case VIS_MOVE_TO_LINE_LEFT:
327	motion = VIS_MOVE_RIGHT_TILL;	357	motion = VIS_MOVE_TO_LINE_RIGHT;
328	break;	358	break;
		359	case VIS_MOVE_TILL_RIGHT:
		360	motion = VIS_MOVE_TILL_LEFT;
		361	break;
		362	case VIS_MOVE_TILL_LEFT:
		363	motion = VIS_MOVE_TILL_RIGHT;
		364	break;
		365	case VIS_MOVE_TILL_LINE_RIGHT:
		366	motion = VIS_MOVE_TILL_LINE_LEFT;
		367	break;
		368	case VIS_MOVE_TILL_LINE_LEFT:
		369	motion = VIS_MOVE_TILL_LINE_RIGHT;
		370	break;
329	default:	371	default:
330	goto err;	372	goto err;
331	}	373	}
Lines 515-534 Link Here
515	.txt = lastline,	557	.txt = lastline,
516	.type = LINEWISE\|LINEWISE_INCLUSIVE\|JUMP\|IDEMPOTENT,	558	.type = LINEWISE\|LINEWISE_INCLUSIVE\|JUMP\|IDEMPOTENT,
517	},	559	},
518	[VIS_MOVE_LEFT_TO] = {	560	[VIS_MOVE_TO_LEFT] = {
519	.vis = to_left,	561	.vis = to_left,
520	.type = COUNT_EXACT,	562	.type = COUNT_EXACT,
521	},	563	},
522	[VIS_MOVE_RIGHT_TO] = {	564	[VIS_MOVE_TO_RIGHT] = {
523	.vis = to,	565	.vis = to_right,
524	.type = INCLUSIVE\|COUNT_EXACT,	566	.type = INCLUSIVE\|COUNT_EXACT,
525	},	567	},
526	[VIS_MOVE_LEFT_TILL] = {	568	[VIS_MOVE_TO_LINE_LEFT] = {
		569	.vis = to_line_left,
		570	.type = COUNT_EXACT,
		571	},
		572	[VIS_MOVE_TO_LINE_RIGHT] = {
		573	.vis = to_line_right,
		574	.type = INCLUSIVE\|COUNT_EXACT,
		575	},
		576	[VIS_MOVE_TILL_LEFT] = {
527	.vis = till_left,	577	.vis = till_left,
528	.type = COUNT_EXACT,	578	.type = COUNT_EXACT,
529	},	579	},
530	[VIS_MOVE_RIGHT_TILL] = {	580	[VIS_MOVE_TILL_RIGHT] = {
531	.vis = till,	581	.vis = till_right,
		582	.type = INCLUSIVE\|COUNT_EXACT,
		583	},
		584	[VIS_MOVE_TILL_LINE_LEFT] = {
		585	.vis = till_line_left,
		586	.type = COUNT_EXACT,
		587	},
		588	[VIS_MOVE_TILL_LINE_RIGHT] = {
		589	.vis = till_line_right,
532	.type = INCLUSIVE\|COUNT_EXACT,	590	.type = INCLUSIVE\|COUNT_EXACT,
533	},	591	},
534	[VIS_MOVE_SEARCH_WORD_FORWARD] = {	592	[VIS_MOVE_SEARCH_WORD_FORWARD] = {

Lines 8-13 Link Here

(-)vis-0.6/vis-open (-1 / +10 lines)
8	VIS_MENU_PROMPT=""	8	VIS_MENU_PROMPT=""
9	ALLOW_AUTO_SELECT=1	9	ALLOW_AUTO_SELECT=1
10		10
		11	wrap_dirs() {
		12	local o
		13
		14	while read o
		15	do
		16	[ -d "$o" ] && printf "%s/\n" "$o" \|\| printf "%s\n" "$o"
		17	done
		18	}
		19
11	while [ $# -gt 0 ]; do	20	while [ $# -gt 0 ]; do
12	case "$1" in	21	case "$1" in
13	-h\|--help)	22	-h\|--help)
Lines 63-69 Link Here
63		72
64	# At this point, we have a bunch of options we need to present to the	73	# At this point, we have a bunch of options we need to present to the
65	# user so they can pick one.	74	# user so they can pick one.
66	CHOICE=$(printf "%s\n" "$@" \| vis-menu -b -p "$VIS_MENU_PROMPT")	75	CHOICE=$(printf "%s\n" "$@" \| wrap_dirs \| vis-menu -b -p "$VIS_MENU_PROMPT")
67		76
68	# Did they pick a file or directory? Who knows, let's let the next iteration figure it out.	77	# Did they pick a file or directory? Who knows, let's let the next iteration figure it out.
69	exec "$0" -p "$VIS_MENU_PROMPT" -- "$CHOICE"	78	exec "$0" -p "$VIS_MENU_PROMPT" -- "$CHOICE"

Lines 173-184 Link Here

(-)vis-0.6/vis-text-objects.c (-6 lines)
173	.txt = object_backtick,	173	.txt = object_backtick,
174	.type = TEXTOBJECT_DELIMITED_INNER,	174	.type = TEXTOBJECT_DELIMITED_INNER,
175	},	175	},
176	[VIS_TEXTOBJECT_OUTER_ENTIRE] = {
177	.txt = text_object_entire,
178	},
179	[VIS_TEXTOBJECT_INNER_ENTIRE] = {
180	.txt = text_object_entire_inner,
181	},
182	[VIS_TEXTOBJECT_OUTER_LINE] = {	176	[VIS_TEXTOBJECT_OUTER_LINE] = {
183	.txt = text_object_line,	177	.txt = text_object_line,
184	},	178	},

Lines 57-62 Link Here

(-)vis-0.6/vis.h (-17 / +23 lines)
57	void (win_close)(Vis, Win*);	57	void (win_close)(Vis, Win*);
58	void (win_highlight)(Vis, Win*);	58	void (win_highlight)(Vis, Win*);
59	void (win_status)(Vis, Win*);	59	void (win_status)(Vis, Win*);
		60	void (term_csi)(Vis, const long *);
60	} VisEvent;	61	} VisEvent;
61		62
62	/** Union used to pass arguments to key action functions. */	63	/** Union used to pass arguments to key action functions. */
Lines 76-82 Link Here
76	* @rst	77	* @rst
77	* .. note:: An empty string ``""`` indicates that no further input is available.	78	* .. note:: An empty string ``""`` indicates that no further input is available.
78	* @endrst	79	* @endrst
79	* @return Pointer to first non-cosumed key.	80	* @return Pointer to first non-consumed key.
80	* @rst	81	* @rst
81	* .. warning:: Must be in range ``[keys, keys+strlen(keys)]`` or ``NULL`` to	82	* .. warning:: Must be in range ``[keys, keys+strlen(keys)]`` or ``NULL`` to
82	* indicate that not enough input was available. In the latter case	83	* indicate that not enough input was available. In the latter case
Lines 130-136 Link Here
130	void vis_die(Vis, const char msg, ...) __attribute__((noreturn,format(printf, 2, 3)));	131	void vis_die(Vis, const char msg, ...) __attribute__((noreturn,format(printf, 2, 3)));
131		132
132	/**	133	/**
133	* Temporarily supsend the editor process.	134	* Temporarily suspend the editor process.
134	* @rst	135	* @rst
135	* .. note:: This function will generate a ``SIGTSTP`` signal.	136	* .. note:: This function will generate a ``SIGTSTP`` signal.
136	* @endrst	137	* @endrst
Lines 221-229 Link Here
221	void vis_window_focus(Win*);	222	void vis_window_focus(Win*);
222	/** Swap location of two windows. */	223	/** Swap location of two windows. */
223	void vis_window_swap(Win, Win);	224	void vis_window_swap(Win, Win);
224	/** Query window dimension. */	225	/** Query window width. */
225	int vis_window_width_get(const Win*);	226	int vis_window_width_get(const Win*);
226	/** Query window dimension. */	227	/** Query window height. */
227	int vis_window_height_get(const Win*);	228	int vis_window_height_get(const Win*);
228	/**	229	/**
229	* @}	230	* @}
Lines 263-269 Link Here
263	/** Perform insertion at all cursor positions. */	264	/** Perform insertion at all cursor positions. */
264	void vis_insert_key(Vis, const char data, size_t len);	265	void vis_insert_key(Vis, const char data, size_t len);
265	/**	266	/**
266	* Perform character subsitution at all cursor positions.	267	* Perform character substitution at all cursor positions.
267	* @rst	268	* @rst
268	* .. note:: Does not replace new line characters.	269	* .. note:: Does not replace new line characters.
269	* @endrst	270	* @endrst
Lines 432-438 Link Here
432	*	433	*
433	* - `VIS_OP_JOIN` a char pointer referring to the text to insert between lines.	434	* - `VIS_OP_JOIN` a char pointer referring to the text to insert between lines.
434	* - `VIS_OP_MODESWITCH` an ``enum VisMode`` indicating the mode to switch to.	435	* - `VIS_OP_MODESWITCH` an ``enum VisMode`` indicating the mode to switch to.
435	* - `VIS_OP_REPLACE` a char pointer reffering to the replacement character.	436	* - `VIS_OP_REPLACE` a char pointer referring to the replacement character.
436	*/	437	*/
437	bool vis_operator(Vis*, enum VisOperator, ...);	438	bool vis_operator(Vis*, enum VisOperator, ...);
438		439
Lines 490-499 Link Here
490	VIS_MOVE_PARENTHESIS_START,	491	VIS_MOVE_PARENTHESIS_START,
491	VIS_MOVE_PARENTHESIS_END,	492	VIS_MOVE_PARENTHESIS_END,
492	VIS_MOVE_BRACKET_MATCH,	493	VIS_MOVE_BRACKET_MATCH,
493	VIS_MOVE_LEFT_TO,	494	VIS_MOVE_TO_LEFT,
494	VIS_MOVE_RIGHT_TO,	495	VIS_MOVE_TO_RIGHT,
495	VIS_MOVE_LEFT_TILL,	496	VIS_MOVE_TO_LINE_LEFT,
496	VIS_MOVE_RIGHT_TILL,	497	VIS_MOVE_TO_LINE_RIGHT,
		498	VIS_MOVE_TILL_LEFT,
		499	VIS_MOVE_TILL_RIGHT,
		500	VIS_MOVE_TILL_LINE_LEFT,
		501	VIS_MOVE_TILL_LINE_RIGHT,
497	VIS_MOVE_FILE_BEGIN,	502	VIS_MOVE_FILE_BEGIN,
498	VIS_MOVE_FILE_END,	503	VIS_MOVE_FILE_END,
499	VIS_MOVE_SEARCH_WORD_FORWARD,	504	VIS_MOVE_SEARCH_WORD_FORWARD,
Lines 622-629 Link Here
622	VIS_TEXTOBJECT_INNER_SINGLE_QUOTE,	627	VIS_TEXTOBJECT_INNER_SINGLE_QUOTE,
623	VIS_TEXTOBJECT_OUTER_BACKTICK,	628	VIS_TEXTOBJECT_OUTER_BACKTICK,
624	VIS_TEXTOBJECT_INNER_BACKTICK,	629	VIS_TEXTOBJECT_INNER_BACKTICK,
625	VIS_TEXTOBJECT_OUTER_ENTIRE,
626	VIS_TEXTOBJECT_INNER_ENTIRE,
627	VIS_TEXTOBJECT_OUTER_LINE,	630	VIS_TEXTOBJECT_OUTER_LINE,
628	VIS_TEXTOBJECT_INNER_LINE,	631	VIS_TEXTOBJECT_INNER_LINE,
629	VIS_TEXTOBJECT_INDENTATION,	632	VIS_TEXTOBJECT_INDENTATION,
Lines 675-682 Link Here
675	* @defgroup vis_marks	678	* @defgroup vis_marks
676	* @{	679	* @{
677	*/	680	*/
678	/** Translate single character mark name to corresponding constant. */	681	/** Translate between single character mark name and corresponding constant. */
679	enum VisMark vis_mark_from(Vis*, char mark);	682	enum VisMark vis_mark_from(Vis*, char mark);
		683	char vis_mark_to(Vis*, enum VisMark);
680	/**	684	/**
681	* Specify mark to use.	685	* Specify mark to use.
682	* @rst	686	* @rst
Lines 731-736 Link Here
731	VIS_REG_9,	735	VIS_REG_9,
732	VIS_REG_BLACKHOLE, /* /dev/null register */	736	VIS_REG_BLACKHOLE, /* /dev/null register */
733	VIS_REG_CLIPBOARD, /* system clipboard register */	737	VIS_REG_CLIPBOARD, /* system clipboard register */
		738	VIS_REG_PRIMARY, /* system primary clipboard register */
734	VIS_REG_DOT, /* last inserted text, copy of VIS_MACRO_OPERATOR */	739	VIS_REG_DOT, /* last inserted text, copy of VIS_MACRO_OPERATOR */
735	VIS_REG_SEARCH, /* last used search pattern "/ */	740	VIS_REG_SEARCH, /* last used search pattern "/ */
736	VIS_REG_COMMAND, /* last used :-command ": */	741	VIS_REG_COMMAND, /* last used :-command ": */
Lines 758-765 Link Here
758	* @defgroup vis_registers	763	* @defgroup vis_registers
759	* @{	764	* @{
760	*/	765	*/
761	/** Translate single character register name to corresponding constant. */	766	/** Translate between single character register name and corresponding constant. */
762	enum VisRegister vis_register_from(Vis*, char reg);	767	enum VisRegister vis_register_from(Vis*, char reg);
		768	char vis_register_to(Vis*, enum VisRegister);
763	/**	769	/**
764	* Specify register to use.	770	* Specify register to use.
765	* @rst	771	* @rst
Lines 772-778 Link Here
772	* Get register content.	778	* Get register content.
773	* @return An array of ``TextString`` structs.	779	* @return An array of ``TextString`` structs.
774	* @rst	780	* @rst
775	* .. warning:: The caller must eventually free the array ressources using	781	* .. warning:: The caller must eventually free the array resources using
776	* ``array_release``.	782	* ``array_release``.
777	* @endrst	783	* @endrst
778	*/	784	*/
Lines 851-857 Link Here
851	* Option handler function.	857	* Option handler function.
852	* @param win The window to which option should apply, might be ``NULL``.	858	* @param win The window to which option should apply, might be ``NULL``.
853	* @param context User provided context pointer as given to `vis_option_register`.	859	* @param context User provided context pointer as given to `vis_option_register`.
854	* @param force Whether the option was specfied with a bang ``!``.	860	* @param force Whether the option was specified with a bang ``!``.
855	* @param name Name of option which was set.	861	* @param name Name of option which was set.
856	* @param arg The new option value.	862	* @param arg The new option value.
857	*/	863	*/
Lines 962-968 Link Here
962	Regex vis_regex(Vis, const char *pattern);	968	Regex vis_regex(Vis, const char *pattern);
963		969
964	/**	970	/**
965	* Take an undo snaphost to which we can later revert to.	971	* Take an undo snapshot to which we can later revert.
966	* @rst	972	* @rst
967	* .. note:: Does nothing when invoked while replaying a macro.	973	* .. note:: Does nothing when invoked while replaying a macro.
968	* @endrst	974	* @endrst