#include <assert.h>
#include <inttypes.h>
#include <limits.h>
#include <string.h>
#include "nvim/ascii.h"
#include "nvim/buffer.h"
#include "nvim/charset.h"
#include "nvim/diff.h"
#include "nvim/eval.h"
#include "nvim/ex_cmds.h"
#include "nvim/extmark.h"
#include "nvim/fileio.h"
#include "nvim/fold.h"
#include "nvim/mark.h"
#include "nvim/mbyte.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/normal.h"
#include "nvim/option.h"
#include "nvim/os/input.h"
#include "nvim/os/os.h"
#include "nvim/os/time.h"
#include "nvim/path.h"
#include "nvim/quickfix.h"
#include "nvim/search.h"
#include "nvim/sign.h"
#include "nvim/strings.h"
#include "nvim/ui.h"
#include "nvim/vim.h"

Macros
#define	one_adjust(add)

#define	one_adjust_nodel(add)

#define	col_adjust(pp)

Functions
int	setmark (int c)

void	free_fmark (fmark_T fm)
	Free fmark_T item. More...

void	free_xfmark (xfmark_T fm)
	Free xfmark_T item. More...

void	clear_fmark (fmark_T *fm) FUNC_ATTR_NONNULL_ALL
	Free and clear fmark_T item. More...

int	setmark_pos (int c, pos_T *pos, int fnum)

void	setpcmark (void)

void	checkpcmark (void)

pos_T *	movemark (int count)

pos_T *	movechangelist (int count)

pos_T *	getmark_buf (buf_T *buf, int c, bool changefile)

pos_T *	getmark (int c, bool changefile)

pos_T *	getmark_buf_fnum (buf_T buf, int c, bool changefile, int fnum)

pos_T *	getnextmark (pos_T *startpos, int dir, int begin_line)

void	fmarks_check_names (buf_T *buf)

int	check_mark (pos_T *pos)

void	clrallmarks (buf_T *const buf) FUNC_ATTR_NONNULL_ALL

char_u *	fm_getname (fmark_T *fmark, int lead_len)

void	ex_marks (exarg_T *eap)

void	ex_delmarks (exarg_T *eap)

void	ex_jumps (exarg_T *eap)

void	ex_clearjumps (exarg_T *eap)

void	ex_changes (exarg_T *eap)

void	mark_adjust (linenr_T line1, linenr_T line2, long amount, long amount_after, ExtmarkOp op)

void	mark_adjust_nofold (linenr_T line1, linenr_T line2, long amount, long amount_after, ExtmarkOp op)

void	mark_col_adjust (linenr_T lnum, colnr_T mincol, long lnum_amount, long col_amount, int spaces_removed)

void	cleanup_jumplist (win_T *wp, bool checktail)

void	copy_jumplist (win_T from, win_T to)

