------------
Less
-Copyright (C) 1984-2016 Mark Nudelman
+Copyright (C) 1984-2018 Mark Nudelman
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
wide.uni: unicode/EastAsianWidth.txt
./mkutable -f1 W F -- unicode/EastAsianWidth.txt > $@
+unicode/UnicodeData.txt:
+ mkdir -p unicode
+ curl -s -o $@ ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
+unicode/EastAsianWidth.txt:
+ mkdir -p unicode
+ curl -s -o $@ ftp://ftp.unicode.org/Public/UNIDATA/EastAsianWidth.txt
+
distfiles: ${DISTFILES}
dist: ${DISTFILES}
tagall:
@REL=`sed -e '/char version/!d' -e 's/[^0-9.]*\([0-9.]*\).*/v\1/' -e q ${srcdir}/version.c`; \
echo "tagging $$REL"; \
- $(GIT) tag -f "$$REL"
+ $(GIT) tag -a -f -m "$$REL" "$$REL"
======================================================================
+ Major changes between "less" versions 530 and 551
+
+* Add --mouse option.
+
+* Add --wheel-lines option.
+
+* Add --no-histdups option.
+
+* Add --save-marks option.
+
+* Support PCRE2 regular expression library.
+
+* Redraw screen on SIGWINCH even if screen size doesn't change.
+
+* Shell-escape filenames in history so they can be used again.
+
+* Ring bell if user enters invalid long option name.
+
+* Use PCRE_UTF8 flag for pcre regular expressions when in UTF-8 mode.
+
+* Windows: use wide-char string to set console title.
+
+* Don't count lines in initial screen if using -X with -F.
+
+* Support mingw build system.
+
+* Fix bug in v command on empty file.
+
+* Fix bug in v command when filename contains shell metacharacters.
+
+======================================================================
+
Major changes between "less" versions 487 and 530
* Don't output terminal init sequence if using -F and file fits on one screen.
- Less, version 530
+ Less, version 551
- This is the distribution of less, version 530, released 05 Dec 2017.
+ This is the distribution of less, version 551, released 11 Jun 2019.
This program is part of the GNU project (http://www.gnu.org).
This program is free software. You may redistribute it and/or
finds a regular expression library automatically. Other values are:
gnu Use the GNU regex library.
pcre Use the PCRE library.
+ pcre2 Use the PCRE2 library.
posix Use the POSIX-compatible regcomp.
regcmp Use the regcmp library.
re_comp Use the re_comp library.
regcomp-local Use Henry Spencer's V8-compatible regcomp
(source is supplied with less).
none No regular expressions, only simple string matching.
+
--with-secure
Builds a "secure" version of less, with some features disabled
to prevent users from viewing other files, accessing shell
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Get the character pointed to by the read pointer.
*/
int
-ch_get()
+ch_get(VOID_PARAM)
{
struct buf *bp;
struct bufnode *bn;
* If we haven't read all of standard input into it, do that now.
*/
public void
-end_logfile()
+end_logfile(VOID_PARAM)
{
static int tried = FALSE;
* Write all the existing buffered data to the log file.
*/
public void
-sync_logfile()
+sync_logfile(VOID_PARAM)
{
struct buf *bp;
struct bufnode *bn;
* Seek to the end of the file.
*/
public int
-ch_end_seek()
+ch_end_seek(VOID_PARAM)
{
POSITION len;
* Seek to the last position in the file that is currently buffered.
*/
public int
-ch_end_buffer_seek()
+ch_end_buffer_seek(VOID_PARAM)
{
struct buf *bp;
struct bufnode *bn;
* beginning of the pipe is no longer buffered.
*/
public int
-ch_beg_seek()
+ch_beg_seek(VOID_PARAM)
{
struct bufnode *bn;
struct bufnode *firstbn;
* Return the length of the file, if known.
*/
public POSITION
-ch_length()
+ch_length(VOID_PARAM)
{
if (thisfile == NULL)
return (NULL_POSITION);
* Return the current position in the file.
*/
public POSITION
-ch_tell()
+ch_tell(VOID_PARAM)
{
if (thisfile == NULL)
return (NULL_POSITION);
* Get the current char and post-increment the read pointer.
*/
public int
-ch_forw_get()
+ch_forw_get(VOID_PARAM)
{
int c;
* Pre-decrement the read pointer and get the new current char.
*/
public int
-ch_back_get()
+ch_back_get(VOID_PARAM)
{
if (thisfile == NULL)
return (EOI);
* Flush (discard) any saved file state, including buffer contents.
*/
public void
-ch_flush()
+ch_flush(VOID_PARAM)
{
struct bufnode *bn;
* The buffer is added to the tail of the buffer chain.
*/
static int
-ch_addbuf()
+ch_addbuf(VOID_PARAM)
{
struct buf *bp;
struct bufnode *bn;
*
*/
static void
-init_hashtbl()
+init_hashtbl(VOID_PARAM)
{
int h;
* Delete all buffers for this file.
*/
static void
-ch_delbufs()
+ch_delbufs(VOID_PARAM)
{
struct bufnode *bn;
* This is used after an ignore_eof read, during which the EOF may change.
*/
public void
-ch_set_eof()
+ch_set_eof(VOID_PARAM)
{
ch_fsize = ch_fpos;
}
* Close a filestate.
*/
public void
-ch_close()
+ch_close(VOID_PARAM)
{
int keepstate = FALSE;
* Return ch_flags for the current file.
*/
public int
-ch_getflags()
+ch_getflags(VOID_PARAM)
{
if (thisfile == NULL)
return (0);
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Define a charset, given a locale name.
*/
static void
-ilocale()
+ilocale(VOID_PARAM)
{
int c;
*
*/
static void
-set_charset()
+set_charset(VOID_PARAM)
{
char *s;
* LESSCHARSET is not defined: try LESSCHARDEF.
*/
s = lgetenv("LESSCHARDEF");
- if (s != NULL && *s != '\0')
+ if (!isnullenv(s))
{
ichardef(s);
return;
* Initialize charset data structures.
*/
public void
-init_charset()
+init_charset(VOID_PARAM)
{
char *s;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#define A_RRSHIFT 59
#define A_CLRMARK 62
#define A_SETMARKBOT 63
+#define A_X11MOUSE_IN 64
+#define A_X11MOUSE_IGNORE 65
+#define A_F_MOUSE 66
+#define A_B_MOUSE 67
+/* Note "X116" refers to extended (1006) X11 mouse reporting. */
+#define A_X116MOUSE_IN 68
+#define A_X116MOUSE_IGNORE 69
#define A_INVALID 100
#define A_NOACTION 101
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern int sc_width;
extern int utf_mode;
+extern int no_hist_dups;
+extern int marks_modified;
static char cmdbuf[CMDBUF_SIZE]; /* Buffer for holding a multi-char command */
static int cmd_col; /* Current column of the cursor */
#define HISTFILE_FIRST_LINE ".less-history-file:"
#define HISTFILE_SEARCH_SECTION ".search"
#define HISTFILE_SHELL_SECTION ".shell"
+#define HISTFILE_MARK_SECTION ".mark"
/*
* A mlist structure represents a command history.
* Reset command buffer (to empty).
*/
public void
-cmd_reset()
+cmd_reset(VOID_PARAM)
{
cp = cmdbuf;
*cp = '\0';
* Clear command line.
*/
public void
-clear_cmd()
+clear_cmd(VOID_PARAM)
{
cmd_col = prompt_col = 0;
cmd_mbc_buf_len = 0;
* How many characters are in the command buffer?
*/
public int
-len_cmdbuf()
+len_cmdbuf(VOID_PARAM)
{
char *s = cmdbuf;
char *endline = s + strlen(s);
* and set cp to the corresponding char in cmdbuf.
*/
static void
-cmd_home()
+cmd_home(VOID_PARAM)
{
while (cmd_col > prompt_col)
{
* Shift the cmdbuf display left a half-screen.
*/
static void
-cmd_lshift()
+cmd_lshift(VOID_PARAM)
{
char *s;
char *save_cp;
* Shift the cmdbuf display right a half-screen.
*/
static void
-cmd_rshift()
+cmd_rshift(VOID_PARAM)
{
char *s;
char *save_cp;
* Move cursor right one character.
*/
static int
-cmd_right()
+cmd_right(VOID_PARAM)
{
char *pr;
char *ncp;
* Move cursor left one character.
*/
static int
-cmd_left()
+cmd_left(VOID_PARAM)
{
char *ncp;
int width = 0;
* Delete the char to the left of the cursor.
*/
static int
-cmd_erase()
+cmd_erase(VOID_PARAM)
{
char *s;
int clen;
* Delete the char under the cursor.
*/
static int
-cmd_delete()
+cmd_delete(VOID_PARAM)
{
if (*cp == '\0')
{
* Delete the "word" to the left of the cursor.
*/
static int
-cmd_werase()
+cmd_werase(VOID_PARAM)
{
if (cp > cmdbuf && cp[-1] == ' ')
{
* Delete the "word" under the cursor.
*/
static int
-cmd_wdelete()
+cmd_wdelete(VOID_PARAM)
{
if (*cp == ' ')
{
* Delete all chars in the command buffer.
*/
static int
-cmd_kill()
+cmd_kill(VOID_PARAM)
{
if (cmdbuf[0] == '\0')
{
s = ml->string;
if (s == NULL)
s = "";
+ cmd_offset = 0;
cmd_home();
clear_eol();
strcpy(cmdbuf, s);
#endif
/*
+ *
+ */
+ static void
+ml_link(mlist, ml)
+ struct mlist *mlist;
+ struct mlist *ml;
+{
+ ml->next = mlist;
+ ml->prev = mlist->prev;
+ mlist->prev->next = ml;
+ mlist->prev = ml;
+}
+
+/*
+ *
+ */
+ static void
+ml_unlink(ml)
+ struct mlist *ml;
+{
+ ml->prev->next = ml->next;
+ ml->next->prev = ml->prev;
+}
+
+/*
* Add a string to an mlist.
*/
public void
if (strlen(cmd) == 0)
return;
+ if (no_hist_dups)
+ {
+ struct mlist *next = NULL;
+ for (ml = mlist->next; ml->string != NULL; ml = next)
+ {
+ next = ml->next;
+ if (strcmp(ml->string, cmd) == 0)
+ {
+ ml_unlink(ml);
+ free(ml->string);
+ free(ml);
+ }
+ }
+ }
+
/*
* Save the command unless it's a duplicate of the
* last command in the history.
ml = (struct mlist *) ecalloc(1, sizeof(struct mlist));
ml->string = save(cmd);
ml->modified = modified;
- ml->next = mlist;
- ml->prev = mlist->prev;
- mlist->prev->next = ml;
- mlist->prev = ml;
+ ml_link(mlist, ml);
}
/*
* Point to the cmd just after the just-accepted command.
* Add it to the currently selected history list.
*/
public void
-cmd_accept()
+cmd_accept(VOID_PARAM)
{
#if CMD_HISTORY
/*
* Nothing to do if there is no currently selected history list.
*/
- if (curr_mlist == NULL)
+ if (curr_mlist == NULL || curr_mlist == ml_examine)
return;
cmd_addhist(curr_mlist, cmdbuf, 1);
curr_mlist->modified = 1;
#if TAB_COMPLETE_FILENAME
#define not_in_completion() in_completion = 0
#else
-#define not_in_completion()
+#define not_in_completion(VOID_PARAM)
#endif
/*
* cursor at the end of the word.
*/
static char *
-delimit_word()
+delimit_word(VOID_PARAM)
{
char *word;
#if SPACES_IN_FILENAMES
* which start with that word, and set tk_text to that list.
*/
static void
-init_compl()
+init_compl(VOID_PARAM)
{
char *word;
char c;
tk_trial = next_compl(action, tk_trial);
}
- /*
- * Remove the original word, or the previous trial completion.
- */
+ /*
+ * Remove the original word, or the previous trial completion.
+ */
while (cp > tk_ipoint)
(void) cmd_erase();
* Return a pointer to the command buffer.
*/
public char *
-get_cmdbuf()
+get_cmdbuf(VOID_PARAM)
{
return (cmdbuf);
}
* Return the last (most recent) string in the current command history.
*/
public char *
-cmd_lastpattern()
+cmd_lastpattern(VOID_PARAM)
{
if (curr_mlist == NULL)
return (NULL);
* Get the name of the history file.
*/
static char *
-histfile_name()
+histfile_name(VOID_PARAM)
{
char *home;
char *name;
/* See if filename is explicitly specified by $LESSHISTFILE. */
name = lgetenv("LESSHISTFILE");
- if (name != NULL && *name != '\0')
+ if (!isnullenv(name))
{
if (strcmp(name, "-") == 0 || strcmp(name, "/dev/null") == 0)
/* $LESSHISTFILE == "-" means don't use a history file. */
/* Otherwise, file is in $HOME. */
home = lgetenv("HOME");
- if (home == NULL || *home == '\0')
+ if (isnullenv(home))
{
#if OS2
home = lgetenv("INIT");
- if (home == NULL || *home == '\0')
+ if (isnullenv(home))
#endif
return (NULL);
}
ml = NULL;
skip = NULL;
#endif
+ } else if (strcmp(line, HISTFILE_MARK_SECTION) == 0)
+ {
+ ml = NULL;
} else if (*line == '"')
{
if (ml != NULL)
else
(*action)(uparam, ml, line+1);
}
+ } else if (*line == 'm')
+ {
+ (*action)(uparam, NULL, line);
}
}
fclose(f);
static void
addhist_init(void *uparam, struct mlist *ml, char *string)
{
- if (ml == NULL || string == NULL)
- return;
- cmd_addhist(ml, string, 0);
+ if (ml != NULL)
+ cmd_addhist(ml, string, 0);
+ else if (string != NULL)
+ restore_mark(string);
}
#endif /* CMD_HISTORY */
* Initialize history from a .lesshist file.
*/
public void
-init_cmdhist()
+init_cmdhist(VOID_PARAM)
{
#if CMD_HISTORY
read_cmdhist(&addhist_init, NULL, 0, 0);
{
struct save_ctx *ctx = (struct save_ctx *) uparam;
- if (ml != ctx->mlist) {
+ if (ml != NULL && ml != ctx->mlist) {
/* We're changing mlists. */
if (ctx->mlist)
/* Append any new entries to the end of the current mlist. */
ctx->mlist = ml;
write_mlist_header(ctx->mlist, ctx->fout);
}
- if (string != NULL)
- {
- /* Copy the entry. */
- fprintf(ctx->fout, "\"%s\n", string);
- }
- if (ml == NULL) /* End of file */
+
+ if (string == NULL) /* End of file */
{
/* Write any sections that were not in the original file. */
if (mlist_search.modified)
write_mlist(&mlist_shell, ctx->fout);
}
#endif
+ } else if (ml != NULL)
+ {
+ /* Copy mlist entry. */
+ fprintf(ctx->fout, "\"%s\n", string);
}
+ /* Skip marks */
}
#endif /* CMD_HISTORY */
* Does the history file need to be updated?
*/
static int
-histfile_modified()
+histfile_modified(VOID_PARAM)
{
if (mlist_search.modified)
return 1;
if (mlist_shell.modified)
return 1;
#endif
+#if CMD_HISTORY
+ if (marks_modified)
+ return 1;
+#endif
return 0;
}
* Update the .lesshst file.
*/
public void
-save_cmdhist()
+save_cmdhist(VOID_PARAM)
{
#if CMD_HISTORY
char *histname;
fprintf(fout, "%s\n", HISTFILE_FIRST_LINE);
ctx.fout = fout;
ctx.mlist = NULL;
- read_cmdhist(copy_hist, &ctx, skip_search, skip_shell);
+ read_cmdhist(©_hist, &ctx, skip_search, skip_shell);
+ save_marks(fout, HISTFILE_MARK_SECTION);
fclose(fout);
#if MSDOS_COMPILER==WIN32C
/*
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern IFILE curr_ifile;
extern void *ml_search;
extern void *ml_examine;
+extern int wheel_lines;
#if SHELL_ESCAPE || PIPEC
extern void *ml_shell;
#endif
extern int shift_count;
extern int oldbot;
extern int forw_prompt;
+#if MSDOS_COMPILER==WIN32C
+extern int utf_mode;
+#endif
#if SHELL_ESCAPE
static char *shellcmd = NULL; /* For holding last shell command for "!!" */
* updating the screen.
*/
static void
-cmd_exec()
+cmd_exec(VOID_PARAM)
{
- clear_attn();
+ clear_attn();
clear_bot();
flush();
}
/*
+ * Indicate we are reading a multi-character command.
+ */
+ static void
+set_mca(action)
+ int action;
+{
+ mca = action;
+ deinit_mouse(); /* we don't want mouse events while entering a cmd */
+ clear_bot();
+ clear_cmd();
+}
+
+/*
+ * Indicate we are not reading a multi-character command.
+ */
+ static void
+clear_mca(VOID_PARAM)
+{
+ if (mca == 0)
+ return;
+ mca = 0;
+ init_mouse();
+}
+
+/*
* Set up the display to start a new multi-character command.
*/
static void
void *mlist;
int cmdflags;
{
- mca = action;
- clear_bot();
- clear_cmd();
+ set_mca(action);
cmd_putstr(prompt);
set_mlist(mlist, cmdflags);
}
public int
-in_mca()
+in_mca(VOID_PARAM)
{
return (mca != 0 && mca != A_PREFIX);
}
* Set up the display to start a new search command.
*/
static void
-mca_search()
+mca_search(VOID_PARAM)
{
#if HILITE_SEARCH
if (search_type & SRCH_FILTER)
- mca = A_FILTER;
+ set_mca(A_FILTER);
else
#endif
if (search_type & SRCH_FORW)
- mca = A_F_SEARCH;
+ set_mca(A_F_SEARCH);
else
- mca = A_B_SEARCH;
-
- clear_bot();
- clear_cmd();
+ set_mca(A_B_SEARCH);
if (search_type & SRCH_NO_MATCH)
cmd_putstr("Non-match ");
* Set up the display to start a new toggle-option command.
*/
static void
-mca_opt_toggle()
+mca_opt_toggle(VOID_PARAM)
{
int no_prompt;
int flag;
flag = (optflag & ~OPT_NO_PROMPT);
dash = (flag == OPT_NO_TOGGLE) ? "_" : "-";
- mca = A_OPT_TOGGLE;
- clear_bot();
- clear_cmd();
+ set_mca(A_OPT_TOGGLE);
cmd_putstr(dash);
if (optgetname)
cmd_putstr(dash);
* Execute a multicharacter command.
*/
static void
-exec_mca()
+exec_mca(VOID_PARAM)
{
char *cbuf;
{
char *p;
char *oname;
+ int err;
if (curropt != NULL)
{
return (MCA_DONE);
p = get_cmdbuf();
opt_lower = ASCII_IS_LOWER(p[0]);
- curropt = findopt_name(&p, &oname, NULL);
+ err = 0;
+ curropt = findopt_name(&p, &oname, &err);
if (curropt != NULL)
{
/*
if (cmd_char(c) != CC_OK)
return (MCA_DONE);
}
+ } else if (err != OPT_AMBIG)
+ {
+ bell();
}
return (MCA_MORE);
}
error("There is no %s option", &parg);
return (MCA_DONE);
}
+ opt_lower = ASCII_IS_LOWER(c);
}
/*
* If the option which was entered does not take a
if ((optflag & ~OPT_NO_PROMPT) != OPT_TOGGLE ||
!opt_has_param(curropt))
{
- toggle_option(curropt, ASCII_IS_LOWER(c), "", optflag);
+ toggle_option(curropt, opt_lower, "", optflag);
return (MCA_DONE);
}
/*
* as a normal command character.
*/
number = cmd_int(&fraction);
- mca = 0;
+ clear_mca();
cmd_accept();
return (NO_MCA);
}
* Discard any buffered file data.
*/
static void
-clear_buffers()
+clear_buffers(VOID_PARAM)
{
if (!(ch_getflags() & CH_CANSEEK))
return;
* Make sure the screen is displayed.
*/
static void
-make_display()
+make_display(VOID_PARAM)
{
/*
* If nothing is displayed yet, display starting from initial_scrpos.
* Display the appropriate prompt.
*/
static void
-prompt()
+prompt(VOID_PARAM)
{
constant char *p;
* In Win32, display the file name in the window title.
*/
if (!(ch_getflags() & CH_HELPFILE))
- SetConsoleTitle(pr_expand("Less?f - %f.", 0));
+ {
+ WCHAR w[MAX_PATH+16];
+ p = pr_expand("Less?f - %f.", 0);
+ MultiByteToWideChar(CP_ACP, 0, p, -1, w, sizeof(w)/sizeof(*w));
+ SetConsoleTitleW(w);
+ }
#endif
+
/*
* Select the proper prompt and display it.
*/
putchr(':');
else
{
+#if MSDOS_COMPILER==WIN32C
+ WCHAR w[MAX_PATH*2];
+ char a[MAX_PATH*2];
+ MultiByteToWideChar(CP_ACP, 0, p, -1, w, sizeof(w)/sizeof(*w));
+ WideCharToMultiByte(utf_mode ? CP_UTF8 : GetConsoleOutputCP(),
+ 0, w, -1, a, sizeof(a), NULL, NULL);
+ p = a;
+#endif
at_enter(AT_STANDOUT);
putstr(p);
at_exit();
* Display the less version message.
*/
public void
-dispversion()
+dispversion(VOID_PARAM)
{
PARG parg;
* Return a character to complete a partial command, if possible.
*/
static LWCHAR
-getcc_end_command()
+getcc_end_command(VOID_PARAM)
{
switch (mca)
{
* Get command character.
*/
public int
-getcc()
+getcc(VOID_PARAM)
{
- /* Replace kent (keypad Enter) with a newline. */
- return getcc_repl(kent, "\n", getccu, ungetcc);
+ /* Replace kent (keypad Enter) with a newline. */
+ return getcc_repl(kent, "\n", getccu, ungetcc);
}
/*
* Peek the next command character, without consuming it.
*/
public LWCHAR
-peekcc()
+peekcc(VOID_PARAM)
{
LWCHAR c = getcc();
ungetcc(c);
* Accept and execute commands until a quit command.
*/
public void
-commands()
+commands(VOID_PARAM)
{
int c;
int action;
for (;;)
{
- mca = 0;
+ clear_mca();
cmd_accept();
number = 0;
curropt = NULL;
backward((int) number, 0, 0);
break;
+ case A_F_MOUSE:
+ /*
+ * Forward wheel_lines lines.
+ */
+ cmd_exec();
+ forward(wheel_lines, 0, 0);
+ break;
+
+ case A_B_MOUSE:
+ /*
+ * Backward wheel_lines lines.
+ */
+ cmd_exec();
+ backward(wheel_lines, 0, 0);
+ break;
+
case A_FF_LINE:
/*
* Force forward N (default 1) line.
number = 0;
fraction = 0;
}
- if (number > 100)
+ if (number > 100 || (number == 100 && fraction != 0))
{
number = 100;
fraction = 0;
-/* Generated by "./mkutable -f2 Mn Me Cf -- unicode/UnicodeData.txt" on Tue Jul 25 09:04:35 PDT 2017 */
- { 0x00ad, 0x00ad }, /* Cf */
+/* Generated by "./mkutable -f2 Mn Me -- unicode/UnicodeData.txt" on Wed Feb 13 17:57:05 PST 2019 */
{ 0x0300, 0x036f }, /* Mn */
{ 0x0483, 0x0487 }, /* Mn */
{ 0x0488, 0x0489 }, /* Me */
{ 0x05c1, 0x05c2 }, /* Mn */
{ 0x05c4, 0x05c5 }, /* Mn */
{ 0x05c7, 0x05c7 }, /* Mn */
- { 0x0600, 0x0605 }, /* Cf */
{ 0x0610, 0x061a }, /* Mn */
- { 0x061c, 0x061c }, /* Cf */
{ 0x064b, 0x065f }, /* Mn */
{ 0x0670, 0x0670 }, /* Mn */
{ 0x06d6, 0x06dc }, /* Mn */
- { 0x06dd, 0x06dd }, /* Cf */
{ 0x06df, 0x06e4 }, /* Mn */
{ 0x06e7, 0x06e8 }, /* Mn */
{ 0x06ea, 0x06ed }, /* Mn */
- { 0x070f, 0x070f }, /* Cf */
{ 0x0711, 0x0711 }, /* Mn */
{ 0x0730, 0x074a }, /* Mn */
{ 0x07a6, 0x07b0 }, /* Mn */
{ 0x07eb, 0x07f3 }, /* Mn */
+ { 0x07fd, 0x07fd }, /* Mn */
{ 0x0816, 0x0819 }, /* Mn */
{ 0x081b, 0x0823 }, /* Mn */
{ 0x0825, 0x0827 }, /* Mn */
{ 0x0829, 0x082d }, /* Mn */
{ 0x0859, 0x085b }, /* Mn */
- { 0x08d4, 0x08e1 }, /* Mn */
- { 0x08e2, 0x08e2 }, /* Cf */
+ { 0x08d3, 0x08e1 }, /* Mn */
{ 0x08e3, 0x0902 }, /* Mn */
{ 0x093a, 0x093a }, /* Mn */
{ 0x093c, 0x093c }, /* Mn */
{ 0x09c1, 0x09c4 }, /* Mn */
{ 0x09cd, 0x09cd }, /* Mn */
{ 0x09e2, 0x09e3 }, /* Mn */
+ { 0x09fe, 0x09fe }, /* Mn */
{ 0x0a01, 0x0a02 }, /* Mn */
{ 0x0a3c, 0x0a3c }, /* Mn */
{ 0x0a41, 0x0a42 }, /* Mn */
{ 0x0bc0, 0x0bc0 }, /* Mn */
{ 0x0bcd, 0x0bcd }, /* Mn */
{ 0x0c00, 0x0c00 }, /* Mn */
+ { 0x0c04, 0x0c04 }, /* Mn */
{ 0x0c3e, 0x0c40 }, /* Mn */
{ 0x0c46, 0x0c48 }, /* Mn */
{ 0x0c4a, 0x0c4d }, /* Mn */
{ 0x17c9, 0x17d3 }, /* Mn */
{ 0x17dd, 0x17dd }, /* Mn */
{ 0x180b, 0x180d }, /* Mn */
- { 0x180e, 0x180e }, /* Cf */
{ 0x1885, 0x1886 }, /* Mn */
{ 0x18a9, 0x18a9 }, /* Mn */
{ 0x1920, 0x1922 }, /* Mn */
{ 0x1cf8, 0x1cf9 }, /* Mn */
{ 0x1dc0, 0x1df9 }, /* Mn */
{ 0x1dfb, 0x1dff }, /* Mn */
- { 0x200b, 0x200f }, /* Cf */
- { 0x202a, 0x202e }, /* Cf */
- { 0x2060, 0x2064 }, /* Cf */
- { 0x2066, 0x206f }, /* Cf */
{ 0x20d0, 0x20dc }, /* Mn */
{ 0x20dd, 0x20e0 }, /* Me */
{ 0x20e1, 0x20e1 }, /* Mn */
{ 0xa825, 0xa826 }, /* Mn */
{ 0xa8c4, 0xa8c5 }, /* Mn */
{ 0xa8e0, 0xa8f1 }, /* Mn */
+ { 0xa8ff, 0xa8ff }, /* Mn */
{ 0xa926, 0xa92d }, /* Mn */
{ 0xa947, 0xa951 }, /* Mn */
{ 0xa980, 0xa982 }, /* Mn */
{ 0xfb1e, 0xfb1e }, /* Mn */
{ 0xfe00, 0xfe0f }, /* Mn */
{ 0xfe20, 0xfe2f }, /* Mn */
- { 0xfeff, 0xfeff }, /* Cf */
- { 0xfff9, 0xfffb }, /* Cf */
{ 0x101fd, 0x101fd }, /* Mn */
{ 0x102e0, 0x102e0 }, /* Mn */
{ 0x10376, 0x1037a }, /* Mn */
{ 0x10a38, 0x10a3a }, /* Mn */
{ 0x10a3f, 0x10a3f }, /* Mn */
{ 0x10ae5, 0x10ae6 }, /* Mn */
+ { 0x10d24, 0x10d27 }, /* Mn */
+ { 0x10f46, 0x10f50 }, /* Mn */
{ 0x11001, 0x11001 }, /* Mn */
{ 0x11038, 0x11046 }, /* Mn */
{ 0x1107f, 0x11081 }, /* Mn */
{ 0x110b3, 0x110b6 }, /* Mn */
{ 0x110b9, 0x110ba }, /* Mn */
- { 0x110bd, 0x110bd }, /* Cf */
{ 0x11100, 0x11102 }, /* Mn */
{ 0x11127, 0x1112b }, /* Mn */
{ 0x1112d, 0x11134 }, /* Mn */
{ 0x11173, 0x11173 }, /* Mn */
{ 0x11180, 0x11181 }, /* Mn */
{ 0x111b6, 0x111be }, /* Mn */
- { 0x111ca, 0x111cc }, /* Mn */
+ { 0x111c9, 0x111cc }, /* Mn */
{ 0x1122f, 0x11231 }, /* Mn */
{ 0x11234, 0x11234 }, /* Mn */
{ 0x11236, 0x11237 }, /* Mn */
{ 0x112df, 0x112df }, /* Mn */
{ 0x112e3, 0x112ea }, /* Mn */
{ 0x11300, 0x11301 }, /* Mn */
- { 0x1133c, 0x1133c }, /* Mn */
+ { 0x1133b, 0x1133c }, /* Mn */
{ 0x11340, 0x11340 }, /* Mn */
{ 0x11366, 0x1136c }, /* Mn */
{ 0x11370, 0x11374 }, /* Mn */
{ 0x11438, 0x1143f }, /* Mn */
{ 0x11442, 0x11444 }, /* Mn */
{ 0x11446, 0x11446 }, /* Mn */
+ { 0x1145e, 0x1145e }, /* Mn */
{ 0x114b3, 0x114b8 }, /* Mn */
{ 0x114ba, 0x114ba }, /* Mn */
{ 0x114bf, 0x114c0 }, /* Mn */
{ 0x1171d, 0x1171f }, /* Mn */
{ 0x11722, 0x11725 }, /* Mn */
{ 0x11727, 0x1172b }, /* Mn */
- { 0x11a01, 0x11a06 }, /* Mn */
- { 0x11a09, 0x11a0a }, /* Mn */
+ { 0x1182f, 0x11837 }, /* Mn */
+ { 0x11839, 0x1183a }, /* Mn */
+ { 0x11a01, 0x11a0a }, /* Mn */
{ 0x11a33, 0x11a38 }, /* Mn */
{ 0x11a3b, 0x11a3e }, /* Mn */
{ 0x11a47, 0x11a47 }, /* Mn */
{ 0x11d3c, 0x11d3d }, /* Mn */
{ 0x11d3f, 0x11d45 }, /* Mn */
{ 0x11d47, 0x11d47 }, /* Mn */
+ { 0x11d90, 0x11d91 }, /* Mn */
+ { 0x11d95, 0x11d95 }, /* Mn */
+ { 0x11d97, 0x11d97 }, /* Mn */
+ { 0x11ef3, 0x11ef4 }, /* Mn */
{ 0x16af0, 0x16af4 }, /* Mn */
{ 0x16b30, 0x16b36 }, /* Mn */
{ 0x16f8f, 0x16f92 }, /* Mn */
{ 0x1bc9d, 0x1bc9e }, /* Mn */
- { 0x1bca0, 0x1bca3 }, /* Cf */
{ 0x1d167, 0x1d169 }, /* Mn */
- { 0x1d173, 0x1d17a }, /* Cf */
{ 0x1d17b, 0x1d182 }, /* Mn */
{ 0x1d185, 0x1d18b }, /* Mn */
{ 0x1d1aa, 0x1d1ad }, /* Mn */
{ 0x1e026, 0x1e02a }, /* Mn */
{ 0x1e8d0, 0x1e8d6 }, /* Mn */
{ 0x1e944, 0x1e94a }, /* Mn */
- { 0xe0001, 0xe0001 }, /* Cf */
- { 0xe0020, 0xe007f }, /* Cf */
{ 0xe0100, 0xe01ef }, /* Mn */
--without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
--with-secure Compile in secure mode
--with-no-float Do not use floating point
- --with-regex=LIB select regular expression library (LIB is one of auto,none,gnu,pcre,posix,regcmp,re_comp,regcomp,regcomp-local) [auto]
+ --with-regex=LIB select regular expression library (LIB is one of auto,none,gnu,pcre,pcre2,posix,regcmp,re_comp,regcomp,regcomp-local) [auto]
--with-editor=PROGRAM use PROGRAM as the default editor [vi]
Some influential environment variables:
+
# Checks for identifiers.
ac_fn_c_check_type "$LINENO" "off_t" "ac_cv_type_off_t" "$ac_includes_default"
if test "x$ac_cv_type_off_t" = xyes; then :
_ACEOF
-for ac_func in fsync popen _setjmp sigprocmask sigsetmask snprintf stat system fchmod
+for ac_func in fsync popen _setjmp sigprocmask sigsetmask snprintf stat system fchmod realpath
do :
as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
fi
if test $have_regex = no; then
+if test $WANT_REGEX = auto -o $WANT_REGEX = pcre2; then
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pcre2_compile_8 in -lpcre2-8" >&5
+$as_echo_n "checking for pcre2_compile_8 in -lpcre2-8... " >&6; }
+if ${ac_cv_lib_pcre2_8_pcre2_compile_8+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ ac_check_lib_save_LIBS=$LIBS
+LIBS="-lpcre2-8 $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+/* Override any GCC internal prototype to avoid an error.
+ Use char because int might match the return type of a GCC
+ builtin and then its argument prototype would still apply. */
+#ifdef __cplusplus
+extern "C"
+#endif
+char pcre2_compile_8 ();
+int
+main ()
+{
+return pcre2_compile_8 ();
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+ ac_cv_lib_pcre2_8_pcre2_compile_8=yes
+else
+ ac_cv_lib_pcre2_8_pcre2_compile_8=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+ conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_pcre2_8_pcre2_compile_8" >&5
+$as_echo "$ac_cv_lib_pcre2_8_pcre2_compile_8" >&6; }
+if test "x$ac_cv_lib_pcre2_8_pcre2_compile_8" = xyes; then :
+ $as_echo "#define HAVE_PCRE2 1" >>confdefs.h
+ LIBS="$LIBS -lpcre2-8" have_regex=yes; supported_regex="$supported_regex pcre2"
+fi
+
+fi
+fi
+
+if test $have_regex = no; then
if test $WANT_REGEX = auto -o $WANT_REGEX = pcre; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for pcre_compile in -lpcre" >&5
$as_echo_n "checking for pcre_compile in -lpcre... " >&6; }
[POSIX regcomp() and regex.h])
AH_TEMPLATE([HAVE_PCRE],
[PCRE (Perl-compatible regular expression) library])
+AH_TEMPLATE([HAVE_PCRE2],
+ [PCRE2 (Perl-compatible regular expression) library])
AH_TEMPLATE([HAVE_RE_COMP],
[BSD re_comp()])
AH_TEMPLATE([HAVE_REGCMP],
# Checks for library functions.
AC_TYPE_SIGNAL
-AC_CHECK_FUNCS([fsync popen _setjmp sigprocmask sigsetmask snprintf stat system fchmod])
+AC_CHECK_FUNCS([fsync popen _setjmp sigprocmask sigsetmask snprintf stat system fchmod realpath])
# AC_CHECK_FUNCS may not work for inline functions, so test these separately.
AC_MSG_CHECKING(for memcpy)
# Select a regular expression library.
WANT_REGEX=auto
AC_ARG_WITH(regex,
- [ --with-regex=LIB select regular expression library (LIB is one of auto,none,gnu,pcre,posix,regcmp,re_comp,regcomp,regcomp-local) [[auto]]],
+ [ --with-regex=LIB select regular expression library (LIB is one of auto,none,gnu,pcre,pcre2,posix,regcmp,re_comp,regcomp,regcomp-local) [[auto]]],
WANT_REGEX="$withval")
if test $have_regex = no; then
fi
if test $have_regex = no; then
+if test $WANT_REGEX = auto -o $WANT_REGEX = pcre2; then
+AC_CHECK_LIB(pcre2-8, pcre2_compile_8,
+[AC_DEFINE(HAVE_PCRE2) LIBS="$LIBS -lpcre2-8" have_regex=yes; supported_regex="$supported_regex pcre2"], [])
+fi
+fi
+
+if test $have_regex = no; then
if test $WANT_REGEX = auto -o $WANT_REGEX = pcre; then
AC_CHECK_LIB(pcre, pcre_compile,
[AC_DEFINE(HAVE_PCRE) LIBS="$LIBS -lpcre" have_regex=yes; supported_regex="$supported_regex pcre"], [])
#define PIPEC (!SECURE)
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern int erase_char, erase2_char, kill_char;
extern int secure;
+extern int mousecap;
+extern int screen_trashed;
+extern int sc_height;
#define SK(k) \
SK_SPECIAL_KEY, (k), 6, 1, 1, 1
CONTROL('D'),0, A_F_SCROLL,
'u',0, A_B_SCROLL,
CONTROL('U'),0, A_B_SCROLL,
+ ESC,'[','M',0, A_X11MOUSE_IN,
+ ESC,'[','<',0, A_X116MOUSE_IN,
' ',0, A_F_SCREEN,
'f',0, A_F_SCREEN,
CONTROL('F'),0, A_F_SCREEN,
* Expand special key abbreviations in all command tables.
*/
public void
-expand_cmd_tables()
+expand_cmd_tables(VOID_PARAM)
{
expand_cmd_table(list_fcmd_tables);
expand_cmd_table(list_ecmd_tables);
* Initialize the command lists.
*/
public void
-init_cmds()
+init_cmds(VOID_PARAM)
{
/*
* Add the default command tables.
}
/*
+ * Return action for a mouse wheel down event.
+ */
+ static int
+mouse_wheel_down(VOID_PARAM)
+{
+ return ((mousecap == OPT_ONPLUS) ? A_B_MOUSE : A_F_MOUSE);
+}
+
+/*
+ * Return action for a mouse wheel up event.
+ */
+ static int
+mouse_wheel_up(VOID_PARAM)
+{
+ return ((mousecap == OPT_ONPLUS) ? A_F_MOUSE : A_B_MOUSE);
+}
+
+/*
+ * Return action for a mouse button release event.
+ */
+ static int
+mouse_button_rel(x, y)
+ int x;
+ int y;
+{
+ /*
+ * {{ It would be better to return an action and then do this
+ * in commands() but it's nontrivial to pass y to it. }}
+ */
+ if (y < sc_height-1)
+ {
+ setmark('#', y);
+ screen_trashed = 1;
+ }
+ return (A_NOACTION);
+}
+
+/*
+ * Read a decimal integer. Return the integer and set *pterm to the terminating char.
+ */
+ static int
+getcc_int(pterm)
+ char* pterm;
+{
+ int num = 0;
+ int digits = 0;
+ for (;;)
+ {
+ char ch = getcc();
+ if (ch < '0' || ch > '9')
+ {
+ if (pterm != NULL) *pterm = ch;
+ if (digits == 0)
+ return (-1);
+ return (num);
+ }
+ num = (10 * num) + (ch - '0');
+ ++digits;
+ }
+}
+
+/*
+ * Read suffix of mouse input and return the action to take.
+ * The prefix ("\e[M") has already been read.
+ */
+ static int
+x11mouse_action(VOID_PARAM)
+{
+ int b = getcc() - X11MOUSE_OFFSET;
+ int x = getcc() - X11MOUSE_OFFSET-1;
+ int y = getcc() - X11MOUSE_OFFSET-1;
+ switch (b) {
+ default:
+ return (A_NOACTION);
+ case X11MOUSE_WHEEL_DOWN:
+ return mouse_wheel_down();
+ case X11MOUSE_WHEEL_UP:
+ return mouse_wheel_up();
+ case X11MOUSE_BUTTON_REL:
+ return mouse_button_rel(x, y);
+ }
+}
+
+/*
+ * Read suffix of mouse input and return the action to take.
+ * The prefix ("\e[<") has already been read.
+ */
+ static int
+x116mouse_action(VOID_PARAM)
+{
+ char ch;
+ int x, y;
+ int b = getcc_int(&ch);
+ if (b < 0 || ch != ';') return (A_NOACTION);
+ x = getcc_int(&ch) - 1;
+ if (x < 0 || ch != ';') return (A_NOACTION);
+ y = getcc_int(&ch) - 1;
+ if (y < 0) return (A_NOACTION);
+ switch (b) {
+ case X11MOUSE_WHEEL_DOWN:
+ return mouse_wheel_down();
+ case X11MOUSE_WHEEL_UP:
+ return mouse_wheel_up();
+ default:
+ if (ch != 'm') return (A_NOACTION);
+ return mouse_button_rel(x, y);
+ }
+}
+
+/*
* Search a single command table for the command string in cmd.
*/
static int
*sp = ++p;
a &= ~A_EXTRA;
}
+ if (a == A_X11MOUSE_IN)
+ a = x11mouse_action();
+ else if (a == A_X116MOUSE_IN)
+ a = x116mouse_action();
return (a);
}
} else if (*q == '\0')
return (NULL);
}
+/*
+ * Is a string null or empty?
+ */
+ public int
+isnullenv(s)
+ char* s;
+{
+ return (s == NULL || *s == '\0');
+}
+
#if USERFILE
/*
* Get an "integer" from a lesskey file.
if (c == erase_char || c == erase2_char)
return (EC_BACKSPACE);
if (c == kill_char)
+ {
+#if MSDOS_COMPILER==WIN32C
+ if (!win32_kbhit())
+#endif
+
return (EC_LINEKILL);
+ }
/*
* Collect characters in a buffer.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#endif
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
#define PIPEC (!SECURE)
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
/* PCRE (Perl-compatible regular expression) library */
#undef HAVE_PCRE
+/* PCRE2 (Perl-compatible regular expression) library */
+#undef HAVE_PCRE2
+
/* Define to 1 if you have the `popen' function. */
#undef HAVE_POPEN
/* POSIX regcomp() and regex.h */
#undef HAVE_POSIX_REGCOMP
+/* Define to 1 if you have the `realpath' function. */
+#undef HAVE_REALPATH
+
/* System V regcmp() */
#undef HAVE_REGCMP
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#define PIPEC (!SECURE)
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#define PIPEC (!SECURE)
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#define PIPEC 1
/*
- * LOGFILE is 1 if you wish to allow the -l option (to create log files).
+ * LOGFILE is 1 if you wish to allow the -o option (to create log files).
*/
#define LOGFILE (!SECURE)
/*
* Sizes of various buffers.
*/
-#if 0 /* old sizes for small memory machines
+#if 0 /* old sizes for small memory machines */
#define CMDBUF_SIZE 512 /* Buffer for multichar commands */
#define UNGOT_SIZE 100 /* Max chars to unget() */
#define LINEBUF_SIZE 1024 /* Max size of line in input file */
/* #undef HAVE_POSIX_REGCOMP */
/* #undef HAVE_RE_COMP */
/* #undef HAVE_REGCMP */
+#ifdef MINGW
+ #ifdef USE_POSIX_REGCOMP
+ #define HAVE_POSIX_REGCOMP 1
+ #else
+ #ifdef USE_GNU_REGEX
+ #define HAVE_GNU_REGEX 1
+ #else
+ #ifdef USE_REGEXP_C
+ #define HAVE_V8_REGCOMP 1
+ #define HAVE_REGEXEC2 1
+ #else
+ #define NO_REGEX 1
+ #endif
+ #endif
+ #endif
+#else
#define HAVE_V8_REGCOMP 1
/* #undef NO_REGEX */
#define HAVE_REGEXEC2 1
+#endif
/* Define HAVE_VOID if your compiler supports the "void" type. */
#define HAVE_VOID 1
/* Define MUST_DEFINE_ERRNO if you have errno but it is not define
* in errno.h */
#define HAVE_ERRNO 1
+#ifdef MINGW
+#define MUST_DEFINE_ERRNO 0
+#else
#define MUST_DEFINE_ERRNO 1
+#endif
/* Define HAVE_SYS_ERRLIST if you have the sys_errlist[] variable */
#define HAVE_SYS_ERRLIST 1
#define HAVE_TIME_H 1
/* Define if you have the <unistd.h> header file. */
+#ifdef MINGW
+#define HAVE_UNISTD_H 1
+#else
#define HAVE_UNISTD_H 0
+#endif
/* Define if you have the <values.h> header file. */
#ifdef _MSC_VER
#define HAVE_VALUES_H 0
#else
+#ifdef MINGW
+#define HAVE_VALUES_H 0
+#else
#define HAVE_VALUES_H 1
#endif
+#endif
#define popen _popen
-#define pclose _pclose
#if !defined(_MSC_VER) || (_MSC_VER < 1900)
#define snprintf _snprintf
#endif
+#ifndef MINGW
#pragma warning(disable:4996)
+#endif
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Close the current input file.
*/
static void
-close_file()
+close_file(VOID_PARAM)
{
struct scrpos scrpos;
int chflags;
clr_hilite();
#endif
if (strcmp(filename, FAKE_HELPFILE) && strcmp(filename, FAKE_EMPTYFILE))
- cmd_addhist(ml_examine, filename, 1);
+ {
+ char *qfilename = shell_quote(filename);
+ cmd_addhist(ml_examine, qfilename, 1);
+ free(qfilename);
+ }
+
if (no_display && errmsgs > 0)
{
/*
* Edit the first file in the command line (ifile) list.
*/
public int
-edit_first()
+edit_first(VOID_PARAM)
{
+ if (nifile() == 0)
+ return (edit_stdin());
curr_ifile = NULL_IFILE;
return (edit_next(1));
}
* Edit the last file in the command line (ifile) list.
*/
public int
-edit_last()
+edit_last(VOID_PARAM)
{
curr_ifile = NULL_IFILE;
return (edit_prev(1));
}
public IFILE
-save_curr_ifile()
+save_curr_ifile(VOID_PARAM)
{
if (curr_ifile != NULL_IFILE)
hold_ifile(curr_ifile, 1);
}
public void
-reopen_curr_ifile()
+reopen_curr_ifile(VOID_PARAM)
{
IFILE save_ifile = save_curr_ifile();
close_file();
* Edit standard input.
*/
public int
-edit_stdin()
+edit_stdin(VOID_PARAM)
{
if (isatty(fd0))
{
* Used if standard output is not a tty.
*/
public void
-cat_file()
+cat_file(VOID_PARAM)
{
int c;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Get the shell's escape character.
*/
public char *
-get_meta_escape()
+get_meta_escape(VOID_PARAM)
{
char *s;
* Get the characters which the shell considers to be "metacharacters".
*/
static char *
-metachars()
+metachars(VOID_PARAM)
{
static char *mchars = NULL;
#if HAVE_POPEN
-FILE *popen();
-
/*
* Execute a shell command.
* Return a pointer to a pipe connected to the shell command's standard output.
char *shell;
shell = lgetenv("SHELL");
- if (shell != NULL && *shell != '\0')
+ if (!isnullenv(shell))
{
char *scmd;
char *esccmd;
return (filename);
}
lessecho = lgetenv("LESSECHO");
- if (lessecho == NULL || *lessecho == '\0')
+ if (isnullenv(lessecho))
lessecho = "lessecho";
/*
* Invoke lessecho, and read its output (a globbed list of filenames).
if (*gfilename == '\0')
{
free(gfilename);
- return (save(filename));
+ return (filename);
}
}
#else
}
/*
+ * @@@
+ */
+ public char *
+lrealpath(path)
+ char *path;
+{
+#if HAVE_REALPATH
+ char rpath[PATH_MAX];
+ if (realpath(path, rpath) != NULL)
+ return (save(rpath));
+#endif
+ return (save(path));
+}
+
+/*
* Return number of %s escapes in a string.
* Return a large number if there are any other % escapes besides %s.
*/
*
*/
public char *
-shell_coption()
+shell_coption(VOID_PARAM)
{
return ("-c");
}
-/* Generated by "./mkutable -f2 Cf -- unicode/UnicodeData.txt" on Sun Nov 12 16:13:49 PST 2017 */
+/* Generated by "./mkutable -f2 Cf -- unicode/UnicodeData.txt" on Wed Feb 13 17:57:05 PST 2019 */
{ 0x00ad, 0x00ad }, /* Cf */
{ 0x0600, 0x0605 }, /* Cf */
{ 0x061c, 0x061c }, /* Cf */
{ 0xfeff, 0xfeff }, /* Cf */
{ 0xfff9, 0xfffb }, /* Cf */
{ 0x110bd, 0x110bd }, /* Cf */
+ { 0x110cd, 0x110cd }, /* Cf */
{ 0x1bca0, 0x1bca3 }, /* Cf */
{ 0x1d173, 0x1d17a }, /* Cf */
{ 0xe0001, 0xe0001 }, /* Cf */
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Sound the bell to indicate user is trying to move past end of file.
*/
static void
-eof_bell()
+eof_bell(VOID_PARAM)
{
if (quiet == NOT_QUIET)
bell();
* Check to see if the end of file is currently displayed.
*/
public int
-eof_displayed()
+eof_displayed(VOID_PARAM)
{
POSITION pos;
* Check to see if the entire file is currently displayed.
*/
public int
-entire_file_displayed()
+entire_file_displayed(VOID_PARAM)
{
POSITION pos;
* for the first time.
*/
public void
-squish_check()
+squish_check(VOID_PARAM)
{
if (!squished)
return;
* top_scroll, as well as back_scroll.
*/
public int
-get_back_scroll()
+get_back_scroll(VOID_PARAM)
{
if (no_back_scroll)
return (0);
}
/*
- * Return number of displayable lines in the file.
- * Stop counting at screen height + 1.
+ * Will the entire file fit on one screen?
*/
public int
-get_line_count()
+get_one_screen(VOID_PARAM)
{
int nlines;
POSITION pos = ch_zero();
- for (nlines = 0; nlines <= sc_height; nlines++)
+ for (nlines = 0; nlines < sc_height; nlines++)
{
pos = forw_line(pos);
if (pos == NULL_POSITION) break;
}
- return nlines;
+ return (nlines < sc_height);
}
public void scrsize LESSPARAMS ((VOID_PARAM));
public char * special_key_str LESSPARAMS ((int key));
public void get_term LESSPARAMS ((VOID_PARAM));
+public void init_mouse LESSPARAMS ((VOID_PARAM));
+public void deinit_mouse LESSPARAMS ((VOID_PARAM));
public void init LESSPARAMS ((VOID_PARAM));
public void deinit LESSPARAMS ((VOID_PARAM));
public void home LESSPARAMS ((VOID_PARAM));
public int apply_at_specials LESSPARAMS ((int attr));
public void backspace LESSPARAMS ((VOID_PARAM));
public void putbs LESSPARAMS ((VOID_PARAM));
-public char WIN32getch LESSPARAMS ((int tty));
+public int win32_kbhit LESSPARAMS ((VOID_PARAM));
+public char WIN32getch LESSPARAMS ((VOID_PARAM));
public void WIN32setcolors LESSPARAMS ((int fg, int bg));
public void WIN32textout LESSPARAMS ((char *text, int len));
public void match_brac LESSPARAMS ((int obrac, int cbrac, int forwdir, int n));
public int fcmd_decode LESSPARAMS ((char *cmd, char **sp));
public int ecmd_decode LESSPARAMS ((char *cmd, char **sp));
public char * lgetenv LESSPARAMS ((char *var));
+public int isnullenv LESSPARAMS ((char* s));
public int lesskey LESSPARAMS ((char *filename, int sysvar));
public void add_hometable LESSPARAMS ((char *envname, char *def_filename, int sysvar));
public int editchar LESSPARAMS ((int c, int flags));
public char * fcomplete LESSPARAMS ((char *s));
public int bin_file LESSPARAMS ((int f));
public char * lglob LESSPARAMS ((char *filename));
+public char * lrealpath LESSPARAMS ((char *path));
public char * open_altfile LESSPARAMS ((char *filename, int *pf, void **pfd));
public void close_altfile LESSPARAMS ((char *altfilename, char *filename));
public int is_dir LESSPARAMS ((char *filename));
public void forward LESSPARAMS ((int n, int force, int only_last));
public void backward LESSPARAMS ((int n, int force, int only_last));
public int get_back_scroll LESSPARAMS ((VOID_PARAM));
-public int get_line_count LESSPARAMS ((VOID_PARAM));
+public int get_one_screen LESSPARAMS ((VOID_PARAM));
public void del_ifile LESSPARAMS ((IFILE h));
public IFILE next_ifile LESSPARAMS ((IFILE h));
public IFILE prev_ifile LESSPARAMS ((IFILE h));
public POSITION markpos LESSPARAMS ((int c));
public char posmark LESSPARAMS ((POSITION pos));
public void unmark LESSPARAMS ((IFILE ifile));
+public void mark_check_ifile LESSPARAMS ((IFILE ifile));
+public void save_marks LESSPARAMS ((FILE *fout, char *hdr));
+public void restore_mark LESSPARAMS ((char *line));
public void opt_o LESSPARAMS ((int type, char *s));
public void opt__O LESSPARAMS ((int type, char *s));
public void opt_j LESSPARAMS ((int type, char *s));
public void opt_quote LESSPARAMS ((int type, char *s));
public void opt_rscroll LESSPARAMS ((int type, char *s));
public void opt_query LESSPARAMS ((int type, char *s));
+public void opt_mousecap LESSPARAMS ((int type, char *s));
+public void opt_wheel_lines LESSPARAMS ((int type, char *s));
public int get_swindow LESSPARAMS ((VOID_PARAM));
public char * propt LESSPARAMS ((int c));
public void scan_option LESSPARAMS ((char *s));
public int valid_pattern LESSPARAMS ((char *pattern));
public int is_null_pattern LESSPARAMS ((PATTERN_TYPE pattern));
public int match_pattern LESSPARAMS ((PATTERN_TYPE pattern, char *tpattern, char *line, int line_len, char **sp, char **ep, int notbol, int search_type));
+public char * pattern_lib_name LESSPARAMS ((VOID_PARAM));
public POSITION position LESSPARAMS ((int sindex));
public void add_forw_pos LESSPARAMS ((POSITION pos));
public void add_back_pos LESSPARAMS ((POSITION pos));
public int edit_tagfile LESSPARAMS ((VOID_PARAM));
public void open_getchr LESSPARAMS ((VOID_PARAM));
public void close_getchr LESSPARAMS ((VOID_PARAM));
+public int default_wheel_lines LESSPARAMS ((VOID_PARAM));
public int getchr LESSPARAMS ((VOID_PARAM));
-/* This file was generated by mkhelp.pl from less.hlp at 22:56 on 2017/12/5 */
+/* This file was generated by mkhelp.pl from less.hlp at 18:12 on 2019/6/11 */
#include "less.h"
constant char helpdata[] = {
'\n',
' ',' ','E','S','C','-','u',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','U','n','d','o',' ','(','t','o','g','g','l','e',')',' ','s','e','a','r','c','h',' ','h','i','g','h','l','i','g','h','t','i','n','g','.','\n',
' ',' ','&','_','\b','p','_','\b','a','_','\b','t','_','\b','t','_','\b','e','_','\b','r','_','\b','n',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*',' ',' ','D','i','s','p','l','a','y',' ','o','n','l','y',' ','m','a','t','c','h','i','n','g',' ','l','i','n','e','s','\n',
' ',' ',' ',' ',' ',' ',' ',' ','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','\n',
-' ',' ',' ',' ',' ',' ',' ',' ','A',' ','s','e','a','r','c','h',' ','p','a','t','t','e','r','n',' ','m','a','y',' ','b','e',' ','p','r','e','c','e','d','e','d',' ','b','y',' ','o','n','e',' ','o','r',' ','m','o','r','e',' ','o','f',':','\n',
+' ',' ',' ',' ',' ',' ',' ',' ','A',' ','s','e','a','r','c','h',' ','p','a','t','t','e','r','n',' ','m','a','y',' ','b','e','g','i','n',' ','w','i','t','h',' ','o','n','e',' ','o','r',' ','m','o','r','e',' ','o','f',':','\n',
' ',' ',' ',' ',' ',' ',' ',' ','^','N',' ','o','r',' ','!',' ',' ','S','e','a','r','c','h',' ','f','o','r',' ','N','O','N','-','m','a','t','c','h','i','n','g',' ','l','i','n','e','s','.','\n',
' ',' ',' ',' ',' ',' ',' ',' ','^','E',' ','o','r',' ','*',' ',' ','S','e','a','r','c','h',' ','m','u','l','t','i','p','l','e',' ','f','i','l','e','s',' ','(','p','a','s','s',' ','t','h','r','u',' ','E','N','D',' ','O','F',' ','F','I','L','E',')','.','\n',
' ',' ',' ',' ',' ',' ',' ',' ','^','F',' ','o','r',' ','@',' ',' ','S','t','a','r','t',' ','s','e','a','r','c','h',' ','a','t',' ','F','I','R','S','T',' ','f','i','l','e',' ','(','f','o','r',' ','/',')',' ','o','r',' ','l','a','s','t',' ','f','i','l','e',' ','(','f','o','r',' ','?',')','.','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','i','s','p','l','a','y',' ','a',' ','s','t','a','t','u','s',' ','c','o','l','u','m','n',' ','a','t',' ','l','e','f','t',' ','e','d','g','e',' ','o','f',' ','s','c','r','e','e','n','.','\n',
' ',' ','-','k',' ','[','_','\b','f','_','\b','i','_','\b','l','_','\b','e',']',' ',' ','.',' ',' ','-','-','l','e','s','s','k','e','y','-','f','i','l','e','=','[','_','\b','f','_','\b','i','_','\b','l','_','\b','e',']','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','U','s','e',' ','a',' ','l','e','s','s','k','e','y',' ','f','i','l','e','.','\n',
-' ',' ','-','K',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','q','u','i','t','-','o','n','-','i','n','t','r','\n',
+' ',' ','-','K',' ',' ','.','.','.','.','.','.','.','.',' ',' ','-','-','q','u','i','t','-','o','n','-','i','n','t','r','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','x','i','t',' ','l','e','s','s',' ','i','n',' ','r','e','s','p','o','n','s','e',' ','t','o',' ','c','t','r','l','-','C','.','\n',
' ',' ','-','L',' ',' ','.','.','.','.','.','.','.','.',' ',' ','-','-','n','o','-','l','e','s','s','o','p','e','n','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','I','g','n','o','r','e',' ','t','h','e',' ','L','E','S','S','O','P','E','N',' ','e','n','v','i','r','o','n','m','e','n','t',' ','v','a','r','i','a','b','l','e','.','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','o','n','\'','t',' ','d','i','s','p','l','a','y',' ','t','i','l','d','e','s',' ','a','f','t','e','r',' ','e','n','d',' ','o','f',' ','f','i','l','e','.','\n',
' ',' ','-','#',' ','[','_','\b','N',']',' ',' ','.','.','.','.',' ',' ','-','-','s','h','i','f','t','=','[','_','\b','N',']','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','H','o','r','i','z','o','n','t','a','l',' ','s','c','r','o','l','l',' ','a','m','o','u','n','t',' ','(','0',' ','=',' ','o','n','e',' ','h','a','l','f',' ','s','c','r','e','e','n',' ','w','i','d','t','h',')','\n',
-' ',' ',' ',' ',' ',' ','.','.','.','.','.','.','.','.',' ',' ','-','-','n','o','-','k','e','y','p','a','d','\n',
-' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','o','n','\'','t',' ','s','e','n','d',' ','t','e','r','m','c','a','p',' ','k','e','y','p','a','d',' ','i','n','i','t','/','d','e','i','n','i','t',' ','s','t','r','i','n','g','s','.','\n',
-' ',' ',' ',' ',' ',' ','.','.','.','.','.','.','.','.',' ',' ','-','-','f','o','l','l','o','w','-','n','a','m','e','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','f','o','l','l','o','w','-','n','a','m','e','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','T','h','e',' ','F',' ','c','o','m','m','a','n','d',' ','c','h','a','n','g','e','s',' ','f','i','l','e','s',' ','i','f',' ','t','h','e',' ','i','n','p','u','t',' ','f','i','l','e',' ','i','s',' ','r','e','n','a','m','e','d','.','\n',
-' ',' ',' ',' ',' ',' ','.','.','.','.','.','.','.','.',' ',' ','-','-','u','s','e','-','b','a','c','k','s','l','a','s','h','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','m','o','u','s','e','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','n','a','b','l','e',' ','m','o','u','s','e',' ','i','n','p','u','t','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','n','o','-','k','e','y','p','a','d','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','o','n','\'','t',' ','s','e','n','d',' ','t','e','r','m','c','a','p',' ','k','e','y','p','a','d',' ','i','n','i','t','/','d','e','i','n','i','t',' ','s','t','r','i','n','g','s','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','n','o','-','h','i','s','t','d','u','p','s','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','R','e','m','o','v','e',' ','d','u','p','l','i','c','a','t','e','s',' ','f','r','o','m',' ','c','o','m','m','a','n','d',' ','h','i','s','t','o','r','y','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','r','s','c','r','o','l','l','=','C','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','S','e','t',' ','t','h','e',' ','c','h','a','r','a','c','t','e','r',' ','u','s','e','d',' ','t','o',' ','m','a','r','k',' ','t','r','u','n','c','a','t','e','d',' ','l','i','n','e','s','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','s','a','v','e','-','m','a','r','k','s','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','R','e','t','a','i','n',' ','m','a','r','k','s',' ','a','c','r','o','s','s',' ','i','n','v','o','c','a','t','i','o','n','s',' ','o','f',' ','l','e','s','s','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','u','s','e','-','b','a','c','k','s','l','a','s','h','\n',
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','S','u','b','s','e','q','u','e','n','t',' ','o','p','t','i','o','n','s',' ','u','s','e',' ','b','a','c','k','s','l','a','s','h',' ','a','s',' ','e','s','c','a','p','e',' ','c','h','a','r','.','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','-','-','w','h','e','e','l','-','l','i','n','e','s','=','N','\n',
+' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','a','c','h',' ','c','l','i','c','k',' ','o','f',' ','t','h','e',' ','m','o','u','s','e',' ','w','h','e','e','l',' ','m','o','v','e','s',' ','N',' ','l','i','n','e','s','.','\n',
'\n',
'\n',
' ','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','\n',
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
p->h_hold = 0;
p->h_filestate = NULL;
link_ifile(p, prev);
+ /*
+ * {{ It's dodgy to call mark.c functions from here;
+ * there is potentially dangerous recursion.
+ * Probably need to revisit this design. }}
+ */
+ mark_check_ifile(ext_ifile(p));
return (p);
}
* Return the number of ifiles.
*/
public int
-nifile()
+nifile(VOID_PARAM)
{
return (ifiles);
}
char *filename;
{
struct ifile *p;
+ char *rfilename = lrealpath(filename);
for (p = anchor.h_next; p != &anchor; p = p->h_next)
- if (strcmp(filename, p->h_filename) == 0)
- return (p);
- return (NULL);
+ {
+ if (strcmp(filename, p->h_filename) == 0 ||
+ strcmp(rfilename, p->h_filename) == 0)
+ {
+ /*
+ * If given name is shorter than the name we were
+ * previously using for this file, adopt shorter name.
+ */
+ if (strlen(filename) < strlen(p->h_filename))
+ strcpy(p->h_filename, filename);
+ break;
+ }
+ }
+ free(rfilename);
+ if (p == &anchor)
+ p = NULL;
+ return (p);
}
/*
#if 0
public void
-if_dump()
+if_dump(VOID_PARAM)
{
struct ifile *p;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Jump to the end of the file.
*/
public void
-jump_forw()
+jump_forw(VOID_PARAM)
{
POSITION pos;
POSITION end_pos;
* Jump to the last buffered line in the file.
*/
public void
-jump_forw_buffered()
+jump_forw_buffered(VOID_PARAM)
{
POSITION end;
* Repaint the screen.
*/
public void
-repaint()
+repaint(VOID_PARAM)
{
struct scrpos scrpos;
/*
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
int ln;
};
-/*
- * A mark is an ifile (input file) plus a position within the file.
- */
-struct mark
-{
- IFILE m_ifile;
- struct scrpos m_scrpos;
-};
-
typedef union parg
{
char *p_string;
#endif /* IS_EBCDIC_HOST */
#define ESC CONTROL('[')
+#define ESCS "\33"
#define CSI ((unsigned char)'\233')
#define CHAR_END_COMMAND 0x40000000
#define time_type long
#endif
+/* X11 mouse reporting definitions */
+#define X11MOUSE_BUTTON1 0 /* Left button press */
+#define X11MOUSE_BUTTON2 1 /* Middle button press */
+#define X11MOUSE_BUTTON3 2 /* Right button press */
+#define X11MOUSE_BUTTON_REL 3 /* Button release */
+#define X11MOUSE_WHEEL_UP 0x40 /* Wheel scroll up */
+#define X11MOUSE_WHEEL_DOWN 0x41 /* Wheel scroll down */
+#define X11MOUSE_OFFSET 0x20 /* Added to button & pos bytes to create a char */
+
struct mlist;
struct loption;
struct hilite_tree;
void postoa LESSPARAMS ((POSITION, char*));
void linenumtoa LESSPARAMS ((LINENUM, char*));
void inttoa LESSPARAMS ((int, char*));
+int lstrtoi LESSPARAMS ((char*, char**));
+POSITION lstrtopos LESSPARAMS ((char*, char**));
+#if MSDOS_COMPILER==WIN32C
+int pclose LESSPARAMS ((FILE*));
+#endif
ESC-u Undo (toggle) search highlighting.
&_\bp_\ba_\bt_\bt_\be_\br_\bn * Display only matching lines
---------------------------------------------------
- A search pattern may be preceded by one or more of:
+ A search pattern may begin with one or more of:
^N or ! Search for NON-matching lines.
^E or * Search multiple files (pass thru END OF FILE).
^F or @ Start search at FIRST file (for /) or last file (for ?).
Display a status column at left edge of screen.
-k [_\bf_\bi_\bl_\be] . --lesskey-file=[_\bf_\bi_\bl_\be]
Use a lesskey file.
- -K --quit-on-intr
+ -K ........ --quit-on-intr
Exit less in response to ctrl-C.
-L ........ --no-lessopen
Ignore the LESSOPEN environment variable.
Don't display tildes after end of file.
-# [_\bN] .... --shift=[_\bN]
Horizontal scroll amount (0 = one half screen width)
- ........ --no-keypad
- Don't send termcap keypad init/deinit strings.
- ........ --follow-name
+ --follow-name
The F command changes files if the input file is renamed.
- ........ --use-backslash
+ --mouse
+ Enable mouse input.
+ --no-keypad
+ Don't send termcap keypad init/deinit strings.
+ --no-histdups
+ Remove duplicates from command history.
+ --rscroll=C
+ Set the character used to mark truncated lines.
+ --save-marks
+ Retain marks across invocations of less.
+ --use-backslash
Subsequent options use backslash as escape char.
+ --wheel-lines=N
+ Each click of the mouse wheel moves N lines.
---------------------------------------------------------------------------
-Q or --QUIET or --SILENT
Causes totally "quiet" operation: the terminal bell is never
- rung.
+ rung. If the terminal has a "visual bell", it is used in all
+ cases where the terminal bell would have been rung.
-r or --raw-control-chars
Causes "raw" control characters to be displayed. The default is
- to display control characters using the caret notation; for
+ to display control characters using the caret notation; for
example, a control-A (octal 001) is displayed as "^A". Warning:
when the -r option is used, \e[4mless\e[24m cannot keep track of the actual
- appearance of the screen (since this depends on how the screen
+ appearance of the screen (since this depends on how the screen
responds to each type of control character). Thus, various dis-
- play problems may result, such as long lines being split in the
+ play problems may result, such as long lines being split in the
wrong place.
-R or --RAW-CONTROL-CHARS
- Like -r, but only ANSI "color" escape sequences are output in
+ Like -r, but only ANSI "color" escape sequences are output in
"raw" form. Unlike -r, the screen appearance is maintained cor-
rectly in most cases. ANSI "color" escape sequences are
sequences of the form:
ESC [ ... m
- where the "..." is zero or more color specification characters
- For the purpose of keeping track of screen appearance, ANSI
- color escape sequences are assumed to not move the cursor. You
- can make \e[4mless\e[24m think that characters other than "m" can end ANSI
- color escape sequences by setting the environment variable
+ where the "..." is zero or more color specification characters
+ For the purpose of keeping track of screen appearance, ANSI
+ color escape sequences are assumed to not move the cursor. You
+ can make \e[4mless\e[24m think that characters other than "m" can end ANSI
+ color escape sequences by setting the environment variable
LESSANSIENDCHARS to the list of characters which can end a color
- escape sequence. And you can make \e[4mless\e[24m think that characters
- other than the standard ones may appear between the ESC and the
- m by setting the environment variable LESSANSIMIDCHARS to the
+ escape sequence. And you can make \e[4mless\e[24m think that characters
+ other than the standard ones may appear between the ESC and the
+ m by setting the environment variable LESSANSIMIDCHARS to the
list of characters which can appear.
-s or --squeeze-blank-lines
- Causes consecutive blank lines to be squeezed into a single
+ Causes consecutive blank lines to be squeezed into a single
blank line. This is useful when viewing \e[4mnroff\e[24m output.
-S or --chop-long-lines
- Causes lines longer than the screen width to be chopped (trun-
+ Causes lines longer than the screen width to be chopped (trun-
cated) rather than wrapped. That is, the portion of a long line
that does not fit in the screen width is not shown. The default
- is to wrap long lines; that is, display the remainder on the
+ is to wrap long lines; that is, display the remainder on the
next line.
-t\e[4mtag\e[24m or --tag=\e[4mtag\e[0m
The -t option, followed immediately by a TAG, will edit the file
- containing that tag. For this to work, tag information must be
- available; for example, there may be a file in the current
+ containing that tag. For this to work, tag information must be
+ available; for example, there may be a file in the current
directory called "tags", which was previously built by \e[4mctags\e[24m (1)
or an equivalent command. If the environment variable LESSGLOB-
- ALTAGS is set, it is taken to be the name of a command compati-
- ble with \e[4mglobal\e[24m (1), and that command is executed to find the
+ ALTAGS is set, it is taken to be the name of a command compati-
+ ble with \e[4mglobal\e[24m (1), and that command is executed to find the
tag. (See http://www.gnu.org/software/global/global.html). The
- -t option may also be specified from within \e[4mless\e[24m (using the -
- command) as a way of examining a new file. The command ":t" is
+ -t option may also be specified from within \e[4mless\e[24m (using the -
+ command) as a way of examining a new file. The command ":t" is
equivalent to specifying -t from within \e[4mless\e[24m.
-T\e[4mtagsfile\e[24m or --tag-file=\e[4mtagsfile\e[0m
Specifies a tags file to be used instead of "tags".
-u or --underline-special
- Causes backspaces and carriage returns to be treated as print-
- able characters; that is, they are sent to the terminal when
+ Causes backspaces and carriage returns to be treated as print-
+ able characters; that is, they are sent to the terminal when
they appear in the input.
-U or --UNDERLINE-SPECIAL
- Causes backspaces, tabs, carriage returns and "formatting char-
+ Causes backspaces, tabs, carriage returns and "formatting char-
acters" (as defined by Unicode) to be treated as control charac-
ters; that is, they are handled as specified by the -r option.
- By default, if neither -u nor -U is given, backspaces which
- appear adjacent to an underscore character are treated spe-
- cially: the underlined text is displayed using the terminal's
- hardware underlining capability. Also, backspaces which appear
- between two identical characters are treated specially: the
- overstruck text is printed using the terminal's hardware bold-
- face capability. Other backspaces are deleted, along with the
+ By default, if neither -u nor -U is given, backspaces which
+ appear adjacent to an underscore character are treated spe-
+ cially: the underlined text is displayed using the terminal's
+ hardware underlining capability. Also, backspaces which appear
+ between two identical characters are treated specially: the
+ overstruck text is printed using the terminal's hardware bold-
+ face capability. Other backspaces are deleted, along with the
preceding character. Carriage returns immediately followed by a
- newline are deleted. Other carriage returns are handled as
- specified by the -r option. Text which is overstruck or under-
+ newline are deleted. Other carriage returns are handled as
+ specified by the -r option. Text which is overstruck or under-
lined can be searched for if neither -u nor -U is in effect.
-V or --version
Displays the version number of \e[4mless\e[24m.
-w or --hilite-unread
- Temporarily highlights the first "new" line after a forward
+ Temporarily highlights the first "new" line after a forward
movement of a full page. The first "new" line is the line imme-
- diately following the line previously at the bottom of the
+ diately following the line previously at the bottom of the
screen. Also highlights the target line after a g or p command.
- The highlight is removed at the next command which causes move-
- ment. The entire line is highlighted, unless the -J option is
+ The highlight is removed at the next command which causes move-
+ ment. The entire line is highlighted, unless the -J option is
in effect, in which case only the status column is highlighted.
-W or --HILITE-UNREAD
forward movement command larger than one line.
-x\e[4mn\e[24m,... or --tabs=\e[4mn\e[24m,...
- Sets tab stops. If only one \e[4mn\e[24m is specified, tab stops are set
- at multiples of \e[4mn\e[24m. If multiple values separated by commas are
- specified, tab stops are set at those positions, and then con-
- tinue with the same spacing as the last two. For example,
- \e[4m-x9,17\e[24m will set tabs at positions 9, 17, 25, 33, etc. The
+ Sets tab stops. If only one \e[4mn\e[24m is specified, tab stops are set
+ at multiples of \e[4mn\e[24m. If multiple values separated by commas are
+ specified, tab stops are set at those positions, and then con-
+ tinue with the same spacing as the last two. For example,
+ \e[4m-x9,17\e[24m will set tabs at positions 9, 17, 25, 33, etc. The
default for \e[4mn\e[24m is 8.
-X or --no-init
Disables sending the termcap initialization and deinitialization
- strings to the terminal. This is sometimes desirable if the
- deinitialization string does something unnecessary, like clear-
+ strings to the terminal. This is sometimes desirable if the
+ deinitialization string does something unnecessary, like clear-
ing the screen.
-y\e[4mn\e[24m or --max-forw-scroll=\e[4mn\e[0m
Specifies a maximum number of lines to scroll forward. If it is
- necessary to scroll forward more than \e[4mn\e[24m lines, the screen is
- repainted instead. The -c or -C option may be used to repaint
- from the top of the screen if desired. By default, any forward
+ necessary to scroll forward more than \e[4mn\e[24m lines, the screen is
+ repainted instead. The -c or -C option may be used to repaint
+ from the top of the screen if desired. By default, any forward
movement causes scrolling.
-z\e[4mn\e[24m or --window=\e[4mn\e[24m or -\e[4mn\e[0m
- Changes the default scrolling window size to \e[4mn\e[24m lines. The
+ Changes the default scrolling window size to \e[4mn\e[24m lines. The
default is one screenful. The z and w commands can also be used
- to change the window size. The "z" may be omitted for compati-
+ to change the window size. The "z" may be omitted for compati-
bility with some versions of \e[4mmore\e[24m. If the number \e[4mn\e[24m is negative,
- it indicates \e[4mn\e[24m lines less than the current screen size. For
+ it indicates \e[4mn\e[24m lines less than the current screen size. For
example, if the screen is 24 lines, \e[4m-z-4\e[24m sets the scrolling win-
- dow to 20 lines. If the screen is resized to 40 lines, the
+ dow to 20 lines. If the screen is resized to 40 lines, the
scrolling window automatically changes to 36 lines.
-"\e[4mcc\e[24m or --quotes=\e[4mcc\e[0m
- Changes the filename quoting character. This may be necessary
- if you are trying to name a file which contains both spaces and
- quote characters. Followed by a single character, this changes
- the quote character to that character. Filenames containing a
+ Changes the filename quoting character. This may be necessary
+ if you are trying to name a file which contains both spaces and
+ quote characters. Followed by a single character, this changes
+ the quote character to that character. Filenames containing a
space should then be surrounded by that character rather than by
- double quotes. Followed by two characters, changes the open
- quote to the first character, and the close quote to the second
+ double quotes. Followed by two characters, changes the open
+ quote to the first character, and the close quote to the second
character. Filenames containing a space should then be preceded
- by the open quote character and followed by the close quote
- character. Note that even after the quote characters are
- changed, this option remains -" (a dash followed by a double
+ by the open quote character and followed by the close quote
+ character. Note that even after the quote characters are
+ changed, this option remains -" (a dash followed by a double
quote).
-~ or --tilde
-# or --shift
Specifies the default number of positions to scroll horizontally
- in the RIGHTARROW and LEFTARROW commands. If the number speci-
- fied is zero, it sets the default number of positions to one
+ in the RIGHTARROW and LEFTARROW commands. If the number speci-
+ fied is zero, it sets the default number of positions to one
half of the screen width. Alternately, the number may be speci-
- fied as a fraction of the width of the screen, starting with a
- decimal point: .5 is half of the screen width, .3 is three
- tenths of the screen width, and so on. If the number is speci-
- fied as a fraction, the actual number of scroll positions is
- recalculated if the terminal window is resized, so that the
- actual scroll remains at the specified fraction of the screen
+ fied as a fraction of the width of the screen, starting with a
+ decimal point: .5 is half of the screen width, .3 is three
+ tenths of the screen width, and so on. If the number is speci-
+ fied as a fraction, the actual number of scroll positions is
+ recalculated if the terminal window is resized, so that the
+ actual scroll remains at the specified fraction of the screen
width.
--follow-name
- Normally, if the input file is renamed while an F command is
- executing, \e[4mless\e[24m will continue to display the contents of the
- original file despite its name change. If --follow-name is
+ Normally, if the input file is renamed while an F command is
+ executing, \e[4mless\e[24m will continue to display the contents of the
+ original file despite its name change. If --follow-name is
specified, during an F command \e[4mless\e[24m will periodically attempt to
reopen the file by name. If the reopen succeeds and the file is
- a different file from the original (which means that a new file
- has been created with the same name as the original (now
+ a different file from the original (which means that a new file
+ has been created with the same name as the original (now
renamed) file), \e[4mless\e[24m will display the contents of that new file.
+ --mouse
+ Enables mouse input: scrolling the mouse wheel down moves for-
+ ward in the file, scrolling the mouse wheel up moves backwards
+ in the file, and clicking the mouse sets the "#" mark to the
+ line where the mouse is clicked. The number of lines to scroll
+ when the wheel is moved can be set by the --wheel-lines option.
+ Mouse input works only on terminals which support X11 mouse
+ reporting, and on the Windows version of \e[4mless\e[24m.
+
+ --MOUSE
+ Like --mouse, except the direction scrolled on mouse wheel move-
+ ment is reversed.
+
--no-keypad
Disables sending the keypad initialization and deinitialization
strings to the terminal. This is sometimes useful if the keypad
strings make the numeric keypad behave in an undesirable manner.
- --use-backslash
- This option changes the interpretations of options which follow
- this one. After the --use-backslash option, any backslash in an
- option string is removed and the following character is taken
- literally. This allows a dollar sign to be included in option
- strings.
+ --no-histdups
+ This option changes the behavior so that if a search string or
+ file name is typed in, and the same string is already in the
+ history list, the existing copy is removed from the history list
+ before the new one is added. Thus, a given string will appear
+ only once in the history list. Normally, a string may appear
+ multiple times.
--rscroll
- This option changes the character used to mark truncated lines.
+ This option changes the character used to mark truncated lines.
It may begin with a two-character attribute indicator like LESS-
- BINFMT does. If there is no attribute indicator, standout is
+ BINFMT does. If there is no attribute indicator, standout is
used. If set to "-", truncated lines are not marked.
+ --save-marks
+ Save marks in the history file, so marks are retained across
+ different invocations of \e[4mless\e[24m.
+
+ --use-backslash
+ This option changes the interpretations of options which follow
+ this one. After the --use-backslash option, any backslash in an
+ option string is removed and the following character is taken
+ literally. This allows a dollar sign to be included in option
+ strings.
+
+ --wheel-lines=\e[4mn\e[0m
+ Set the number of lines to scroll when the mouse wheel is
+ scrolled and the --mouse or --MOUSE option is in effect. The
+ default is 1 line.
+
-- A command line argument of "--" marks the end of option argu-
ments. Any arguments following this are interpreted as file-
names. This can be useful when viewing a file whose name begins
lessopen.sh:
#! /bin/sh
case "$1" in
- *.Z) uncompress -c $1 >/tmp/less.$$ 2>/dev/null
- if [ -s /tmp/less.$$ ]; then
- echo /tmp/less.$$
+ *.Z) TEMPFILE=$(mktemp)
+ uncompress -c $1 >$TEMPFILE 2>/dev/null
+ if [ -s $TEMPFILE ]; then
+ echo $TEMPFILE
else
- rm -f /tmp/less.$$
+ rm -f $TEMPFILE
fi
;;
esac
#! /bin/sh
case "$1" in
*.Z) uncompress -c $1 2>/dev/null
+ ;;
*) exit 1
;;
esac
%F Replaced by the last component of the name of the current input
file.
+ %g Replaced by the shell-escaped name of the current input file.
+ This is useful when the expanded string will be used in a shell
+ command, such as in LESSEDIT.
+
%i Replaced by the index of the current file in the list of input
files.
expanded in the same way as the prompt strings. The default value for
LESSEDIT is:
- %E ?lm+%lm. %f
+ %E ?lm+%lm. %g
Note that this expands to the editor name, followed by a + and the line
- number, followed by the file name. If your editor does not accept the
- "+linenumber" syntax, or has other differences in invocation syntax,
- the LESSEDIT variable can be changed to modify this default.
+ number, followed by the shell-escaped file name. If your editor does
+ not accept the "+linenumber" syntax, or has other differences in invo-
+ cation syntax, the LESSEDIT variable can be changed to modify this
+ default.
\e[1mSECURITY\e[0m
- When the environment variable LESSSECURE is set to 1, \e[4mless\e[24m runs in a
+ When the environment variable LESSSECURE is set to 1, \e[4mless\e[24m runs in a
"secure" mode. This means these features are disabled:
! the shell command
\e[1mCOMPATIBILITY WITH MORE\e[0m
If the environment variable LESS_IS_MORE is set to 1, or if the program
- is invoked via a file link named "more", \e[4mless\e[24m behaves (mostly) in con-
- formance with the POSIX "more" command specification. In this mode,
+ is invoked via a file link named "more", \e[4mless\e[24m behaves (mostly) in con-
+ formance with the POSIX "more" command specification. In this mode,
less behaves differently in these ways:
- The -e option works differently. If the -e option is not set, \e[4mless\e[0m
- behaves as if the -e option were set. If the -e option is set, \e[4mless\e[0m
+ The -e option works differently. If the -e option is not set, \e[4mless\e[0m
+ behaves as if the -e option were set. If the -e option is set, \e[4mless\e[0m
behaves as if the -E option were set.
- The -m option works differently. If the -m option is not set, the
- medium prompt is used, and it is prefixed with the string "--More--".
+ The -m option works differently. If the -m option is not set, the
+ medium prompt is used, and it is prefixed with the string "--More--".
If the -m option is set, the short prompt is used.
- The -n option acts like the -z option. The normal behavior of the -n
+ The -n option acts like the -z option. The normal behavior of the -n
option is unavailable in this mode.
- The parameter to the -p option is taken to be a \e[4mless\e[24m command rather
+ The parameter to the -p option is taken to be a \e[4mless\e[24m command rather
than a search pattern.
- The LESS environment variable is ignored, and the MORE environment
+ The LESS environment variable is ignored, and the MORE environment
variable is used in its place.
\e[1mENVIRONMENT VARIABLES\e[0m
Environment variables may be specified either in the system environment
- as usual, or in a \e[4mlesskey\e[24m (1) file. If environment variables are
- defined in more than one place, variables defined in a local lesskey
- file take precedence over variables defined in the system environment,
+ as usual, or in a \e[4mlesskey\e[24m (1) file. If environment variables are
+ defined in more than one place, variables defined in a local lesskey
+ file take precedence over variables defined in the system environment,
which take precedence over variables defined in the system-wide lesskey
file.
COLUMNS
Sets the number of columns on the screen. Takes precedence over
- the number of columns specified by the TERM variable. (But if
+ the number of columns specified by the TERM variable. (But if
you have a windowing system which supports TIOCGWINSZ or
- WIOCGETD, the window system's idea of the screen size takes
+ WIOCGETD, the window system's idea of the screen size takes
precedence over the LINES and COLUMNS environment variables.)
EDITOR The name of the editor (used for the v command).
- HOME Name of the user's home directory (used to find a lesskey file
+ HOME Name of the user's home directory (used to find a lesskey file
on Unix and OS/2 systems).
HOMEDRIVE, HOMEPATH
- Concatenation of the HOMEDRIVE and HOMEPATH environment vari-
+ Concatenation of the HOMEDRIVE and HOMEPATH environment vari-
ables is the name of the user's home directory if the HOME vari-
able is not set (only in the Windows version).
- INIT Name of the user's init directory (used to find a lesskey file
+ INIT Name of the user's init directory (used to find a lesskey file
on OS/2 systems).
LANG Language for determining the character set.
LESS Options which are passed to \e[4mless\e[24m automatically.
LESSANSIENDCHARS
- Characters which may end an ANSI color escape sequence (default
+ Characters which may end an ANSI color escape sequence (default
"m").
LESSANSIMIDCHARS
- Characters which may appear between the ESC character and the
- end character in an ANSI color escape sequence (default
+ Characters which may appear between the ESC character and the
+ end character in an ANSI color escape sequence (default
"0123456789:;[?!"'#%()*+ ".
LESSBINFMT
LESSECHO
Name of the lessecho program (default "lessecho"). The lessecho
- program is needed to expand metacharacters, such as * and ?, in
+ program is needed to expand metacharacters, such as * and ?, in
filenames on Unix systems.
LESSEDIT
- Editor prototype string (used for the v command). See discus-
+ Editor prototype string (used for the v command). See discus-
sion under PROMPTS.
LESSGLOBALTAGS
- Name of the command used by the -t option to find global tags.
+ Name of the command used by the -t option to find global tags.
Normally should be set to "global" if your system has the \e[4mglobal\e[0m
(1) command. If not set, global tags are not used.
LESSHISTFILE
- Name of the history file used to remember search commands and
- shell commands between invocations of \e[4mless\e[24m. If set to "-" or
- "/dev/null", a history file is not used. The default is
- "$HOME/.lesshst" on Unix systems, "$HOME/_lesshst" on DOS and
- Windows systems, or "$HOME/lesshst.ini" or "$INIT/lesshst.ini"
+ Name of the history file used to remember search commands and
+ shell commands between invocations of \e[4mless\e[24m. If set to "-" or
+ "/dev/null", a history file is not used. The default is
+ "$HOME/.lesshst" on Unix systems, "$HOME/_lesshst" on DOS and
+ Windows systems, or "$HOME/lesshst.ini" or "$INIT/lesshst.ini"
on OS/2 systems.
LESSHISTSIZE
Name of the default system-wide lesskey(1) file.
LESSMETACHARS
- List of characters which are considered "metacharacters" by the
+ List of characters which are considered "metacharacters" by the
shell.
LESSMETAESCAPE
- Prefix which less will add before each metacharacter in a com-
- mand sent to the shell. If LESSMETAESCAPE is an empty string,
- commands containing metacharacters will not be passed to the
+ Prefix which less will add before each metacharacter in a com-
+ mand sent to the shell. If LESSMETAESCAPE is an empty string,
+ commands containing metacharacters will not be passed to the
shell.
LESSOPEN
Runs less in "secure" mode. See discussion under SECURITY.
LESSSEPARATOR
- String to be appended to a directory name in filename comple-
+ String to be appended to a directory name in filename comple-
tion.
LESSUTFBINFMT
LESS_IS_MORE
Emulate the \e[4mmore\e[24m (1) command.
- LINES Sets the number of lines on the screen. Takes precedence over
+ LINES Sets the number of lines on the screen. Takes precedence over
the number of lines specified by the TERM variable. (But if you
- have a windowing system which supports TIOCGWINSZ or WIOCGETD,
- the window system's idea of the screen size takes precedence
+ have a windowing system which supports TIOCGWINSZ or WIOCGETD,
+ the window system's idea of the screen size takes precedence
over the LINES and COLUMNS environment variables.)
- MORE Options which are passed to \e[4mless\e[24m automatically when running in
+ MORE Options which are passed to \e[4mless\e[24m automatically when running in
\e[4mmore\e[24m compatible mode.
- PATH User's search path (used to find a lesskey file on MS-DOS and
+ PATH User's search path (used to find a lesskey file on MS-DOS and
OS/2 systems).
- SHELL The shell used to execute the ! command, as well as to expand
+ SHELL The shell used to execute the ! command, as well as to expand
filenames.
TERM The type of terminal on which \e[4mless\e[24m is being run.
\e[1mCOPYRIGHT\e[0m
- Copyright (C) 1984-2017 Mark Nudelman
+ Copyright (C) 1984-2019 Mark Nudelman
- less is part of the GNU project and is free software. You can redis-
- tribute it and/or modify it under the terms of either (1) the GNU Gen-
- eral Public License as published by the Free Software Foundation; or
+ less is part of the GNU project and is free software. You can redis-
+ tribute it and/or modify it under the terms of either (1) the GNU Gen-
+ eral Public License as published by the Free Software Foundation; or
(2) the Less License. See the file README in the less distribution for
more details regarding redistribution. You should have received a copy
- of the GNU General Public License along with the source for less; see
- the file COPYING. If not, write to the Free Software Foundation, 59
- Temple Place, Suite 330, Boston, MA 02111-1307, USA. You should also
+ of the GNU General Public License along with the source for less; see
+ the file COPYING. If not, write to the Free Software Foundation, 59
+ Temple Place, Suite 330, Boston, MA 02111-1307, USA. You should also
have received a copy of the Less License; see the file LICENSE.
less is distributed in the hope that it will be useful, but WITHOUT ANY
- WARRANTY; without even the implied warranty of MERCHANTABILITY or FIT-
- NESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FIT-
+ NESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.
\e[1mAUTHOR\e[0m
Mark Nudelman
- Send bug reports or comments to <bug-less@gnu.org>
- See http://www.greenwoodsoftware.com/less/bugs.html for the latest list
- of known bugs in less.
+ Report bugs at https://github.com/gwsw/less/issues.
For more information, see the less homepage at
http://www.greenwoodsoftware.com/less.
- Version 530: 05 Dec 2017 LESS(1)
+ Version 551: 11 Jun 2019 LESS(1)
-.TH LESS 1 "Version 530: 05 Dec 2017"
+.TH LESS 1 "Version 551: 11 Jun 2019"
.SH NAME
less \- opposite of more
.SH SYNOPSIS
.IP "\-Q or \-\-QUIET or \-\-SILENT"
Causes totally "quiet" operation:
the terminal bell is never rung.
+If the terminal has a "visual bell", it is used in all cases
+where the terminal bell would have been rung.
.IP "\-r or \-\-raw-control-chars"
Causes "raw" control characters to be displayed.
The default is to display control characters using the caret notation;
with the same name as the original (now renamed) file),
.I less
will display the contents of that new file.
+.IP "\-\-mouse"
+Enables mouse input:
+scrolling the mouse wheel down moves forward in the file,
+scrolling the mouse wheel up moves backwards in the file,
+and clicking the mouse sets the "#" mark to the line
+where the mouse is clicked.
+The number of lines to scroll when the wheel is moved
+can be set by the \-\-wheel-lines option.
+Mouse input works only on terminals which support X11 mouse reporting,
+and on the Windows version of
+.IR less .
+.IP "\-\-MOUSE"
+Like \-\-mouse, except the direction scrolled
+on mouse wheel movement is reversed.
.IP "\-\-no-keypad"
Disables sending the keypad initialization and deinitialization strings
to the terminal.
This is sometimes useful if the keypad strings make the numeric
keypad behave in an undesirable manner.
-.IP "\-\-use-backslash"
-This option changes the interpretations of options which follow this one.
-After the \-\-use-backslash option, any backslash in an option string is
-removed and the following character is taken literally.
-This allows a dollar sign to be included in option strings.
+.IP "\-\-no-histdups"
+This option changes the behavior so that if a search string or
+file name is typed in, and the same string is already in the history list,
+the existing copy is removed from the history list before the new one is added.
+Thus, a given string will appear only once in the history list.
+Normally, a string may appear multiple times.
.IP "\-\-rscroll"
This option changes the character used to mark truncated lines.
It may begin with a two-character attribute indicator like LESSBINFMT does.
If there is no attribute indicator, standout is used.
If set to "-", truncated lines are not marked.
+.IP "\-\-save-marks"
+Save marks in the history file, so marks are retained
+across different invocations of \fIless\fP.
+.IP "\-\-use-backslash"
+This option changes the interpretations of options which follow this one.
+After the \-\-use-backslash option, any backslash in an option string is
+removed and the following character is taken literally.
+This allows a dollar sign to be included in option strings.
+.IP "\-\-wheel-lines=\fIn\fP"
+Set the number of lines to scroll when the mouse wheel is scrolled
+and the \-\-mouse or \-\-MOUSE option is in effect.
+The default is 1 line.
.IP \-\-
A command line argument of "\-\-" marks the end of option arguments.
Any arguments following this are interpreted as filenames.
.br
case "$1" in
.br
- *.Z) uncompress \-c $1 >/tmp/less.$$ 2>/dev/null
+ *.Z) TEMPFILE=$(mktemp)
+.br
+ uncompress \-c $1 >$TEMPFILE 2>/dev/null
.br
- if [ \-s /tmp/less.$$ ]; then
+ if [ \-s $TEMPFILE ]; then
.br
- echo /tmp/less.$$
+ echo $TEMPFILE
.br
else
.br
- rm \-f /tmp/less.$$
+ rm \-f $TEMPFILE
.br
fi
.br
.br
*.Z) uncompress \-c $1 2>/dev/null
.br
+ ;;
+.br
*) exit 1
.br
;;
Replaced by the name of the current input file.
.IP "%F"
Replaced by the last component of the name of the current input file.
+.IP "%g"
+Replaced by the shell-escaped name of the current input file.
+This is useful when the expanded string will be used in a shell command,
+such as in LESSEDIT.
.IP "%i"
Replaced by the index of the current file in the list of
input files.
The default value for LESSEDIT is:
.nf
.sp
- %E\ ?lm+%lm.\ %f
+ %E\ ?lm+%lm.\ %g
.sp
.fi
Note that this expands to the editor name, followed by a + and the
-line number, followed by the file name.
+line number, followed by the shell-escaped file name.
If your editor does not accept the "+linenumber" syntax, or has other
differences in invocation syntax, the LESSEDIT variable can be
changed to modify this default.
lesskey(1)
.SH COPYRIGHT
-Copyright (C) 1984-2017 Mark Nudelman
+Copyright (C) 1984-2019 Mark Nudelman
.PP
less is part of the GNU project and is free software.
You can redistribute it and/or modify it
.PP
Mark Nudelman
.br
-Send bug reports or comments to <bug-less@gnu.org>
-.br
-See http://www.greenwoodsoftware.com/less/bugs.html for the latest list of known bugs in less.
+Report bugs at https://github.com/gwsw/less/issues.
.br
For more information, see the less homepage at
.br
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
static int num_metachars = 0;
static void
-pr_usage()
+pr_usage(VOID_PARAM)
{
fprintf(stderr,
"usage: lessecho [-ox] [-cx] [-pn] [-dn] [-mx] [-nn] [-ex] [-fn] [-a] file ...\n");
}
static void
-pr_version()
+pr_version(VOID_PARAM)
{
char *p;
char buf[10];
- Version 530: 05 Dec 2017 LESSECHO(1)
+ Version 551: 11 Jun 2019 LESSECHO(1)
-.TH LESSECHO 1 "Version 530: 05 Dec 2017"
+.TH LESSECHO 1 "Version 551: 11 Jun 2019"
.SH NAME
lessecho \- expand metacharacters
.SH SYNOPSIS
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern char version[];
void
-usage()
+usage(VOID_PARAM)
{
fprintf(stderr, "usage: lesskey [-o output] [input]\n");
exit(1);
* Initialize data structures.
*/
void
-init_tables()
+init_tables(VOID_PARAM)
{
cmdtable.names = cmdnames;
cmdtable.pbuffer = cmdtable.buffer;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
\e[1mCOPYRIGHT\e[0m
- Copyright (C) 1984-2017 Mark Nudelman
+ Copyright (C) 1984-2019 Mark Nudelman
less is part of the GNU project and is free software. You can redis-
tribute it and/or modify it under the terms of either (1) the GNU Gen-
- Version 530: 05 Dec 2017 LESSKEY(1)
+ Version 551: 11 Jun 2019 LESSKEY(1)
-.TH LESSKEY 1 "Version 530: 05 Dec 2017"
+.TH LESSKEY 1 "Version 551: 11 Jun 2019"
.SH NAME
lesskey \- specify key bindings for less
.SH SYNOPSIS
This NUL character should be represented as \e340 in a lesskey file.
.SH COPYRIGHT
-Copyright (C) 1984-2017 Mark Nudelman
+Copyright (C) 1984-2019 Mark Nudelman
.PP
less is part of the GNU project and is free software.
You can redistribute it and/or modify it
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
char ext[_MAX_EXT]; \
int handle;
#else
-#if MSDOS_COMPILER==WIN32C && defined(_MSC_VER)
+#if MSDOS_COMPILER==WIN32C && (defined(_MSC_VER) || defined(MINGW))
#define GLOB_FIRST_NAME(filename,fndp,h) h = _findfirst(filename, fndp)
#define GLOB_FIRST_FAILED(handle) ((handle) == -1)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern int utf_mode;
extern POSITION start_attnpos;
extern POSITION end_attnpos;
-extern LWCHAR rscroll_char;
+extern char rscroll_char;
extern int rscroll_attr;
static char mbc_buf[MAX_UTF_CHAR_LEN];
* Initialize from environment variables.
*/
public void
-init_line()
+init_line(VOID_PARAM)
{
end_ansi_chars = lgetenv("LESSANSIENDCHARS");
- if (end_ansi_chars == NULL || *end_ansi_chars == '\0')
+ if (isnullenv(end_ansi_chars))
end_ansi_chars = "m";
mid_ansi_chars = lgetenv("LESSANSIMIDCHARS");
- if (mid_ansi_chars == NULL || *mid_ansi_chars == '\0')
+ if (isnullenv(mid_ansi_chars))
mid_ansi_chars = "0123456789:;[?!\"'#%()*+ ";
linebuf = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
* Expand the line buffer.
*/
static int
-expand_linebuf()
+expand_linebuf(VOID_PARAM)
{
/* Double the size of the line buffer. */
int new_size = size_linebuf * 2;
free(new_buf);
return 1;
}
-#if HAVE_REALLOC
- /*
- * We realloc'd the buffers; they already have the old contents.
- */
- #if 0
- memset(new_buf + size_linebuf, 0, new_size - size_linebuf);
- memset(new_attr + size_linebuf, 0, new_size - size_linebuf);
- #endif
-#else
+#if !HAVE_REALLOC
/*
* We just calloc'd the buffers; copy the old contents.
*/
* Rewind the line buffer.
*/
public void
-prewind()
+prewind(VOID_PARAM)
{
curr = 0;
column = 0;
static void
set_linebuf(n, ch, a)
int n;
- LWCHAR ch;
+ char ch;
char a;
{
linebuf[n] = ch;
*/
static void
add_linebuf(ch, a, w)
- LWCHAR ch;
+ char ch;
char a;
int w;
{
*
*/
public void
-pshift_all()
+pshift_all(VOID_PARAM)
{
pshift(column);
}
* Return 1 if one is found.
*/
static int
-backc()
+backc(VOID_PARAM)
{
LWCHAR prev_ch;
char *p = linebuf + curr;
* Are we currently within a recognized ANSI escape sequence?
*/
static int
-in_ansi_esc_seq()
+in_ansi_esc_seq(VOID_PARAM)
{
char *p;
*
*/
public int
-pflushmbc()
+pflushmbc(VOID_PARAM)
{
int r = 0;
* Switch to normal attribute at end of line.
*/
static void
-add_attr_normal()
+add_attr_normal(VOID_PARAM)
{
char *p = "\033[m";
* Indicate that there is no current line.
*/
public void
-null_line()
+null_line(VOID_PARAM)
{
is_null_line = 1;
cshift = 0;
* Find the shift necessary to show the end of the longest displayed line.
*/
public int
-rrshift()
+rrshift(VOID_PARAM)
{
POSITION pos;
int save_width;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Initialize the line number structures.
*/
public void
-clr_linenum()
+clr_linenum(VOID_PARAM)
{
struct linenum_info *p;
* line number, print a message to tell the user what we're doing.
*/
static void
-longloopmessage()
+longloopmessage(VOID_PARAM)
{
ierror("Calculating line numbers", NULL_PARG);
}
#endif
static void
-longish()
+longish(VOID_PARAM)
{
#if HAVE_TIME
if (loopcount >= 0 && ++loopcount > 100)
* a lengthy line number calculation.
*/
static void
-abort_long()
+abort_long(VOID_PARAM)
{
if (linenums == OPT_ONPLUS)
/*
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#if MSDOS_COMPILER
#include <dos.h>
+#if MSDOS_COMPILER==WIN32C && defined(MINGW)
+#include <direct.h>
+#define setdisk(n) _chdrive((n)+1)
+#else
#ifdef _MSC_VER
#include <direct.h>
#define setdisk(n) _chdrive((n)+1)
#include <dir.h>
#endif
#endif
+#endif
extern int screen_trashed;
extern IFILE curr_ifile;
{
FILE *f;
int c;
- extern FILE *popen();
/*
* This is structured much like lsystem().
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#include "less.h"
#if MSDOS_COMPILER==WIN32C
+#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
static char consoleTitle[256];
#endif
-public int line_count;
+public int one_screen;
extern int less_is_more;
extern int missing_cap;
extern int know_dumb;
extern int pr_type;
extern int quit_if_one_screen;
+extern int no_init;
/*
secure = 0;
s = lgetenv("LESSSECURE");
- if (s != NULL && *s != '\0')
+ if (!isnullenv(s))
secure = 1;
#ifdef WIN32
* Command line arguments override environment arguments.
*/
is_tty = isatty(1);
+ init_mark();
init_cmds();
get_term();
expand_cmd_tables();
* If the name of the executable program is "more",
* act like LESS_IS_MORE is set.
*/
- for (s = progname + strlen(progname); s > progname; s--)
- {
- if (s[-1] == PATHNAME_SEP[0])
- break;
- }
+ s = last_component(progname);
if (strcmp(s, "more") == 0)
less_is_more = 1;
if (editor == NULL || *editor == '\0')
{
editor = lgetenv("EDITOR");
- if (editor == NULL || *editor == '\0')
+ if (isnullenv(editor))
editor = EDIT_PGM;
}
editproto = lgetenv("LESSEDIT");
- if (editproto == NULL || *editproto == '\0')
- editproto = "%E ?lm+%lm. %f";
+ if (isnullenv(editproto))
+ editproto = "%E ?lm+%lm. %g";
#endif
/*
* Just copy the input file(s) to output.
*/
SET_BINARY(1);
- if (nifile() == 0)
- {
- if (edit_stdin() == 0)
- cat_file();
- } else if (edit_first() == 0)
+ if (edit_first() == 0)
{
do {
cat_file();
if (missing_cap && !know_dumb)
error("WARNING: terminal is not fully functional", NULL_PARG);
- init_mark();
open_getchr();
raw_mode(1);
init_signals(1);
initial_scrpos.ln = jump_sline;
} else
#endif
- if (nifile() == 0)
- {
- if (edit_stdin()) /* Edit standard input */
- quit(QUIT_ERROR);
- if (quit_if_one_screen)
- line_count = get_line_count();
- } else
{
- if (edit_first()) /* Edit first valid file in cmd line */
+ if (edit_first())
quit(QUIT_ERROR);
+ /*
+ * See if file fits on one screen to decide whether
+ * to send terminal init. But don't need this
+ * if -X (no_init) overrides this (see init()).
+ */
if (quit_if_one_screen)
{
- if (nifile() == 1)
- line_count = get_line_count();
- else /* If more than one file, -F can not be used */
+ if (nifile() > 1) /* If more than one file, -F cannot be used */
quit_if_one_screen = FALSE;
+ else if (!no_init)
+ one_screen = get_one_screen();
}
}
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern IFILE curr_ifile;
extern int sc_height;
extern int jump_sline;
+extern int perma_marks;
+
+/*
+ * A mark is an ifile (input file) plus a position within the file.
+ */
+struct mark
+{
+ /*
+ * Normally m_ifile != IFILE_NULL and m_filename == NULL.
+ * For restored marks we set m_filename instead of m_ifile
+ * because we don't want to create an ifile until the
+ * user explicitly requests the file (by name or mark).
+ */
+ char m_letter; /* Associated character */
+ IFILE m_ifile; /* Input file being marked */
+ char *m_filename; /* Name of the input file */
+ struct scrpos m_scrpos; /* Position of the mark */
+};
/*
* The table of marks.
* Each mark is identified by a lowercase or uppercase letter.
* The final one is lmark, for the "last mark"; addressed by the apostrophe.
*/
-#define NMARKS ((2*26)+1) /* a-z, A-Z, lastmark */
+#define NMARKS ((2*26)+2) /* a-z, A-Z, mousemark, lastmark */
+#define NUMARKS ((2*26)+1) /* user marks (not lastmark) */
+#define MOUSEMARK (NMARKS-2)
#define LASTMARK (NMARKS-1)
static struct mark marks[NMARKS];
+public int marks_modified = 0;
+
+
+/*
+ * Initialize a mark struct.
+ */
+ static void
+cmark(m, ifile, pos, ln)
+ struct mark *m;
+ IFILE ifile;
+ POSITION pos;
+ int ln;
+{
+ m->m_ifile = ifile;
+ m->m_scrpos.pos = pos;
+ m->m_scrpos.ln = ln;
+ m->m_filename = NULL;
+}
/*
* Initialize the mark table to show no marks are set.
*/
public void
-init_mark()
+init_mark(VOID_PARAM)
{
int i;
for (i = 0; i < NMARKS; i++)
- marks[i].m_scrpos.pos = NULL_POSITION;
+ {
+ char letter;
+ switch (i) {
+ case MOUSEMARK: letter = '#'; break;
+ case LASTMARK: letter = '\''; break;
+ default: letter = (i < 26) ? 'a'+i : 'A'+i-26; break;
+ }
+ marks[i].m_letter = letter;
+ cmark(&marks[i], NULL_IFILE, NULL_POSITION, -1);
+ }
}
/*
- * See if a mark letter is valid (between a and z).
+ * Set m_ifile and clear m_filename.
+ */
+ static void
+mark_set_ifile(m, ifile)
+ struct mark *m;
+ IFILE ifile;
+{
+ m->m_ifile = ifile;
+ /* With m_ifile set, m_filename is no longer needed. */
+ free(m->m_filename);
+ m->m_filename = NULL;
+}
+
+/*
+ * Populate the m_ifile member of a mark struct from m_filename.
+ */
+ static void
+mark_get_ifile(m)
+ struct mark *m;
+{
+ if (m->m_ifile != NULL_IFILE)
+ return; /* m_ifile is already set */
+ mark_set_ifile(m, get_ifile(m->m_filename, prev_ifile(NULL_IFILE)));
+}
+
+/*
+ * Return the user mark struct identified by a character.
*/
static struct mark *
getumark(c)
{
if (c >= 'a' && c <= 'z')
return (&marks[c-'a']);
-
if (c >= 'A' && c <= 'Z')
return (&marks[c-'A'+26]);
-
+ if (c == '#')
+ return (&marks[MOUSEMARK]);
error("Invalid mark letter", NULL_PARG);
return (NULL);
}
/*
* Get the mark structure identified by a character.
- * The mark struct may come either from the mark table
+ * The mark struct may either be in the mark table (user mark)
* or may be constructed on the fly for certain characters like ^, $.
*/
static struct mark *
* Beginning of the current file.
*/
m = &sm;
- m->m_scrpos.pos = ch_zero();
- m->m_scrpos.ln = 0;
- m->m_ifile = curr_ifile;
+ cmark(m, curr_ifile, ch_zero(), 0);
break;
case '$':
/*
return (NULL);
}
m = &sm;
- m->m_scrpos.pos = ch_tell();
- m->m_scrpos.ln = sc_height;
- m->m_ifile = curr_ifile;
+ cmark(m, curr_ifile, ch_tell(), sc_height);
break;
case '.':
/*
*/
m = &sm;
get_scrpos(&m->m_scrpos, TOP);
- m->m_ifile = curr_ifile;
+ cmark(m, curr_ifile, m->m_scrpos.pos, m->m_scrpos.ln);
break;
case '\'':
/*
}
/*
- * Is a mark letter is invalid?
+ * Is a mark letter invalid?
*/
public int
badmark(c)
if (m == NULL)
return;
get_scrpos(&scrpos, where);
- m->m_scrpos = scrpos;
- m->m_ifile = curr_ifile;
+ if (scrpos.pos == NULL_POSITION)
+ {
+ bell();
+ return;
+ }
+ cmark(m, curr_ifile, scrpos.pos, scrpos.ln);
+ marks_modified = 1;
}
/*
m = getumark(c);
if (m == NULL)
return;
+ if (m->m_scrpos.pos == NULL_POSITION)
+ {
+ bell();
+ return;
+ }
m->m_scrpos.pos = NULL_POSITION;
+ marks_modified = 1;
}
/*
* Set lmark (the mark named by the apostrophe).
*/
public void
-lastmark()
+lastmark(VOID_PARAM)
{
struct scrpos scrpos;
get_scrpos(&scrpos, TOP);
if (scrpos.pos == NULL_POSITION)
return;
- marks[LASTMARK].m_scrpos = scrpos;
- marks[LASTMARK].m_ifile = curr_ifile;
+ cmark(&marks[LASTMARK], curr_ifile, scrpos.pos, scrpos.ln);
}
/*
* If we're trying to go to the lastmark and
* it has not been set to anything yet,
* set it to the beginning of the current file.
+ * {{ Couldn't we instead set marks[LASTMARK] in edit()? }}
*/
if (m == &marks[LASTMARK] && m->m_scrpos.pos == NULL_POSITION)
- {
- m->m_ifile = curr_ifile;
- m->m_scrpos.pos = ch_zero();
- m->m_scrpos.ln = jump_sline;
- }
+ cmark(m, curr_ifile, ch_zero(), jump_sline);
- /*
- * If we're using lmark, we must save the screen position now,
- * because if we call edit_ifile() below, lmark will change.
- * (We save the screen position even if we're not using lmark.)
- */
+ mark_get_ifile(m);
+
+ /* Save scrpos; if it's LASTMARK it could change in edit_ifile. */
scrpos = m->m_scrpos;
if (m->m_ifile != curr_ifile)
{
{
int i;
- /* Only lower case and upper case letters */
- for (i = 0; i < 26*2; i++)
+ /* Only user marks */
+ for (i = 0; i < NUMARKS; i++)
{
if (marks[i].m_ifile == curr_ifile && marks[i].m_scrpos.pos == pos)
{
if (i < 26) return 'a' + i;
- return 'A' + i - 26;
+ if (i < 26*2) return 'A' + (i - 26);
+ return '#';
}
}
return 0;
if (marks[i].m_ifile == ifile)
marks[i].m_scrpos.pos = NULL_POSITION;
}
+
+/*
+ * Check if any marks refer to a specified ifile vi m_filename
+ * rather than m_ifile.
+ */
+ public void
+mark_check_ifile(ifile)
+ IFILE ifile;
+{
+ int i;
+ char *filename = lrealpath(get_filename(ifile));
+
+ for (i = 0; i < NMARKS; i++)
+ {
+ struct mark *m = &marks[i];
+ char *mark_filename = m->m_filename;
+ if (mark_filename != NULL)
+ {
+ mark_filename = lrealpath(mark_filename);
+ if (strcmp(filename, mark_filename) == 0)
+ mark_set_ifile(m, ifile);
+ free(mark_filename);
+ }
+ }
+ free(filename);
+}
+
+#if CMD_HISTORY
+
+/*
+ * Save marks to history file.
+ */
+ public void
+save_marks(fout, hdr)
+ FILE *fout;
+ char *hdr;
+{
+ int i;
+
+ if (!perma_marks)
+ return;
+
+ fprintf(fout, "%s\n", hdr);
+ for (i = 0; i < NUMARKS; i++)
+ {
+ char *filename;
+ struct mark *m = &marks[i];
+ char pos_str[INT_STRLEN_BOUND(m->m_scrpos.pos) + 2];
+ if (m->m_scrpos.pos == NULL_POSITION)
+ continue;
+ postoa(m->m_scrpos.pos, pos_str);
+ filename = m->m_filename;
+ if (filename == NULL)
+ filename = get_filename(m->m_ifile);
+ filename = lrealpath(filename);
+ if (strcmp(filename, "-") != 0)
+ fprintf(fout, "m %c %d %s %s\n",
+ m->m_letter, m->m_scrpos.ln, pos_str, filename);
+ free(filename);
+ }
+}
+
+/*
+ * Restore one mark from the history file.
+ */
+ public void
+restore_mark(line)
+ char *line;
+{
+ struct mark *m;
+ int ln;
+ POSITION pos;
+
+#define skip_whitespace while (*line == ' ') line++
+ if (*line++ != 'm')
+ return;
+ skip_whitespace;
+ m = getumark(*line++);
+ if (m == NULL)
+ return;
+ skip_whitespace;
+ ln = lstrtoi(line, &line);
+ if (ln < 1)
+ ln = 1;
+ if (ln > sc_height)
+ ln = sc_height;
+ skip_whitespace;
+ pos = lstrtopos(line, &line);
+ skip_whitespace;
+ cmark(m, NULL_IFILE, pos, ln);
+ m->m_filename = save(line);
+}
+
+#endif /* CMD_HISTORY */
my $USAGE = <<__EOF__;
usage: mkutable [-n] [-f#] type... [--] [<] UnicodeData.txt
-n = take non-matching types
- -f = zero-based type field (default 2)
+ -f = zero-based type field (default 2)
__EOF__
use vars qw( $opt_f $opt_n );
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
extern long jump_sline_fraction;
extern int shift_count;
extern long shift_count_fraction;
-extern LWCHAR rscroll_char;
+extern char rscroll_char;
extern int rscroll_attr;
+extern int mousecap;
+extern int wheel_lines;
extern int less_is_more;
#if LOGFILE
extern char *namelogfile;
}
public void
-calc_jump_sline()
+calc_jump_sline(VOID_PARAM)
{
if (jump_sline_fraction < 0)
return;
}
}
public void
-calc_shift_count()
+calc_shift_count(VOID_PARAM)
{
if (shift_count_fraction < 0)
return;
putstr("less ");
putstr(version);
putstr(" (");
-#if HAVE_GNU_REGEX
- putstr("GNU ");
-#endif
-#if HAVE_POSIX_REGCOMP
- putstr("POSIX ");
-#endif
-#if HAVE_PCRE
- putstr("PCRE ");
-#endif
-#if HAVE_RE_COMP
- putstr("BSD ");
-#endif
-#if HAVE_REGCMP
- putstr("V8 ");
-#endif
-#if HAVE_V8_REGCOMP
- putstr("Spencer V8 ");
-#endif
-#if !HAVE_GNU_REGEX && !HAVE_POSIX_REGCOMP && !HAVE_PCRE && !HAVE_RE_COMP && !HAVE_REGCMP && !HAVE_V8_REGCOMP
- putstr("no ");
-#endif
- putstr("regular expressions)\n");
- putstr("Copyright (C) 1984-2017 Mark Nudelman\n\n");
+ putstr(pattern_lib_name());
+ putstr(" regular expressions)\n");
+ putstr("Copyright (C) 1984-2019 Mark Nudelman\n\n");
putstr("less comes with NO WARRANTY, to the extent permitted by law.\n");
putstr("For information about the terms of redistribution,\n");
putstr("see the file named README in the less distribution.\n");
- putstr("Homepage: http://www.greenwoodsoftware.com/less\n");
+ putstr("Home page: http://www.greenwoodsoftware.com/less\n");
quit(QUIT_OK);
break;
}
}
/*
+ * Handler for the --mouse option.
+ */
+ /*ARGSUSED*/
+ public void
+opt_mousecap(type, s)
+ int type;
+ char *s;
+{
+ switch (type)
+ {
+ case TOGGLE:
+ if (mousecap == OPT_OFF)
+ deinit_mouse();
+ else
+ init_mouse();
+ break;
+ case INIT:
+ case QUERY:
+ break;
+ }
+}
+
+/*
+ * Handler for the --wheel-lines option.
+ */
+ /*ARGSUSED*/
+ public void
+opt_wheel_lines(type, s)
+ int type;
+ char *s;
+{
+ switch (type)
+ {
+ case INIT:
+ case TOGGLE:
+ if (wheel_lines <= 0)
+ wheel_lines = default_wheel_lines();
+ break;
+ case QUERY:
+ break;
+ }
+}
+
+/*
* Get the "screen window" size.
*/
public int
-get_swindow()
+get_swindow(VOID_PARAM)
{
if (swindow > 0)
return (swindow);
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
if (s == NULL)
return;
if (*str == '+')
+ {
+ if (every_first_cmd != NULL)
+ free(every_first_cmd);
every_first_cmd = save(str+1);
- else
+ } else
{
ungetcc(CHAR_END_COMMAND);
ungetsc(str);
* the previous option.
*/
public int
-isoptpending()
+isoptpending(VOID_PARAM)
{
return (pendopt != NULL);
}
* Print error message if a STRING type option is not followed by a string.
*/
public void
-nopendopt()
+nopendopt(VOID_PARAM)
{
nostring(opt_desc(pendopt));
}
* Get the value of the -e flag.
*/
public int
-get_quit_at_eof()
+get_quit_at_eof(VOID_PARAM)
{
if (!less_is_more)
return quit_at_eof;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
public int follow_mode; /* F cmd Follows file desc or file name? */
public int oldbot; /* Old bottom of screen behavior {{REMOVE}} */
public int opt_use_backslash; /* Use backslash escaping in option parsing */
-public LWCHAR rscroll_char; /* Char which marks chopped lines with -S */
+public char rscroll_char; /* Char which marks chopped lines with -S */
public int rscroll_attr; /* Attribute of rscroll_char */
+public int no_hist_dups; /* Remove dups from history list */
+public int mousecap; /* Allow mouse for scrolling */
+public int wheel_lines; /* Number of lines to scroll on mouse wheel scroll */
+public int perma_marks; /* Save marks in history file */
#if HILITE_SEARCH
public int hilite_search; /* Highlight matched search patterns? */
#endif
static struct optname follow_optname = { "follow-name", NULL };
static struct optname use_backslash_optname = { "use-backslash", NULL };
static struct optname rscroll_optname = { "rscroll", NULL };
+static struct optname nohistdups_optname = { "no-histdups", NULL };
+static struct optname mousecap_optname = { "mouse", NULL };
+static struct optname wheel_lines_optname = { "wheel-lines", NULL };
+static struct optname perma_marks_optname = { "save-marks", NULL };
/*
STRING|REPAINT|INIT_HANDLER, 0, NULL, opt_rscroll,
{ "right scroll character: ", NULL, NULL }
},
+ { OLETTER_NONE, &nohistdups_optname,
+ BOOL, OPT_OFF, &no_hist_dups, NULL,
+ {
+ "Allow duplicates in history list",
+ "Remove duplicates from history list",
+ NULL
+ }
+ },
+ { OLETTER_NONE, &mousecap_optname,
+ TRIPLE, OPT_OFF, &mousecap, opt_mousecap,
+ {
+ "Ignore mouse input",
+ "Use the mouse for scrolling",
+ "Use the mouse for scrolling (reverse)"
+ }
+ },
+ { OLETTER_NONE, &wheel_lines_optname,
+ NUMBER|INIT_HANDLER, 0, &wheel_lines, opt_wheel_lines,
+ {
+ "Lines to scroll on mouse wheel: ",
+ "Scroll %d line(s) on mouse wheel",
+ NULL
+ }
+ },
+ { OLETTER_NONE, &perma_marks_optname,
+ BOOL, OPT_OFF, &perma_marks, NULL,
+ {
+ "Don't save marks in history file",
+ "Save marks in history file",
+ NULL
+ }
+ },
{ '\0', NULL, NOVAR, 0, NULL, NULL, { NULL, NULL, NULL } }
};
* Initialize each option to its default value.
*/
public void
-init_option()
+init_option(VOID_PARAM)
{
struct loption *o;
char *p;
p = lgetenv("LESS_IS_MORE");
- if (p != NULL && *p != '\0')
+ if (!isnullenv(p))
less_is_more = 1;
for (o = option; o->oletter != '\0'; o++)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Interrupt a pending iread().
*/
public void
-intread()
+intread(VOID_PARAM)
{
LONG_JUMP(read_label, 1);
}
*/
#if HAVE_TIME
public time_type
-get_time()
+get_time(VOID_PARAM)
{
time_type t;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Display the line which is in the line buffer.
*/
public void
-put_line()
+put_line(VOID_PARAM)
{
int c;
int i;
* overwritten or scrolled away.
*/
public void
-flush()
+flush(VOID_PARAM)
{
int n;
int fd;
TYPE_TO_A_FUNC(inttoa, int)
/*
+ * Convert an string to an integral type.
+ */
+#define STR_TO_TYPE_FUNC(funcname, type) \
+type funcname(buf, ebuf) \
+ char *buf; \
+ char **ebuf; \
+{ \
+ type val = 0; \
+ for (;;) { \
+ char c = *buf++; \
+ if (c < '0' || c > '9') break; \
+ val = 10 * val + c - '0'; \
+ } \
+ if (ebuf != NULL) *ebuf = buf; \
+ return val; \
+}
+
+STR_TO_TYPE_FUNC(lstrtopos, POSITION);
+STR_TO_TYPE_FUNC(lstrtoi, int);
+
+/*
* Output an integer in a given radix.
*/
static int
* become the next command.
*/
public void
-get_return()
+get_return(VOID_PARAM)
{
int c;
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#include "less.h"
extern int caseless;
+extern int utf_mode;
/*
* Compile a search pattern, for future use by match_pattern.
*comp_pattern = comp;
#endif
#if HAVE_PCRE
- pcre *comp;
constant char *errstring;
int erroffset;
PARG parg;
- comp = pcre_compile(pattern, 0,
+ pcre *comp = pcre_compile(pattern,
+ (utf_mode) ? PCRE_UTF8 | PCRE_NO_UTF8_CHECK : 0,
&errstring, &erroffset, NULL);
if (comp == NULL)
{
}
*comp_pattern = comp;
#endif
+#if HAVE_PCRE2
+ int errcode;
+ PCRE2_SIZE erroffset;
+ PARG parg;
+ pcre2_code *comp = pcre2_compile((PCRE2_SPTR)pattern, strlen(pattern),
+ 0, &errcode, &erroffset, NULL);
+ if (comp == NULL)
+ {
+ if (show_error)
+ {
+ char msg[160];
+ pcre2_get_error_message(errcode, (PCRE2_UCHAR*)msg, sizeof(msg));
+ parg.p_string = msg;
+ error("%s", &parg);
+ }
+ return (-1);
+ }
+ *comp_pattern = comp;
+#endif
#if HAVE_RE_COMP
PARG parg;
if ((parg.p_string = re_comp(pattern)) != NULL)
pcre_free(*pattern);
*pattern = NULL;
#endif
+#if HAVE_PCRE2
+ if (*pattern != NULL)
+ pcre2_code_free(*pattern);
+ *pattern = NULL;
+#endif
#if HAVE_RE_COMP
*pattern = 0;
#endif
#if HAVE_PCRE
return (pattern == NULL);
#endif
+#if HAVE_PCRE2
+ return (pattern == NULL);
+#endif
#if HAVE_RE_COMP
return (pattern == 0);
#endif
}
}
#endif
+#if HAVE_PCRE2
+ {
+ int flags = (notbol) ? PCRE2_NOTBOL : 0;
+ pcre2_match_data *md = pcre2_match_data_create(3, NULL);
+ matched = pcre2_match(pattern, (PCRE2_SPTR)line, line_len,
+ 0, flags, md, NULL) >= 0;
+ if (matched)
+ {
+ PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(md);
+ *sp = line + ovector[0];
+ *ep = line + ovector[1];
+ }
+ pcre2_match_data_free(md);
+ }
+#endif
#if HAVE_RE_COMP
matched = (re_exec(line) == 1);
/*
return (matched);
}
+/*
+ * Return the name of the pattern matching library.
+ */
+ public char *
+pattern_lib_name(VOID_PARAM)
+{
+#if HAVE_GNU_REGEX
+ return ("GNU");
+#else
+#if HAVE_POSIX_REGCOMP
+ return ("POSIX");
+#else
+#if HAVE_PCRE2
+ return ("PCRE2");
+#else
+#if HAVE_PCRE
+ return ("PCRE");
+#else
+#if HAVE_RE_COMP
+ return ("BSD");
+#else
+#if HAVE_REGCMP
+ return ("V8");
+#else
+#if HAVE_V8_REGCOMP
+ return ("Spencer V8");
+#else
+ return ("no");
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+}
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#define CLEAR_PATTERN(name) name = NULL
#endif
+#if HAVE_PCRE2
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include <pcre2.h>
+#define PATTERN_TYPE pcre2_code *
+#define CLEAR_PATTERN(name) name = NULL
+#endif
+
#if HAVE_RE_COMP
char *re_comp LESSPARAMS ((char*));
int re_exec LESSPARAMS ((char*));
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#include "position.h"
static POSITION *table = NULL; /* The position table */
-static int table_size;
+static int table_size = 0;
extern int sc_width, sc_height;
* Initialize the position table, done whenever we clear the screen.
*/
public void
-pos_clear()
+pos_clear(VOID_PARAM)
{
int i;
* Allocate or reallocate the position table.
*/
public void
-pos_init()
+pos_init(VOID_PARAM)
{
struct scrpos scrpos;
* See if the entire screen is empty.
*/
public int
-empty_screen()
+empty_screen(VOID_PARAM)
{
return (empty_lines(0, sc_height-1));
}
switch (where)
{
- case TOP: i = 0; dir = +1; last = sc_height-2; break;
- default: i = sc_height-2; dir = -1; last = 0; break;
+ case TOP:
+ i = 0; dir = +1; last = sc_height-2;
+ break;
+ case BOTTOM: case BOTTOM_PLUS_ONE:
+ i = sc_height-2; dir = -1; last = 0;
+ break;
+ default:
+ i = where;
+ if (table[i] == NULL_POSITION) {
+ scrpos->pos = NULL_POSITION;
+ return;
+ }
+ /* Values of dir and last don't matter after this. */
+ break;
}
/*
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Initialize the prompt prototype strings.
*/
public void
-init_prompt()
+init_prompt(VOID_PARAM)
{
prproto[0] = save(s_proto);
prproto[1] = save(less_is_more ? more_proto : m_proto);
* Append a question mark to the end of the message.
*/
static void
-ap_quest()
+ap_quest(VOID_PARAM)
{
ap_str("?");
}
case 'e': /* At end of file? */
return (eof_displayed());
case 'f': /* Filename known? */
+ case 'g':
return (strcmp(get_filename(curr_ifile), "-") != 0);
case 'l': /* Line number known? */
case 'd': /* Same as l */
- return (linenums);
+ if (!linenums)
+ return 0;
+ return (currline(where) != 0);
case 'L': /* Final line number known? */
case 'D': /* Final page number known? */
return (linenums && ch_length() != NULL_POSITION);
LINENUM linenum;
LINENUM last_linenum;
IFILE h;
+ char *s;
#undef PAGE_NUM
#define PAGE_NUM(linenum) ((((linenum) - 1) / (sc_height - 1)) + 1)
case 'F': /* Last component of file name */
ap_str(last_component(get_filename(curr_ifile)));
break;
+ case 'g': /* Shell-escaped file name */
+ s = shell_quote(get_filename(curr_ifile));
+ ap_str(s);
+ free(s);
+ break;
case 'i': /* Index into list of files */
#if TAGS
if (ntags())
* Return a message suitable for printing by the "=" command.
*/
public char *
-eq_message()
+eq_message(VOID_PARAM)
{
return (pr_expand(eqproto, 0));
}
* and the caller will prompt with a colon.
*/
public char *
-pr_string()
+pr_string(VOID_PARAM)
{
char *prompt;
int type;
* Return a message suitable for printing while waiting in the F command.
*/
public char *
-wait_message()
+wait_message(VOID_PARAM)
{
return (pr_expand(wproto, sc_width-so_s_width-so_e_width-2));
}
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
static int keyCount = 0;
static WORD curr_attr;
static int pending_scancode = 0;
-static WORD *whitescreen;
+static char x11mousebuf[] = "[M???"; /* Mouse report, after ESC */
+static int x11mousePos, x11mouseCount;
static HANDLE con_out_save = INVALID_HANDLE_VALUE; /* previous console */
static HANDLE con_out_ours = INVALID_HANDLE_VALUE; /* our own */
*sc_backspace, /* Backspace cursor */
*sc_s_keypad, /* Start keypad mode */
*sc_e_keypad, /* End keypad mode */
+ *sc_s_mousecap, /* Start mouse capture mode */
+ *sc_e_mousecap, /* End mouse capture mode */
*sc_init, /* Startup terminal initialization */
*sc_deinit; /* Exit terminal de-initialization */
#endif
public char *kent = NULL; /* Keypad ENTER sequence */
static int attrmode = AT_NORMAL;
+static int termcap_debug = -1;
extern int binattr;
-extern int line_count;
+extern int one_screen;
#if !MSDOS_COMPILER
static char *cheaper();
extern int sigs;
extern int wscroll;
extern int screen_trashed;
-extern int tty;
extern int top_scroll;
extern int quit_if_one_screen;
extern int oldbot;
+extern int mousecap;
#if HILITE_SEARCH
extern int hilite_search;
#endif
+#if MSDOS_COMPILER==WIN32C
+extern HANDLE tty;
+#else
+extern int tty;
+#endif
extern char *tgetstr();
extern char *tgoto();
ltget_env(capname)
char *capname;
{
- char name[16];
+ char name[64];
char *s;
- s = lgetenv("LESS_TERMCAP_DEBUG");
- if (s != NULL && *s != '\0')
+ if (termcap_debug)
{
struct env { struct env *next; char *name; char *value; };
static struct env *envs = NULL;
envs = p;
return p->value;
}
- strcpy(name, "LESS_TERMCAP_");
- strcat(name, capname);
+ SNPRINTF1(name, sizeof(name), "LESS_TERMCAP_%s", capname);
return (lgetenv(name));
}
* Get size of the output screen.
*/
public void
-scrsize()
+scrsize(VOID_PARAM)
{
char *s;
int sys_height;
* Figure out how many empty loops it takes to delay a millisecond.
*/
static void
-get_clock()
+get_clock(VOID_PARAM)
{
clock_t start;
* Delay for a specified number of milliseconds.
*/
static void
-dummy_func()
-{
- static long delay_dummy = 0;
- delay_dummy++;
-}
-
- static void
delay(msec)
int msec;
{
while (msec-- > 0)
{
for (i = 0; i < msec_loops; i++)
- {
- /*
- * Make it look like we're doing something here,
- * so the optimizer doesn't remove the whole loop.
- */
- dummy_func();
- }
+ (void) clock();
}
}
#endif
s = windowid ? ltgetstr("@7", &sp) : k_end;
break;
case SK_DELETE:
- if (windowid)
+ s = windowid ? ltgetstr("kD", &sp) : k_delete;
+ if (s == NULL)
{
- s = ltgetstr("kD", &sp);
- if (s == NULL)
- {
- tbuf[0] = '\177';
- tbuf[1] = '\0';
- s = tbuf;
- }
- } else
- s = k_delete;
+ tbuf[0] = '\177';
+ tbuf[1] = '\0';
+ s = tbuf;
+ }
break;
#endif
#if MSDOS_COMPILER
* Get terminal capabilities via termcap.
*/
public void
-get_term()
+get_term(VOID_PARAM)
{
+ termcap_debug = !isnullenv(lgetenv("LESS_TERMCAP_DEBUG"));
#if MSDOS_COMPILER
auto_wrap = 1;
ignaw = 0;
#else /* !MSDOS_COMPILER */
-
+{
char *sp;
char *t1, *t2;
char *term;
* Make sure the termcap database is available.
*/
sp = lgetenv("TERMCAP");
- if (sp == NULL || *sp == '\0')
+ if (isnullenv(sp))
{
char *termcap;
if ((sp = homefile("termcap.dat")) != NULL)
sc_e_keypad = "";
kent = ltgetstr("@8", &sp);
+ sc_s_mousecap = ltgetstr("MOUSE_START", &sp);
+ if (sc_s_mousecap == NULL)
+ sc_s_mousecap = ESCS "[?1000h" ESCS "[?1006h";
+ sc_e_mousecap = ltgetstr("MOUSE_END", &sp);
+ if (sc_e_mousecap == NULL)
+ sc_e_mousecap = ESCS "[?1006l" ESCS "[?1000l";
+
sc_init = ltgetstr("ti", &sp);
if (sc_init == NULL)
sc_init = "";
*/
no_back_scroll = 1;
}
+}
#endif /* MSDOS_COMPILER */
}
* Initialize the screen to the correct color at startup.
*/
static void
-initcolor()
+initcolor(VOID_PARAM)
{
#if MSDOS_COMPILER==BORLANDC || MSDOS_COMPILER==DJGPPC
intensevideo();
* Termcap-like init with a private win32 console.
*/
static void
-win32_init_term()
+win32_init_term(VOID_PARAM)
{
CONSOLE_SCREEN_BUFFER_INFO scr;
COORD size;
/*
* Restore the startup console.
*/
-static void
-win32_deinit_term()
+ static void
+win32_deinit_term(VOID_PARAM)
{
if (con_out_save == INVALID_HANDLE_VALUE)
return;
#endif
/*
+ * Configure the termimal so mouse clicks and wheel moves
+ * produce input to less.
+ */
+ public void
+init_mouse(VOID_PARAM)
+{
+ if (!mousecap)
+ return;
+#if !MSDOS_COMPILER
+ tputs(sc_s_mousecap, sc_height, putchr);
+#else
+#if MSDOS_COMPILER==WIN32C
+ SetConsoleMode(tty, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT);
+#endif
+#endif
+}
+
+/*
+ * Configure the terminal so mouse clicks and wheel moves
+ * are handled by the system (so text can be selected, etc).
+ */
+ public void
+deinit_mouse(VOID_PARAM)
+{
+ if (!mousecap)
+ return;
+#if !MSDOS_COMPILER
+ tputs(sc_e_mousecap, sc_height, putchr);
+#else
+#if MSDOS_COMPILER==WIN32C
+ SetConsoleMode(tty, ENABLE_PROCESSED_INPUT);
+#endif
+#endif
+}
+
+/*
* Initialize terminal
*/
public void
-init()
+init(VOID_PARAM)
{
#if !MSDOS_COMPILER
- if (quit_if_one_screen && line_count >= sc_height)
- quit_if_one_screen = FALSE;
- if (!no_init && !quit_if_one_screen)
- tputs(sc_init, sc_height, putchr);
- if (!no_keypad)
- tputs(sc_s_keypad, sc_height, putchr);
+ if (!(quit_if_one_screen && one_screen))
+ {
+ if (!no_init)
+ tputs(sc_init, sc_height, putchr);
+ if (!no_keypad)
+ tputs(sc_s_keypad, sc_height, putchr);
+ init_mouse();
+ }
if (top_scroll)
{
int i;
* Deinitialize terminal
*/
public void
-deinit()
+deinit(VOID_PARAM)
{
if (!init_done)
return;
#if !MSDOS_COMPILER
- if (!no_keypad)
- tputs(sc_e_keypad, sc_height, putchr);
- if (!no_init && !quit_if_one_screen)
- tputs(sc_deinit, sc_height, putchr);
+ if (!(quit_if_one_screen && one_screen))
+ {
+ deinit_mouse();
+ if (!no_keypad)
+ tputs(sc_e_keypad, sc_height, putchr);
+ if (!no_init)
+ tputs(sc_deinit, sc_height, putchr);
+ }
#else
/* Restore system colors. */
SETCOLORS(sy_fg_color, sy_bg_color);
* Home cursor (move to upper left corner of screen).
*/
public void
-home()
+home(VOID_PARAM)
{
#if !MSDOS_COMPILER
tputs(sc_home, 1, putchr);
* Should scroll the display down.
*/
public void
-add_line()
+add_line(VOID_PARAM)
{
#if !MSDOS_COMPILER
tputs(sc_addline, sc_height, putchr);
* Clear the screen.
*/
static void
-win32_clear()
+win32_clear(VOID_PARAM)
{
/*
* This will clear only the currently visible rows of the NT
* Move cursor to lower left corner of screen.
*/
public void
-lower_left()
+lower_left(VOID_PARAM)
{
if (!init_done)
return;
* Move cursor to left position of current line.
*/
public void
-line_left()
+line_left(VOID_PARAM)
{
#if !MSDOS_COMPILER
tputs(sc_return, 1, putchr);
* (in lieu of SIGWINCH for WIN32).
*/
public void
-check_winch()
+check_winch(VOID_PARAM)
{
#if MSDOS_COMPILER==WIN32C
CONSOLE_SCREEN_BUFFER_INFO scr;
* {{ Yuck! There must be a better way to get a visual bell. }}
*/
static void
-create_flash()
+create_flash(VOID_PARAM)
{
#if MSDOS_COMPILER==MSOFTC
struct videoconfig w;
return;
for (n = 0; n < sc_width * sc_height; n++)
whitescreen[n] = 0x7020;
-#else
-#if MSDOS_COMPILER==WIN32C
- int n;
-
- whitescreen = (WORD *)
- malloc(sc_height * sc_width * sizeof(WORD));
- if (whitescreen == NULL)
- return;
- /* Invert the standard colors. */
- for (n = 0; n < sc_width * sc_height; n++)
- whitescreen[n] = (WORD)((nm_fg_color << 4) | nm_bg_color);
-#endif
#endif
#endif
flash_created = 1;
* Output the "visual bell", if there is one.
*/
public void
-vbell()
+vbell(VOID_PARAM)
{
#if !MSDOS_COMPILER
if (*sc_visual_bell == '\0')
* Make a noise.
*/
static void
-beep()
+beep(VOID_PARAM)
{
#if !MSDOS_COMPILER
putchr(CONTROL('G'));
* Ring the terminal bell.
*/
public void
-bell()
+bell(VOID_PARAM)
{
if (quiet == VERY_QUIET)
vbell();
* Clear the screen.
*/
public void
-clear()
+clear(VOID_PARAM)
{
#if !MSDOS_COMPILER
tputs(sc_clear, sc_height, putchr);
* {{ This must not move the cursor. }}
*/
public void
-clear_eol()
+clear_eol(VOID_PARAM)
{
#if !MSDOS_COMPILER
tputs(sc_eol_clear, 1, putchr);
* Clear the screen if there's off-screen memory below the display.
*/
static void
-clear_eol_bot()
+clear_eol_bot(VOID_PARAM)
{
#if MSDOS_COMPILER
clear_eol();
* Leave the cursor at the beginning of the bottom line.
*/
public void
-clear_bot()
+clear_bot(VOID_PARAM)
{
/*
* If we're in a non-normal attribute mode, temporarily exit
}
public void
-at_exit()
+at_exit(VOID_PARAM)
{
#if !MSDOS_COMPILER
/* Undo things in the reverse order we did them. */
* and move the cursor left.
*/
public void
-backspace()
+backspace(VOID_PARAM)
{
#if !MSDOS_COMPILER
/*
* Output a plain backspace, without erasing the previous char.
*/
public void
-putbs()
+putbs(VOID_PARAM)
{
+ if (termcap_debug)
+ putstr("<bs>");
+ else
+ {
#if !MSDOS_COMPILER
tputs(sc_backspace, 1, putchr);
#else
return;
_settextposition(row, col-1);
#endif /* MSDOS_COMPILER */
+ }
}
#if MSDOS_COMPILER==WIN32C
/*
* Determine whether an input character is waiting to be read.
*/
- static int
-win32_kbhit(tty)
- HANDLE tty;
+ public int
+win32_kbhit(VOID_PARAM)
{
INPUT_RECORD ip;
DWORD read;
currentKey.ascii = 0;
currentKey.scan = 0;
+ if (x11mouseCount > 0)
+ {
+ currentKey.ascii = x11mousebuf[x11mousePos++];
+ --x11mouseCount;
+ keyCount = 1;
+ return (TRUE);
+ }
+
/*
* Wait for a real key-down event, but
* ignore SHIFT and CONTROL key events.
if (read == 0)
return (FALSE);
ReadConsoleInput(tty, &ip, 1, &read);
+ /* generate an X11 mouse sequence from the mouse event */
+ if (mousecap && ip.EventType == MOUSE_EVENT &&
+ ip.Event.MouseEvent.dwEventFlags != MOUSE_MOVED)
+ {
+ x11mousebuf[3] = X11MOUSE_OFFSET + ip.Event.MouseEvent.dwMousePosition.X + 1;
+ x11mousebuf[4] = X11MOUSE_OFFSET + ip.Event.MouseEvent.dwMousePosition.Y + 1;
+ switch (ip.Event.MouseEvent.dwEventFlags)
+ {
+ case 0: /* press or release */
+ if (ip.Event.MouseEvent.dwButtonState == 0)
+ x11mousebuf[2] = X11MOUSE_OFFSET + X11MOUSE_BUTTON_REL;
+ else if (ip.Event.MouseEvent.dwButtonState & (FROM_LEFT_3RD_BUTTON_PRESSED | FROM_LEFT_4TH_BUTTON_PRESSED))
+ continue;
+ else
+ x11mousebuf[2] = X11MOUSE_OFFSET + X11MOUSE_BUTTON1 + ((int)ip.Event.MouseEvent.dwButtonState << 1);
+ break;
+ case MOUSE_WHEELED:
+ x11mousebuf[2] = X11MOUSE_OFFSET + (((int)ip.Event.MouseEvent.dwButtonState < 0) ? X11MOUSE_WHEEL_DOWN : X11MOUSE_WHEEL_UP);
+ break;
+ default:
+ continue;
+ }
+ x11mousePos = 0;
+ x11mouseCount = 5;
+ currentKey.ascii = ESC;
+ keyCount = 1;
+ return (TRUE);
+ }
} while (ip.EventType != KEY_EVENT ||
ip.Event.KeyEvent.bKeyDown != TRUE ||
ip.Event.KeyEvent.wVirtualScanCode == 0 ||
* Read a character from the keyboard.
*/
public char
-WIN32getch(tty)
- int tty;
+WIN32getch(VOID_PARAM)
{
int ascii;
return ((char)(currentKey.scan & 0x00FF));
}
- while (win32_kbhit((HANDLE)tty) == FALSE)
- {
- Sleep(20);
- if (ABORT_SIGS())
- return ('\003');
- continue;
- }
- keyCount --;
- ascii = currentKey.ascii;
- /*
- * On PC's, the extended keys return a 2 byte sequence beginning
- * with '00', so if the ascii code is 00, the next byte will be
- * the lsb of the scan code.
- */
- pending_scancode = (ascii == 0x00);
+ do {
+ while (win32_kbhit() == FALSE)
+ {
+ Sleep(20);
+ if (ABORT_SIGS())
+ return ('\003');
+ continue;
+ }
+ keyCount --;
+ ascii = currentKey.ascii;
+ /*
+ * On PC's, the extended keys return a 2 byte sequence beginning
+ * with '00', so if the ascii code is 00, the next byte will be
+ * the lsb of the scan code.
+ */
+ pending_scancode = (ascii == 0x00);
+ } while (pending_scancode &&
+ (currentKey.scan == PCK_CAPS_LOCK || currentKey.scan == PCK_NUM_LOCK));
+
return ((char)ascii);
}
#endif
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
* Initialize search variables.
*/
public void
-init_search()
+init_search(VOID_PARAM)
{
init_pattern(&search_info);
init_pattern(&filter_info);
* Determine which text conversions to perform before pattern matching.
*/
static int
-get_cvt_ops()
+get_cvt_ops(VOID_PARAM)
{
int ops = 0;
if (is_caseless || bs_mode == BS_SPECIAL)
* Clear the attn hilite.
*/
public void
-clear_attn()
+clear_attn(VOID_PARAM)
{
int sindex;
POSITION old_start_attnpos;
* Hide search string highlighting.
*/
public void
-undo_search()
+undo_search(VOID_PARAM)
{
if (!prev_pattern(&search_info))
{
}
public void
-clr_hilite()
+clr_hilite(VOID_PARAM)
{
clr_hlist(&hilite_anchor);
}
public void
-clr_filter()
+clr_filter(VOID_PARAM)
{
clr_hlist(&filter_anchor);
}
* Find matching text which is currently on screen and highlight it.
*/
static void
-hilite_screen()
+hilite_screen(VOID_PARAM)
{
struct scrpos scrpos;
* Change highlighting parameters.
*/
public void
-chg_hilite()
+chg_hilite(VOID_PARAM)
{
/*
* Erase any highlights currently on screen.
* Updates the internal search state to reflect a change in the -i flag.
*/
public void
-chg_caseless()
+chg_caseless(VOID_PARAM)
{
if (!is_ucase_pattern)
/*
* Is there a line filter in effect?
*/
public int
-is_filtering()
+is_filtering(VOID_PARAM)
{
if (ch_getflags() & CH_HELPFILE)
return (0);
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
/*
* Interrupt signal handler.
*/
+#if MSDOS_COMPILER!=WIN32C
/* ARGSUSED*/
static RETSIGTYPE
u_interrupt(type)
if (reading)
intread(); /* May longjmp */
}
+#endif
#ifdef SIGTSTP
/*
/*
* Handle CTRL-C and CTRL-BREAK keys.
*/
-#include "windows.h"
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
static BOOL WINAPI
wbreak_handler(dwCtrlType)
/*
* Set signal handlers.
*/
- (void) LSIGNAL(SIGINT, u_interrupt);
#if MSDOS_COMPILER==WIN32C
SetConsoleCtrlHandler(wbreak_handler, TRUE);
+#else
+ (void) LSIGNAL(SIGINT, u_interrupt);
#endif
#ifdef SIGTSTP
(void) LSIGNAL(SIGTSTP, stop);
/*
* Restore signals to defaults.
*/
- (void) LSIGNAL(SIGINT, SIG_DFL);
#if MSDOS_COMPILER==WIN32C
SetConsoleCtrlHandler(wbreak_handler, FALSE);
+#else
+ (void) LSIGNAL(SIGINT, SIG_DFL);
#endif
#ifdef SIGTSTP
(void) LSIGNAL(SIGTSTP, SIG_DFL);
* A received signal cause a bit to be set in "sigs".
*/
public void
-psignals()
+psignals(VOID_PARAM)
{
int tsignals;
wscroll = (sc_height + 1) / 2;
calc_jump_sline();
calc_shift_count();
- screen_trashed = 1;
}
+ screen_trashed = 1;
}
#endif
if (tsignals & S_INTERRUPT)
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
enum {
T_CTAGS, /* 'tags': standard and extended format (ctags) */
T_CTAGS_X, /* stdin: cross reference format (ctags) */
- T_GTAGS, /* 'GTAGS': function defenition (global) */
+ T_GTAGS, /* 'GTAGS': function definition (global) */
T_GRTAGS, /* 'GRTAGS': function reference (global) */
T_GSYMS, /* 'GSYMS': other symbols (global) */
T_GPATH /* 'GPATH': path name (global) */
* Delete tag structures.
*/
public void
-cleantags()
+cleantags(VOID_PARAM)
{
struct tag *tp;
* Get tag mode.
*/
public int
-gettagtype()
+gettagtype(VOID_PARAM)
{
int f;
* Search for a tag.
*/
public POSITION
-tagsearch()
+tagsearch(VOID_PARAM)
{
if (curtag == NULL)
return (NULL_POSITION); /* No gtags loaded! */
* Return the total number of tags.
*/
public int
-ntags()
+ntags(VOID_PARAM)
{
return total;
}
* Return the sequence number of current tag.
*/
public int
-curr_tag()
+curr_tag(VOID_PARAM)
{
return curseq;
}
* Edit current tagged file.
*/
public int
-edit_tagfile()
+edit_tagfile(VOID_PARAM)
{
if (curtag == NULL)
return (1);
* parentheses (which are almost always found in a tag).
*/
static POSITION
-ctagsearch()
+ctagsearch(VOID_PARAM)
{
POSITION pos, linepos;
LINENUM linenum;
char *qtag;
char *cmd = lgetenv("LESSGLOBALTAGS");
- if (cmd == NULL || *cmd == '\0')
+ if (isnullenv(cmd))
return TAG_NOFILE;
/* Get suitable flag value for global(1). */
switch (type)
* appropriate tag.
*/
static char *
-nextgtag()
+nextgtag(VOID_PARAM)
{
struct tag *tp;
* at the appropriate tag.
*/
static char *
-prevgtag()
+prevgtag(VOID_PARAM)
{
struct tag *tp;
* if it was unable to position at the tag, 0 if successful.
*/
static POSITION
-gtagsearch()
+gtagsearch(VOID_PARAM)
{
if (curtag == NULL)
return (NULL_POSITION); /* No gtags loaded! */
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
#include "pckeys.h"
#endif
#if MSDOS_COMPILER==WIN32C
-#include "windows.h"
-extern char WIN32getch();
-static DWORD console_mode;
+#define WIN32_LEAN_AND_MEAN
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x400
#endif
-
+#include <windows.h>
+static DWORD console_mode;
+public HANDLE tty;
+#else
public int tty;
+#endif
extern int sigs;
extern int utf_mode;
+extern int wheel_lines;
/*
* Open keyboard for input.
*/
public void
-open_getchr()
+open_getchr(VOID_PARAM)
{
#if MSDOS_COMPILER==WIN32C
/* Need this to let child processes inherit our console handle */
memset(&sa, 0, sizeof(SECURITY_ATTRIBUTES));
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
- tty = (int) CreateFile("CONIN$", GENERIC_READ,
+ tty = CreateFile("CONIN$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ, &sa,
OPEN_EXISTING, 0L, NULL);
- GetConsoleMode((HANDLE)tty, &console_mode);
+ GetConsoleMode(tty, &console_mode);
/* Make sure we get Ctrl+C events. */
- SetConsoleMode((HANDLE)tty, ENABLE_PROCESSED_INPUT);
+ SetConsoleMode(tty, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT);
#else
#if MSDOS_COMPILER
extern int fd0;
* Close the keyboard.
*/
public void
-close_getchr()
+close_getchr(VOID_PARAM)
+{
+#if MSDOS_COMPILER==WIN32C
+ SetConsoleMode(tty, console_mode);
+ CloseHandle(tty);
+#endif
+}
+
+#if MSDOS_COMPILER==WIN32C
+/*
+ * Close the pipe, restoring the keyboard (CMD resets it, losing the mouse).
+ */
+ int
+pclose(f)
+ FILE *f;
+{
+ int result;
+
+ result = _pclose(f);
+ SetConsoleMode(tty, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT);
+ return result;
+}
+#endif
+
+/*
+ * Get the number of lines to scroll when mouse wheel is moved.
+ */
+ public int
+default_wheel_lines(VOID_PARAM)
{
+ int lines = 1;
#if MSDOS_COMPILER==WIN32C
- SetConsoleMode((HANDLE)tty, console_mode);
- CloseHandle((HANDLE)tty);
+ if (SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &lines, 0))
+ {
+ if (lines == WHEEL_PAGESCROLL)
+ lines = 3;
+ }
#endif
+ return lines;
}
/*
* Get a character from the keyboard.
*/
public int
-getchr()
+getchr(VOID_PARAM)
{
char c;
int result;
#if MSDOS_COMPILER==WIN32C
if (ABORT_SIGS())
return (READ_INTR);
- c = WIN32getch(tty);
+ c = WIN32getch();
#else
c = getch();
#endif
else if (c >= 'A' && c <= 'F')
v = c - 'A' + 10;
else
- hex_in = 0;
+ v = 0;
hex_value = (hex_value << 4) | v;
if (--hex_in > 0)
{
-/* Generated by "./mkutable -f2 Cc Cs Co Zl Zp -- unicode/UnicodeData.txt" on Tue Jul 25 09:04:35 PDT 2017 */
+/* Generated by "./mkutable -f2 Cc Cs Co Zl Zp -- unicode/UnicodeData.txt" on Wed Feb 13 17:57:06 PST 2019 */
{ 0x0000, 0x0007 }, /* Cc */
{ 0x000b, 0x000b }, /* Cc */
{ 0x000e, 0x001f }, /* Cc */
/*
- * Copyright (C) 1984-2017 Mark Nudelman
+ * Copyright (C) 1984-2019 Mark Nudelman
*
* You may distribute under the terms of either the GNU General Public
* License or the Less License, as specified in the README file.
v528 11/3/17 Make second ESC-u clear status column.
v529 11/12/17 Display Unicode formatting chars in hex if -U is set.
v530 12/2/17 Minor doc change and add missing VOID_PARAM.
+-----------------------------------------------------------------
+v531 5/13/18 Fix bug with v on empty file; fix bug with v on file with
+ metachars in name; add --nohistdups option.
+v532 7/27/18 Redraw screen on SIGWINCH even if screen size doesn't change.
+v533 8/1/18 Shell escape filenames in history; use PCRE_UTF8 flag;
+ use wide-chars for Windows console title (thanks to Jason Hood).
+v534 8/9/18 Support PCRE2.
+v535 8/16/18 Don't count lines of initial screen if using -X with -F
+ (thanks to Linus Torvalds).
+v536 8/31/18 Use descriptive error messages for PCRE2.
+v537 8/31/18 Support mingw build system (thanks to Mike Soyka).
+v538 9/3/18 Clean up some WIN32 code.
+v539 9/13/18 Fix spurious input on Windows with CAPSLOCK.
+v540 10/29/18 Add --mouse option.
+v541 10/30/18 Add --MOUSE option.
+v542 11/6/18 Add mouse support for WIN32; add --wheel-lines option.
+ (thanks to Jason Hood).
+v543 11/12/18 Code cleanup.
+v544 11/16/18 Don't init/deinit keyboard/mouse if quit due to -F.
+v545 11/22/18 Fix Windows build, memory leaks.
+v546 11/29/18 Add --save-marks option.
+v547 11/30/18 Fix some bugs with saved marks.
+v548 12/14/18 Ignore mouse input when line editing.
+v549 2/10/19 Support X11 mouse extension 1006;
+ Win32 fixes (thanks to Jason Hood).
+v550 2/16/19 Fix Win32 build; don't enable mouse unless --mouse is set.
+v551 6/10/19 Doc changes.
*/
-char version[] = "530";
+char version[] = "551";
-/* Generated by "./mkutable -f1 W F -- unicode/EastAsianWidth.txt" on Tue Jul 25 09:04:35 PDT 2017 */
+/* Generated by "./mkutable -f1 W F -- unicode/EastAsianWidth.txt" on Thu Feb 14 08:30:47 PST 2019 */
{ 0x1100, 0x115f }, /* W */
{ 0x231a, 0x231b }, /* W */
{ 0x2329, 0x232a }, /* W */
{ 0x3001, 0x303e }, /* W */
{ 0x3041, 0x3096 }, /* W */
{ 0x3099, 0x30ff }, /* W */
- { 0x3105, 0x312e }, /* W */
+ { 0x3105, 0x312f }, /* W */
{ 0x3131, 0x318e }, /* W */
{ 0x3190, 0x31ba }, /* W */
{ 0x31c0, 0x31e3 }, /* W */
{ 0xff01, 0xff60 }, /* F */
{ 0xffe0, 0xffe6 }, /* F */
{ 0x16fe0, 0x16fe1 }, /* W */
- { 0x17000, 0x187ec }, /* W */
+ { 0x17000, 0x187f1 }, /* W */
{ 0x18800, 0x18af2 }, /* W */
{ 0x1b000, 0x1b11e }, /* W */
{ 0x1b170, 0x1b2fb }, /* W */
{ 0x1f6cc, 0x1f6cc }, /* W */
{ 0x1f6d0, 0x1f6d2 }, /* W */
{ 0x1f6eb, 0x1f6ec }, /* W */
- { 0x1f6f4, 0x1f6f8 }, /* W */
+ { 0x1f6f4, 0x1f6f9 }, /* W */
{ 0x1f910, 0x1f93e }, /* W */
- { 0x1f940, 0x1f94c }, /* W */
- { 0x1f950, 0x1f96b }, /* W */
- { 0x1f980, 0x1f997 }, /* W */
- { 0x1f9c0, 0x1f9c0 }, /* W */
- { 0x1f9d0, 0x1f9e6 }, /* W */
+ { 0x1f940, 0x1f970 }, /* W */
+ { 0x1f973, 0x1f976 }, /* W */
+ { 0x1f97a, 0x1f97a }, /* W */
+ { 0x1f97c, 0x1f9a2 }, /* W */
+ { 0x1f9b0, 0x1f9b9 }, /* W */
+ { 0x1f9c0, 0x1f9c2 }, /* W */
+ { 0x1f9d0, 0x1f9ff }, /* W */
{ 0x20000, 0x2fffd }, /* W */
{ 0x30000, 0x3fffd }, /* W */
projects / platform / upstream / less.git / commitdiff