const void *	mark_jumplist_iter (const void const iter, const win_T const win, xfmark_T *const fm) FUNC_ATTR_NONNULL_ARG(2

	if (iter_mark==&(win->w_jumplist[win->w_jumplistlen - 1]))

const void *	mark_global_iter (const void const iter, char const name, xfmark_T *const fm) FUNC_ATTR_NONNULL_ARG(2

	while ((size_t)(iter_mark - &(namedfm[0]))< ARRAY_SIZE(namedfm) &&!iter_mark->fmark.mark.lnum)

	if ((size_t)(iter_mark - &(namedfm[0]))==ARRAY_SIZE(namedfm)\|\|!iter_mark->fmark.mark.lnum)

	while ((size_t)(++iter_mark - &(namedfm[0]))< ARRAY_SIZE(namedfm))

const void *	mark_buffer_iter (const void const iter, const buf_T const buf, char const name, fmark_T const fm) FUNC_ATTR_NONNULL_ARG(2

	while (iter_mark !=NULL &&iter_mark->mark.lnum==0)

	if (mark_name)

	return (const void *)

bool	mark_set_local (const char name, buf_T *const buf, const fmark_T fm, const bool update) FUNC_ATTR_NONNULL_ALL

void	free_jumplist (win_T *wp)

void	set_last_cursor (win_T *win)

void	mark_mb_adjustpos (buf_T buf, pos_T lp) FUNC_ATTR_NONNULL_ALL

static int	tv_list_append_dict (l, d)

	tv_list_append_number (lpos, bufnr)

	tv_list_append_number (lpos, pos->lnum)

	tv_list_append_number (lpos, pos->col+1)

	if (tv_dict_add_str(d, S_LEN("mark"), mname)==FAIL\|\|tv_dict_add_list(d, S_LEN("pos"), lpos)==FAIL\|\|(fname !=NULL &&tv_dict_add_str(d, S_LEN("file"), fname)==FAIL))

void	get_buf_local_marks (const buf_T buf, list_T l) FUNC_ATTR_NONNULL_ALL

xfmark_T	get_global_mark (char name)

void	get_global_marks (list_T *l) FUNC_ATTR_NONNULL_ALL

Variables
const void	FUNC_ATTR_WARN_UNUSED_RESULT

*	fm = *iter_mark

	else

const xfmark_T *	iter_mark

size_t	iter_off = (size_t)(iter_mark - &(namedfm[0]))

*	name

return	NULL

char	mark_name

list_T *	lpos = tv_list_alloc(kListLenMayKnow)

return	OK

Macro Definition Documentation

◆ col_adjust

#define col_adjust ( pp )

Value:

  { \
    posp = pp; \
    if (posp->lnum == lnum && posp->col >= mincol) \
    { \
      posp->lnum += lnum_amount; \
      assert(col_amount > INT_MIN && col_amount <= INT_MAX); \
      if (col_amount < 0 && posp->col <= (colnr_T)-col_amount) { \
        posp->col = 0; \
      } else if (posp->col < spaces_removed) { \
        posp->col = (int)col_amount + spaces_removed; \
      } else { \
        posp->col += (colnr_T)col_amount; \
      } \
    } \
  }

◆ one_adjust

#define one_adjust ( add )

Value:

  { \
    lp = add; \
    if (*lp >= line1 && *lp <= line2) \
    { \
      if (amount == MAXLNUM) \
      *lp = 0; \
      else \
      *lp += amount; \
    } \
    else if (amount_after && *lp > line2) \
    *lp += amount_after; \
  }

◆ one_adjust_nodel

#define one_adjust_nodel ( add )

Value:

  { \
    lp = add; \
    if (*lp >= line1 && *lp <= line2) \
    { \
      if (amount == MAXLNUM) \
      *lp = line1; \
      else \
      *lp += amount; \
    } \
    else if (amount_after && *lp > line2) \
    *lp += amount_after; \
  }

Function Documentation

◆ check_mark()

int check_mark ( pos_T * pos )

◆ checkpcmark()

void checkpcmark ( void )

◆ cleanup_jumplist()

void cleanup_jumplist	(	win_T *	wp,
		bool	checktail
	)

◆ clear_fmark()

void clear_fmark ( fmark_T * fm )

Free and clear fmark_T item.

◆ clrallmarks()

void clrallmarks ( buf_T *const buf )

Clear all marks and change list in the given buffer

Used mainly when trashing the entire buffer during ":e" type commands.

Parameters

[out] buf Buffer to clear marks in.

◆ copy_jumplist()

void copy_jumplist	(	win_T *	from,
		win_T *	to
	)

◆ ex_changes()

void ex_changes ( exarg_T * eap )

◆ ex_clearjumps()

void ex_clearjumps ( exarg_T * eap )

◆ ex_delmarks()

void ex_delmarks ( exarg_T * eap )

◆ ex_jumps()

void ex_jumps ( exarg_T * eap )

◆ ex_marks()

void ex_marks ( exarg_T * eap )

◆ fm_getname()

char_u* fm_getname	(	fmark_T *	fmark,
		int	lead_len
	)

◆ fmarks_check_names()

void fmarks_check_names ( buf_T * buf )

◆ free_fmark()

void free_fmark ( fmark_T fm )

Free fmark_T item.

◆ free_jumplist()

void free_jumplist ( win_T * wp )

◆ free_xfmark()

void free_xfmark ( xfmark_T fm )

Free xfmark_T item.

◆ get_buf_local_marks()

void get_buf_local_marks	(	const buf_T *	buf,
		list_T *	l
	)

Get information about marks local to a buffer.

Parameters

[in]	buf	Buffer to get the marks from
[out]	l	List to store marks

◆ get_global_mark()

xfmark_T get_global_mark ( char name )

Get a global mark

Parameters

[in]	Name	of named mark
[out]	Global/file	mark

◆ get_global_marks()

void get_global_marks ( list_T * l )

Get information about global marks ('A' to 'Z' and '0' to '9')

Parameters

[out] l List to store global marks

◆ getmark()

pos_T* getmark	(	int	c,
		bool	changefile
	)

◆ getmark_buf()

pos_T* getmark_buf	(	buf_T *	buf,
		int	c,
		bool	changefile
	)

◆ getmark_buf_fnum()

pos_T* getmark_buf_fnum	(	buf_T *	buf,
		int	c,
		bool	changefile,
		int *	fnum
	)

◆ getnextmark()

pos_T* getnextmark	(	pos_T *	startpos,
		int	dir,
		int	begin_line
	)

Search for the next named mark in the current file.

Parameters

startpos	where to start
dir	direction for search

Returns: pointer to pos_T of the next mark or NULL if no mark is found.

◆ if() [1/4]

if ( (size_t)(iter_mark - &(namedfm[0])) = = ARRAY_SIZE(namedfm) || !iter_mark->fmark.mark.lnum )

◆ if() [2/4]

if ( iter_mark = = &(win->w_jumplist[win->w_jumplistlen - 1]) )

◆ if() [3/4]

if ( mark_name )

◆ if() [4/4]

if ( tv_dict_add_str(d, S_LEN("mark"), mname) = = FAIL || tv_dict_add_list(d, S_LEN("pos"), lpos) == FAIL || (fname != NULL && tv_dict_add_str(d, S_LEN("file"), fname) == FAIL) )

◆ mark_adjust()

void mark_adjust	(	linenr_T	line1,
		linenr_T	line2,
		long	amount,
		long	amount_after,
		ExtmarkOp	op
	)

◆ mark_adjust_nofold()

void mark_adjust_nofold	(	linenr_T	line1,
		linenr_T	line2,
		long	amount,
		long	amount_after,
		ExtmarkOp	op
	)

◆ mark_buffer_iter()

const void* mark_buffer_iter	(	const void *const	iter,
		const buf_T *const	buf,
		char *const	name,
		fmark_T *const	fm
	)

Iterate over buffer marks

Warning: No mark-editing functions must be run while iteration is in progress.

Parameters

[in]	iter	Iterator. Pass NULL to start iteration.
[in]	buf	Buffer.
[out]	name	Mark name.
[out]	fm	Mark definition.

Returns: Pointer that needs to be passed to next mark_buffer_iter call or NULL if iteration is over.

◆ mark_col_adjust()

void mark_col_adjust	(	linenr_T	lnum,
		colnr_T	mincol,
		long	lnum_amount,
		long	col_amount,
		int	spaces_removed
	)

◆ mark_global_iter()

const void* mark_global_iter	(	const void *const	iter,
		char *const	name,
		xfmark_T *const	fm
	)

Iterate over global marks

Warning: No mark-editing functions must be run while iteration is in progress.

Parameters

[in]	iter	Iterator. Pass NULL to start iteration.
[out]	name	Mark name.
[out]	fm	Mark definition.

Returns: Pointer that needs to be passed to next mark_global_iter call or NULL if iteration is over.

◆ mark_jumplist_iter()

const void* mark_jumplist_iter	(	const void *const	iter,
		const win_T *const	win,
		xfmark_T *const	fm
	)

Iterate over jumplist items

Warning: No jumplist-editing functions must be run while iteration is in progress.

Parameters

[in]	iter	Iterator. Pass NULL to start iteration.
[in]	win	Window for which jump list is processed.
[out]	fm	Item definition.

Returns: Pointer that needs to be passed to next mark_jumplist_iter call or NULL if iteration is over.

◆ mark_mb_adjustpos()

void mark_mb_adjustpos	(	buf_T *	buf,
		pos_T *	lp
	)

Adjust position to point to the first byte of a multi-byte character

If it points to a tail byte it is move backwards to the head byte.

Parameters

[in]	buf	Buffer to adjust position in.
[out]	lp	Position to adjust.

◆ mark_set_local()

bool mark_set_local	(	const char	name,
		buf_T *const	buf,
		const fmark_T	fm,
		const bool	update
	)

Set local mark

Parameters

[in]	name	Mark name.
[in]	buf	Pointer to the buffer to set mark in.
[in]	fm	Mark to be set.
[in]	update	If true then only set global mark if it was created later then existing one.

Returns: true on success, false on failure.

◆ movechangelist()

pos_T* movechangelist ( int count )

◆ movemark()

pos_T* movemark ( int count )

◆ return()

return ( const void * )

◆ set_last_cursor()

void set_last_cursor ( win_T * win )

◆ setmark()

int setmark ( int c )

◆ setmark_pos()

int setmark_pos	(	int	c,
		pos_T *	pos,
		int	fnum
	)

◆ setpcmark()

void setpcmark ( void )

◆ tv_list_append_dict()

static int tv_list_append_dict	(	l	,
		d
	)

◆ tv_list_append_number() [1/3]

tv_list_append_number	(	lpos	,
		bufnr
	)

◆ tv_list_append_number() [2/3]

tv_list_append_number	(	lpos	,
		pos->col+	1
	)

◆ tv_list_append_number() [3/3]

tv_list_append_number	(	lpos	,
		pos->	lnum
	)

◆ while() [1/3]

while ( )

◆ while() [2/3]

while ( (size_t)(iter_mark - &(namedfm[0]))< ARRAY_SIZE(namedfm) &&!iter_mark->fmark.mark. lnum )

◆ while() [3/3]

while ( iter_mark ! = NULL && iter_mark->mark.lnum == 0 )

Variable Documentation

◆ else

else

Initial value:

{

return iter_mark + 1

◆ fm

* fm = *iter_mark

◆ FUNC_ATTR_WARN_UNUSED_RESULT

const void FUNC_ATTR_WARN_UNUSED_RESULT

Initial value:

{
  if (iter == NULL && win->w_jumplistlen == 0) {
    *fm = (xfmark_T) { { { 0, 0, 0 }, 0, 0, NULL }, NULL };
    return NULL;
  }
  const xfmark_T *const iter_mark =
    (iter == NULL
       ? &(win->w_jumplist[0])
       : (const xfmark_T *const)iter)

◆ iter_mark

const fmark_T * iter_mark

Initial value:

= (iter == NULL
                               ? &(namedfm[0])
                               : (const xfmark_T *const)iter)

◆ iter_off

size_t iter_off = (size_t)(iter_mark - &(namedfm[0]))

◆ lpos

list_T* lpos = tv_list_alloc(kListLenMayKnow)

◆ mark_name

char mark_name

Initial value:

= (char)(iter == NULL
                           ? NUL
                           : (iter == &(buf->b_last_cursor)
                              ? '"'
                              : (iter == &(buf->b_last_insert)
                                 ? '^'
                                 : (iter == &(buf->b_last_change)
                                    ? '.'
                                    : 'a' + (char)((const fmark_T *)iter
                                                   - &(buf->b_namedm[0]))))))

◆ name

* name

Initial value:

= (char)(iter_off < NMARKS
                  ? 'A' + (char)iter_off
                  : '0' + (char)(iter_off - NMARKS))

◆ NULL

return NULL

◆ OK

return OK

Macros

Functions

Variables

Macro Definition Documentation

◆ col_adjust

◆ one_adjust

◆ one_adjust_nodel

Function Documentation

◆ check_mark()

◆ checkpcmark()

◆ cleanup_jumplist()

◆ clear_fmark()

◆ clrallmarks()

◆ copy_jumplist()

◆ ex_changes()

◆ ex_clearjumps()

◆ ex_delmarks()

◆ ex_jumps()

◆ ex_marks()

◆ fm_getname()

◆ fmarks_check_names()

◆ free_fmark()

◆ free_jumplist()

◆ free_xfmark()

◆ get_buf_local_marks()

◆ get_global_mark()

◆ get_global_marks()

◆ getmark()

◆ getmark_buf()

◆ getmark_buf_fnum()

◆ getnextmark()

◆ if() [1/4]

◆ if() [2/4]

◆ if() [3/4]

◆ if() [4/4]

◆ mark_adjust()

◆ mark_adjust_nofold()

◆ mark_buffer_iter()

◆ mark_col_adjust()

◆ mark_global_iter()

◆ mark_jumplist_iter()

◆ mark_mb_adjustpos()

◆ mark_set_local()

◆ movechangelist()

◆ movemark()

◆ return()

◆ set_last_cursor()

◆ setmark()

◆ setmark_pos()

◆ setpcmark()

◆ tv_list_append_dict()

◆ tv_list_append_number() [1/3]

◆ tv_list_append_number() [2/3]

◆ tv_list_append_number() [3/3]

◆ while() [1/3]

◆ while() [2/3]

◆ while() [3/3]

Variable Documentation

◆ else

◆ fm

◆ FUNC_ATTR_WARN_UNUSED_RESULT

◆ iter_mark

◆ iter_off

◆ lpos

◆ mark_name

◆ name

◆ NULL

◆ OK